Mit einer cleveren Idee und einem engagierten Team...

Read more

Im Szenario einer Ablösung vom BizTalk Server 2016...

Read more

Neben der herkömmlichen, vierjährigen Ausbildung...

Read more

Bei Datenübertragungen stossen wir teilweise an...

Read more

Durable Function ist eine Erweiterung der...

Read more

Wir haben eine gute, vor allem spannende und hoch...

Read more

Am 09.05.2022 wurde ein Artikel von Microsoft...

Read more

Neben den altbekannten Logic Apps (Consumption),...

Read more

Im Jahr 2022 fallen eine Reihe von .Net Versionen...

Read more

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

Read more

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

© QUIBIQ GmbH · Imprint · Data protection