CONNECTED Conference 2023 - Aufzeichnungen jetzt hier verfügbar +++                     

Suche

über alle News und Events

 

Alle News

 

Für Entwickler, Architekten, Projektleiter und...

Weiterlesen

In der Welt der Softwareentwicklung ist die...

Weiterlesen

QUIBIQ spendet für den guten Zweck – und für...

Weiterlesen

Eine bestimmte Antwort auf einen HTTP Request zu...

Weiterlesen

In einer Welt, die von stetigem Wandel geprägt...

Weiterlesen

In einem unserer Kundenprojekte, war das Ziel eine...

Weiterlesen

QUIBIQ Hamburg wird mit dem Hamburger...

Weiterlesen

Zwei Tage lang wurde vom 14.-15.11 wieder das...

Weiterlesen

Was ist ein Excel-Plugin – und wann ist es...

Weiterlesen

Wir expandieren, bringen Kunden und Talente besser...

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