Suche

über alle News und Events

 

Alle News

 

SAP in die Power Platform integrieren – In einem...

Weiterlesen

In BizTalk gibt es einige Alternativen, wie...

Weiterlesen

Wir sind auf ein seltsames Phänomen bei einem...

Weiterlesen

Nach der Migration konnten in VS 2019 „normale“...

Weiterlesen

Warum wir uns als Sponsor engagieren, warum und...

Weiterlesen

Für einen Kunden sollen Produktkataloge im XML...

Weiterlesen

Nach 2015 wird die QUIBIQ Schweiz im Jahr 2022...

Weiterlesen

Microsoft hat den Mainstream-Support bis zum 11....

Weiterlesen

Zwei Tage im Zeichen der Integration auf der...

Weiterlesen

Zwei Tage im Zeichen der Integration auf der...

Weiterlesen

How-to: BizTalk Object Messages mit .NET Klassen

In BizTalk gibt es einige Alternativen, wie Messages aufgebaut werden können.

In BizTalk gibt es einige Alternativen, wie Messages aufgebaut werden können.

Am häufigsten auf Basis XSD-Schema:
https://docs.microsoft.com/en-us/biztalk/core/messages-represented-as-xsd-schemas

Weiterhin in den internen Repräsentationen.
In Orchestrations auf Basis XLANGMessage:
https://docs.microsoft.com/en-us/biztalk/core/messages-represented-as-xlangmessage

In Pipelines auf Basis IBaseMessage:
https://docs.microsoft.com/en-us/biztalk/core/ibasemessage-interface

Es gibt auch die Möglichkeit, Messages auf Basis von .NET Klassen (als .NET Objects) zu erzeugen:
https://docs.microsoft.com/en-us/biztalk/core/messages-represented-as-net-classes.

Wie es mit .NET Klassen geht, soll im Folgenden kurz veranschaulicht werden.

Die Felder FirstName und LastName als String, YearOfBirth als Int.

Als .NET Klasse würde man in der einfachsten Form die Person so formulieren.

       [Serializable]
       publicclassPersonObj
       {
              public PersonObj() {}

              [DistinguishedField()]
              publicString FirstName;

              [DistinguishedField()]
              publicString LastName;

              [DistinguishedField()]
              publicInt32 YearOfBirth;
       }

Hierbei sind wichtig:

  • Das [Serializable] Attribute.
  • Der public default Konstruktor public PersonObj() {}.

Falls auf Felder als Distinguished Field zugegriffen werden soll, können sie mit [DistinguishedField()] attributiert werden. Auf Basis dieser Klasse kann nun in einer Orchestration eine Message deklariert werden

Als Beispiel nehmen wir ein simples Person-Modell. Als XSD im BizTalk Schema-Editor so:

Und in einem Assignment Shape wie folgt erstellt und die Felder gesetzt werden:

Mit so erstellten Messages kann sehr bequem in .NET Code gearbeitet werden, direkt mit den Klasseninstanzen, ohne sich mit Xml zu mühen. D.h. wer ohnehin Arbeit in .NET Helpern verrichtet, kann hier bereits einen Vorteil haben. Die so definierte Message wird allerdings von BizTalk, wie auch andere Messages, als Xml serialisiert und sieht “ganz normal“ aus.

<?xmlversion="1.0"?>
<PersonObj
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <FirstName>Max</FirstName>
  <LastName>Mustermann</LastName>
  <YearOfBirth>2022</YearOfBirth>
</PersonObj>

Richtig interessant wird es, wenn man für die BizTalk interne Message Serialisierung einen eigenen Formatter implementiert.

       [Serializable]
       [
CustomFormatter(typeof(PersonObjFormatter))]
       publicclassPersonObj
       {
              public PersonObj() {}
 

              [XmlIgnore]
              [
DistinguishedField()]
              publicString FirstName;


              [XmlIgnore]
              [
DistinguishedField()]
              publicString LastName;

              [XmlIgnore]
              [
DistinguishedField()]
              publicInt32 YearOfBirth;
       }

       publicclassPersonObjFormatter : IFormatter
       {
              publicSerializationBinder Binder
              {

                     get { thrownewNotSupportedException(); }
                     set { thrownewNotSupportedException(); }
              }

              publicStreamingContext Context
              {

                     get { thrownewNotSupportedException(); }
                     set { thrownewNotSupportedException(); }
              }

              publicISurrogateSelector SurrogateSelector
              {

                     get { thrownewNotSupportedException(); }
                     set { thrownewNotSupportedException(); }
              }

              publicobject Deserialize(Stream serializationStream)
              {

                     PersonObj personObj = newPersonObj();
                     BinaryReader r = newBinaryReader(serializationStream);
                     personObj.FirstName = r.ReadString();
                     personObj.LastName = r.ReadString();
                     personObj.YearOfBirth = r.ReadInt32();

                     return personObj;
              }

              publicvoid Serialize(Stream serializationStream, object graph)
              {

                     PersonObj personObj = (PersonObj)graph;
                     BinaryWriter w = newBinaryWriter(serializationStream);
                     w.Write(personObj.FirstName);
                     w.Write(personObj.LastName);

                     w.Write(personObj.YearOfBirth);
              }
       }

Hierbei sind wichtig:

  • Der custom Formatter PersonObjFormatter, der das IFormatter Interface implementiert.
  • Die entsprechende Attributierung [CustomFormatter(typeof(PersonObjFormatter))] der PersonObj Klasse.
  • Mit dem [XmlIgnore] Attribut wird das Felder-Handling durch den Xml Serializer verhindert.
  • Die Deserialize und die Serialize Methoden des Formatters implementieren das Handling der binär serialisierten Nachricht.

Eine so definierte Person-Message wird nun von BizTalk binär serialisiert und sieht so aus (als Hex):

Die serialisierte Nachricht ist jetzt nur 19 Byte gross, im Vergleich dazu die Grösse der gleichen Nachricht als Xml = 173 Byte! Das kann auch sehr schön in der BizTalkMsgBoxDb geprüft werden.

Zum Abschluss ein paar mögliche Vorteile auf .NET Klassen basierender Nachrichten:

  • Vereinfachte Arbeit mit den Messages in .NET Helpern (in komplexen Szenarien).
  • Höhere Performance (besonders bei großen Messages) da schnellere Serialisierung/Deserialisierung im Vergleich zu XML, sowie geringerer Datentransfer.
  • Deutlich geringere Speichergröße (je größer die Messages, desto klarer der Vorteil).
  • Der Serialisierungs-Mechanismus erlaubt es auf einfache Art, beliebigen Message-Output zu erzeugen und beliebigen Message-Input zu konsumieren. z.B. Plain Text, spezifische Dateiformate, binäre Streams.

Viel Freude beim Programmieren mit BizTalk Object Messages!

Plamen Petrow
QUIBIQ Schweiz

Ihre Kontaktmöglichkeiten

Sie haben eine konkrete Frage an uns


 

Bleiben Sie immer auf dem Laufenden


 

Mit meinem "Ja" erkläre ich mich mit der Verarbeitung meiner Daten zur Zusendung von Informationen einverstanden. Ich weiß, dass ich diese Erklärung jederzeit durch einfache Mitteilung widerrufen kann. Bei einem Nein an dieser Stelle erhalte ich zukünftig keine Informationen mehr.

© QUIBIQ GmbH · Impressum · Datenschutz