Freigeben über

Optimieren der Orchestrierungsleistung

In diesem Thema werden bewährte Methoden für die Verwendung von Orchestrierungen in BizTalk Server-Lösungen beschrieben. Dies umfasst Empfehlungen für:

  • Verringern der Latenz von BizTalk Server-Lösungen, die Orchestrierungen verwenden

    • Eliminierung von Orchestrierungen nur für Messagingmuster

    • Verwenden von Inlinesendungen von Orchestrierungen

    • Minimierung von Persistenzpunkten in der Orchestrierung

  • Verschachtelte Orchestrierungen

  • Orchestrierungsdesignmuster

  • Orchestrierungs-Ausnahmebehandlungsblöcke

Empfehlungen für die Optimierung von Orchestrierungen für Szenarien mit geringer Latenz

Die folgenden Techniken können verwendet werden, um die Latenz von BizTalk Server-Lösungen zu reduzieren, die Orchestrierungen verwenden.

Beseitigen von Orchestrierungen bei reinen Kommunikationsmustern.

Minimieren Sie nach Möglichkeit die Verwendung von Orchestrierungen, um den Gesamtdurchsatz zu erhöhen und die Latenz von Geschäftsprozessen zu verringern. Wenn es nicht erforderlich ist, langlaufende Transaktionen auszuführen, und mehrere Systeme nicht für jede Anforderung aufgerufen werden müssen, sollten Sie erwägen, die Orchestrierung zu vermeiden und die Geschäftslogik in die Empfangs- und Sendeports zu verschieben, um die Anzahl der Round-Trip-Kommunikationen mit der BizTalkMsgBoxDb zu reduzieren und die Latenz infolge des Datenbankzugriffs zu verringern. Implementieren Sie in diesem Fall benutzerdefinierte Pipelines und wiederverwenden Sie Hilfsklassen, die zuvor in Orchestrierungen verwendet wurden. Verwenden Sie Orchestrierungen nur dann, wenn sie streng erforderlich sind, um Designmuster wie Scatter/Gather-Muster oder Konvois zu implementieren. Weitere Informationen zu Orchestration Design Patterns finden Sie im Thema Implementieren von Designmustern in Orchestrationen (https://go.microsoft.com/fwlink/?LinkId=140042) in der BizTalk Server-Dokumentation.

Verwenden von Inlinesendungen von Orchestrierungen zur Aufnahme von Szenarien mit geringer Latenz

Minimieren Sie nach Möglichkeit die Verwendung von Orchestrierungslösungen und bevorzugen Sie nur Messaging-Mustern, um den Gesamtdurchsatz zu erhöhen und die Latenz der Geschäftsprozesse zu verringern. Wenn keine langen Transaktionen erforderlich sind und keine Geschäftslogik mehrere Systeme aufrufen muss, sollten Sie die Geschäftslogik verschieben, um Ports zu empfangen und zu senden und die Verwendung von Orchestrierungen zu beseitigen. Dieser Ansatz kann mit benutzerdefinierten Pipelines implementiert werden, die die zuvor aus Orchestrierungen aufgerufenen Hilfsklassen wiederverwenden. Um eine bessere Leistung in Szenarien mit geringer Latenz zu erzielen, führen Sie einen der folgenden Ansätze aus:

  • Vermeiden Sie unnötige Orchestrierungen und übernehmen Sie ausschließlich Messaging-Muster, um die Anzahl der Roundtrips in die BizTalk MessageBox-Datenbank zu reduzieren. Dieser Ansatz bietet eine geringe Latenz, da Inlinesendungen das BizTalk-Messagingmodul und den damit verbundenen Aufwand umgehen. Die Inline-Sendefunktion wird mit BizTalk Server 2006 und höher bereitgestellt.

  • Beseitigen Sie innerhalb von Orchestrierungen logische Ports, die an physische Ports gebunden sind, und verwenden Sie stattdessen Inline-Sendungen. Beispielsweise könnte eine Inlinesendung verwendet werden, um eine Instanz einer WCF-Proxyklasse zu erstellen, um einen nachgeschalteten Webdienst oder eine ADO.NET Komponente für den Zugriff auf eine SQL Server-Datenbank aufzurufen. Im folgenden Diagramm wird ein Inline-Sendevorgang ausgeführt, wenn die Orchestrierung eine Geschäftskomponente instanziiert, die intern ein WCF-Proxyobjekt verwendet, um einen nachgeschalteten Webdienst direkt aufzurufen:

    Darstellung von BizTalk Orchestration Inline Send

Hinweis

Obwohl die Verwendung von Inlinesendungen von Orchestrierungen die Latenz erheblich verringert, gibt es Einschränkungen für diesen Ansatz. Da Inlinesendungen das BizTalk-Messagingmodul umgehen, ist die folgende Funktionalität, die mit dem Messagingmodul bereitgestellt wird, nicht verfügbar:

  • Transaktionspipelinen
    • Wiederherstellbare Pipelines
    • Pipelines, die die BAM-Interceptor-API aufrufen
    • BizTalk Server-Adapterunterstützung
    • Batchverarbeitung
    • Wiederholungsversuche
    • Korrelationssatzinitialisierung
    • Deklarative Konfiguration
    • Sekundäre Transporte
    • Nachverfolgung
    • Deklarative Verwendung von BAM

Weitere Informationen zu den Pipelinetypen, die nicht innerhalb einer Orchestrierung ausgeführt werden können, finden Sie im Abschnitt "Einschränkungen" des Themas "Verwenden von Ausdrücken zum Ausführen von Pipelines () in der BizTalk Server 2010-Dokumentation.For more information about the types of pipelines that cannot be execute from an orchestration, see the "Restrictions" section of the Topic How to Use Expressions to Execute Pipelines (https://go.microsoft.com/fwlink/?LinkId=158008) in the BizTalk Server 2010 documentation.

Optimieren Sie die Orchestrierungslatenz, indem Sie die Anzahl der Persistenzpunkte verringern, wenn möglich

Ein Orchestrierungsbereich muss nur dann als "Transaktion mit langer Ausführung" gekennzeichnet werden, wenn Sie Kompensationen oder Bereichstimeouts verwenden möchten. Ein langandauernder transaktionaler Bereich verursacht einen zusätzlichen Persistenzpunkt am Ende des Bereichs, sodass er vermieden werden sollte, wenn Sie keine Kompensation oder Bereichs-Timeouts verwenden müssen. Ein atomarer Bereich verursacht einen Persistenzpunkt am Ende des Bereichs, garantiert aber auch, dass keine Persistenzpunkte innerhalb des atomaren Bereichs auftreten. Diese Nebenwirkung des Fehlens von Persistenz innerhalb des Anwendungsbereichs kann manchmal zu Ihrem Vorteil genutzt werden, um Persistenzpunkte zu sammeln (z. B. wenn mehrere Sendevorgänge ausgeführt werden). Im Allgemeinen wird jedoch empfohlen, atombezogene Bereiche möglichst zu vermeiden. Das Orchestrierungsmodul speichert den gesamten Zustand einer ausgeführten Orchestrierungsinstanz an verschiedenen Stellen, sodass die Instanz später im Arbeitsspeicher wiederhergestellt und zum Abschluss ausgeführt werden kann. Die Anzahl der Persistenzpunkte in einer Orchestrierung ist einer der wichtigsten Faktoren, die die Latenz von Nachrichten beeinflussen, die durch Orchestrierungen fließen. Jedes Mal, wenn die Engine auf einen Persistenzpunkt trifft, wird der interne Zustand eines laufenden Orchestrierungsprozesses serialisiert und in der MessageBox gespeichert, und dieser Vorgang verursacht Latenzkosten. Die Serialisierung des internen Zustands umfasst alle Nachrichten und Variablen, die instanziiert und noch nicht innerhalb der Orchestrierung freigegeben wurden. Je größer die Nachrichten und Variablen und je mehr es davon gibt, desto länger dauert es, den internen Zustand einer Orchestrierung zu speichern. Eine übermäßige Anzahl von Persistenzpunkten kann zu einer erheblichen Leistungsbeeinträchtigung führen. Aus diesem Grund empfehlen wir, unnötige Persistenzpunkte aus Orchestrierungen zu eliminieren, indem die Anzahl der Transaktionsrahmen und Send-Shape-Objekte reduziert wird. Dieser Ansatz ermöglicht es, die Konkurrenz in der MessageBox durch Orchestrierungs-Dehydration und -Rehydration zu reduzieren, die Gesamt-Skalierbarkeit zu erhöhen und die Latenz der Orchestrierung zu verringern. Eine weitere Empfehlung besteht darin, den internen Zustand einer Orchestrierung so klein wie möglich zu halten. Diese Technik kann die Zeit, die von der XLANG-Engine für die Serialisierung, das Speichern und die Wiederherstellung des internen Zustands einer Orchestrierung bei einem Persistenzpunkt aufgewendet wird, erheblich reduzieren. Eine Möglichkeit, dies zu erreichen, besteht darin, Variablen und Nachrichten so spät wie möglich zu erstellen und sie so früh wie möglich freizugeben; Führen Sie z. B. nicht transaktionsbezogene Bereiche in Ihren Orchestrierungen ein und deklarieren Sie Variablen und Nachrichten innerhalb dieser inneren Bereiche, anstatt sie auf oberster Ebene zu deklarieren. Weitere Informationen zum Minimieren von Orchestrierungspersistenzpunkten finden Sie in den folgenden Themen in der BizTalk Server 2010-Dokumentation:

Richtlinien für die Verwendung höhergestufter Eigenschaften für den Zugriff auf Nachrichtentags oder Attribute aus einer Orchestrierung

Wenn Sie Eigenschaften heraufstufen müssen, stellen Sie nur die Eigenschaften her, die für nachrichtenweiterleitung, Filter und Nachrichtenkorrelation verwendet werden. Die Förderung jeder Eigenschaft setzt die Disassemblierkomponente (XML, Flach, benutzerdefiniert) voraus, um den Dokumenttyp zu erkennen und mithilfe des XPath-Ausdrucks Daten aus der Nachricht abzurufen, der in der entsprechenden Anmerkung enthalten ist, die den Dokumenttyp in der XSD definiert. Darüber hinaus bewirkt jede Eigenschaftsaufstufung einen separaten Aufruf der gespeicherten Prozedur bts_InsertProperty, wenn der Nachrichten-Agent die Nachricht in die MessageBox-Datenbank einfügt. Wenn eine Orchestrierung auf ein bestimmtes Element oder Attribut zugreifen muss, das in einem XML-Dokument enthalten ist, verwenden Sie eine der folgenden Techniken:

  • Verringern Sie die Anzahl der geschriebenen und höhergestuften Eigenschaften, und beseitigen Sie diejenigen, die nicht unbedingt erforderlich sind.

  • Entfernen Sie unnötige hervorgehobene Felder. Die ausgezeichneten Felder sind geschriebene Kontext-Eigenschaften und können leicht erheblichen Platz einnehmen, da ihr Name der XPath-Ausdruck ist, der zur Datenabfrage verwendet wird. Die spezielle Eigenschaft wird durch Anmerkungen in der XSD definiert, die den Dokumenttyp festlegt. Die Zerlegungskomponente verwendet denselben Ansatz wie für beförderte Eigenschaften und nutzt den XPath-Ausdruck, der ein hervorgehobenes Feld definiert, um es im eingehenden Dokument zu finden. Anschließend schreibt die Disassemblerkomponente eine Eigenschaft in den Kontext, in dem:

    • Name: XPath-Ausdruck, der in der Anmerkung definiert ist.

    • Wert: Wert des elements, das vom XPath-Ausdruck innerhalb eines eingehenden Dokuments identifiziert wird.

      Die XPath-Ausdrücke können sehr lang sein, insbesondere, wenn das betreffende Element sehr tief im Dokumentschema liegt. Je mehr differenzierte Felder, desto größer die Kontextgröße. Dies wiederum wirkt sich negativ auf die Gesamtleistung aus.

  • Verwenden Sie die integrierte XPath-Funktion, die von der Orchestrierungslaufzeit bereitgestellt wird.

  • Wenn Nachrichten recht klein sind (einige Kilobyte) und XML-formatiert, können Sie die Nachricht in eine .NET-Klasseninstanz deserialisieren und mit öffentlichen Feldern und Eigenschaften arbeiten. Wenn die Bearbeitung der Nachricht eine komplexe Ausarbeitung (z.B. benutzerdefinierter Code, Richtlinien des Geschäftsregel-Engines) erfordert, bei der auf Daten über die von einer .NET-Klasseninstanz bereitgestellten Eigenschaften zugegriffen wird, ist dies mit XPath-Ausdrücken wesentlich schneller. Wenn die von der Orchestrierung aufgerufene Geschäftslogik abgeschlossen ist, kann das Entitätsobjekt wieder in eine BizTalk-Nachricht serialisiert werden. Sie können .NET-Klassen aus einem XML-Schema mithilfe eines der folgenden Tools erstellen: XSD-Tool (.NET Framework 2.0) oder SVCUTIL (.NET Framework 3.0).

  • Aktivieren Sie eine Hilfskomponente aus einer Orchestrierung. Diese Technik hat gegenüber der Verwendung von unterschiedenen Feldern einen Vorteil. In der Tat kann eine Orchestrierung den XPath-Ausdruck aus einem Konfigurationsspeicher (Konfigurationsdatei, SSO Config Store, benutzerdefinierte Db usw.) lesen. Wenn Sie den XPath-Ausdruck ändern müssen, müssen Sie ein Schema nicht ändern und erneut bereitstellen, wie Sie es bei beförderten Eigenschaften und unterschiedlichen Feldern tun sollten. Das folgende Codebeispiel enthält ein Beispiel für eine Hilfskomponente. Die Komponente verwendet die XPathReader-Klasse, die von der BizTalk-Laufzeit bereitgestellt wird. Dadurch kann der Code den Dokumentdatenstrom lesen, bis der XPath-Ausdruck gefunden wird.

#region Copyright
//===
//Microsoft Windows Server AppFabric Customer Advisory Team (CAT)
//
// This sample is supplemental to the technical guidance published on the community
// blog.
//
// Author: Paolo Salvatori.
//===
// Copyright © 2010 Microsoft Corporation. All rights reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
// EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. YOU BEAR THE RISK OF USING IT.
//===
#endregion
#region Using Directives
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Linq;
using System.Text;
using System.Globalization;
using Microsoft.XLANGs.BaseTypes;
using Microsoft.BizTalk.Streaming;
using Microsoft.BizTalk.XPath;
#endregion
namespace Microsoft.AppFabric.CAT.Samples.DuplexMEP.Helpers
{
public class XPathHelper
{
#region Private Constants
private const string MessageCannotBeNull = "[XPathReader] The message cannot be null.";
#endregion
#region Public Static Methods
public static string GetValue(XLANGMessage message, int partIndex, string xpath)
{
try
{
if (message == null)
{
throw new ApplicationException(MessageCannotBeNull);
}
using (Stream stream = message[partIndex].RetrieveAs(typeof(Stream)) as Stream)
{
XmlTextReader xmlTextReader = new XmlTextReader(stream);
XPathCollection xPathCollection = new XPathCollection();
XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection);
xPathCollection.Add(xpath);
while (xPathReader.Read())
{
if (xPathReader.HasAttributes)
{
for (int i = 0; i < xPathReader.AttributeCount; i++)
{
xPathReader.MoveToAttribute(i);
if (xPathReader.Match(xPathCollection[0]))
{
return xPathReader.GetAttribute(i);
}
}
}
if (xPathReader.Match(xPathCollection[0]))
{
return xPathReader.ReadString();
}
}
}
}
finally
{
message.Dispose();
}
return string.Empty;
}
#endregion
}
}

Minimieren der Orchestrierungskomplexität zur Verbesserung der Leistung

Die Komplexität der Orchestrierungen hat erhebliche Auswirkungen auf die Leistung. Da die Komplexität der Orchestrierung zunimmt, verringert sich die Gesamtleistung. Orchestrierungen können in einer nahezu unendlichen Vielzahl von Szenarien verwendet werden, und jedes Szenario kann Orchestrierungen unterschiedlicher Komplexität umfassen. Vermeiden Sie komplexe Orchestrierungen, wenn möglich, zugunsten eines modularen Ansatzes. Mit anderen Worten: Teilen Sie Ihre Geschäftslogik in mehrere wiederverwendbare Orchestrierungen auf.

Wenn Sie eine komplexe Orchestrierung implementieren müssen, definieren Sie nach Möglichkeit Nachrichten und Variablen in inneren Gültigkeitsbereichen anstatt auf der obersten Ebene. Diese Technik behält für jede Orchestrierung einen geringeren Speicherbedarf bei, da Variablen und Nachrichten verworfen werden, wenn der Fluss den Bereich verlässt, in dem die Variablen und Nachrichten definiert wurden. Dieser Ansatz ist besonders nützlich, wenn Orchestrierungen an Persistenzpunkten im MessageBox-Objekt gespeichert werden.

Verwenden Sie das Shape "Call Orchestration" im Vergleich zum Shape "Start Orchestration", um die Leistung zu verbessern.

Vermeiden Sie das Shape "Orchestrierung starten", und verwenden Sie das Shape "Orchestrierung aufrufen", um eine geschachtelte Orchestrierung auszuführen. Tatsächlich kann das Call Orchestration-Shape verwendet werden, um synchron eine Orchestrierung aufzurufen, auf die in einem anderen Projekt verwiesen wird. Dieser Ansatz ermöglicht die Wiederverwendung gängiger Orchestrierungsworkflowmuster in BizTalk-Projekten. Wenn Sie eine weitere geschachtelte Orchestrierung synchron mit dem Call Orchestration-Shape aufrufen, wartet die umschließende Orchestrierung auf den Abschluss der geschachtelten Orchestrierung, bevor Sie fortfahren. Die geschachtelte Orchestrierung wird auf demselben Thread ausgeführt, der die aufrufende Orchestrierung ausführt.

Das Shape "Orchestrierung starten" ähnelt dem Shape "Call Orchestrierung", aber in diesem Fall wird die verschachtelte Orchestrierung asynchron aufgerufen: Der Steuerungsfluss in der aufrufenden Orchestrierung geht über den Aufruf hinaus, ohne darauf zu warten, dass die aufgerufene Orchestrierung ihre Arbeit abgeschlossen hat. Um diese Entkoppelung zwischen dem Aufrufer und den aufgerufenen Orchestrierungen zu implementieren, wird die Start-Orchestrierung über die Veröffentlichung einer Nachricht in das BizTalk Messagebox implementiert. Diese Nachricht wird dann von einer integrierten BizTalk-Hostinstanz konsumiert, die die geschachtelte Orchestrierung ausführt. Verwenden Sie nach Möglichkeit die Anruf-Orchestrierung, insbesondere, wenn die Anruf-Orchestrierung auf ein Ergebnis der geschachtelten Orchestrierung warten muss, um die Verarbeitung fortzusetzen. Weitere Informationen zur Verwendung des 'Call Orchestration'-Shapes finden Sie in den folgenden Themen in der BizTalk Server 2010-Dokumentation.

Verwenden von XmlReader mit XLANGMessage im Vergleich zur Verwendung von XmlReader mit XmlDocument zur Verbesserung der Orchestrierungsleistung

Um die Orchestrierungsleistung für .NET-Methoden zu verbessern, die von einer Orchestrierung aufgerufen werden, verwenden Sie XmlReader mit XLANGMessage und nicht xmlDocument. Im folgenden Codebeispiel wird diese Funktionalität veranschaulicht.

// As a general rule, use XmlReader with XLANGMessage, not XmlDocument.
// This is illustrated in the parameter passed into the following code.
// The XLANG/s compiler doesn't allow a return value of XmlReader
// so documents must be initially constructed as XmlDocument()
public static XmlDocument FromMsg(XLANGMessage old)
{
    //get at the data
    XmlDocument ret = new XmlDocument();

    try{
        XmlReader reader = (XmlReader)old[0].RetrieveAs(typeof(XmlReader));
        //construct new message from old
        //read property
        object msgid = old.GetPropertyValue(typeof(BTS.MessageID));
    }
    finally {
        // Call Dispose on the XLANGMessage object
        // because the message doesn't belong to the
        // .NET runtime - it belongs to the Messagebox database
        old.Dispose();
    }
    return ret;
}

Eine weitere Methode wäre das Erstellen einer .NET-Klasse basierend auf dem Schema. Dies erfordert weniger Arbeitsspeicher als das Laden des Dokuments in ein XmlDocument-Objekt sowie einen einfachen Zugriff auf die Schemaelemente für .NET-Entwickler. Um eine Klasse basierend auf einem BizTalk-Schema zu generieren, können Sie das mit Visual Studio bereitgestellte xsd.exe Tool verwenden. Wenn Sie z. B. xsd.exe <schema.xsd> /classes mit einem einfachen Schema ausführen, das Felder namens ItemA, ItemB, ItemC enthält, wird die folgende Klasse erzeugt.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.1433
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System.Xml.Serialization;

//
// This source code was auto-generated by xsd, Version=2.0.50727.42.
//

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://Schemas.MySchema")]
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://Schemas.MySchema", IsNullable=false)]
public partial class MySchemaRoot {

    private string itemAField;

    private string itemBField;

    private string itemCField;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
    public string ItemA {
        get {
            return this.itemAField;
        }
        set {
            this.itemAField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
    public string ItemB {
        get {
            return this.itemBField;
        }
        set {
            this.itemBField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
    public string ItemC {
        get {
            return this.itemCField;
        }
        set {
            this.itemCField = value;
        }
    }
}

Auf diese Klasse kann dann in Ihrer .NET-Assembly verwiesen werden, um auf die Nachrichtenelemente zuzugreifen, und das zurückgegebene Objekt kann direkt einer Nachricht zugewiesen werden. Im Folgenden sehen Sie ein Beispiel für die oben generierte Klasse.

public static Root SetValues(Microsoft.XLANGs.BaseTypes.XLANGMessage msg)
{
   try
   {
   MySchemaRoot rootObj=(MySchemaRoot)msg[0].RetrieveAs(typeof(MySchemaRoot);
   rootObj.ItemA="value a";
   rootObj.ItemB="value b";
   rootObj.ItemC="value c";
   }
    finally {
        msg.Dispose();
            }

   return rootObj;
}

Mit dieser Technik können Sie beim Verarbeiten von Nachrichten einen objektorientierten Ansatz verwenden. Diese Technik sollte in erster Linie mit relativ kleinen Nachrichten verwendet werden. Dies liegt daran, dass die gesamte Nachricht weiterhin in den Arbeitsspeicher geladen wird, obwohl diese Technik deutlich weniger Arbeitsspeicher verwendet als beim Laden der Nachricht in ein XmlDocument-Objekt . Verwenden Sie beim Verarbeiten größerer Nachrichten die XmlReader-Klasse zum Lesen von Nachrichten und der XmlWriter-Klasse zum Schreiben von Nachrichten. Bei Verwendung von XmlReader und XmlWriter ist die Nachricht in einem VirtualStream-Objekt enthalten. Wenn die Nachrichtengröße den für den Schwellenwert für große Nachrichten (Bytes) angegebenen Wert überschreitet, der auf der Konfigurationsseite der BizTalk-Gruppeneigenschaften verfügbar gemacht wird, wird die Nachricht in das Dateisystem geschrieben. Dies verringert die Gesamtleistung, vermeidet jedoch Speicherplatzüberschreitungen.

Verbessern der Leistung durch Minimierung der Verwendung logischer Ports, die an physische Ports gebunden sind

Sie können die Leistung erhöhen, indem Sie die Verwendung logischer Ports minimieren, die an physische Ports gebunden sind, die die folgenden Adapter verwenden:

  • SQL Server, Oracle

  • WSE, HTTP, WCF

  • MSMQ, MQSeries

    In BizTalk Server 2010 können Sende- und Empfangspipelines direkt von einer Orchestrierung mithilfe der XLANGPipelineManager-Klasse, die in der Microsoft.XLANGs.Pipeline.dllenthalten ist, aufgerufen werden. So kann die Verarbeitung von Pipelines von Ports in Orchestrierungsprozesse verschoben werden; Logische Ports in einem Orchestrierungsprozess können durch ein Expression-Shape ersetzt werden, das eine Instanz einer bestimmten .NET-Klasse aufruft (z. B. eine Datenzugriffskomponente mit ADO.NET). Bevor Sie diese Technik einführen, sollten Sie beachten, dass Sie, wenn Sie keine Adapter und physischen Ports verwenden, die Möglichkeit verlieren, ihre Funktionen wie Batchverarbeitung, Wiederholungen, deklarative Konfiguration und sekundäre Transporte zu nutzen.

Orchestrierungsentwurfsmuster

Der Orchestration Designer ermöglicht Entwicklern die Implementierung einer vielzahl von Unternehmensintegrationsmustern. Einige gängige Muster umfassen Aggregator, Ausnahmebehandlung und Kompensation, Nachrichtenbroker, Scatter und Gather sowie sequenzielle und parallele Konvoi. Diese Muster können verwendet werden, um komplexe Enterprise Application Integration (EAI), Service-Oriented Architecture (SOA) und BPM-Lösungen (Business Process Management) mit BizTalk Server zu entwickeln. Weitere Informationen zu Orchestration Design Patterns finden Sie im Thema Implementieren von Entwurfsmustern in Orchestrationen (https://go.microsoft.com/fwlink/?LinkId=140042) in der BizTalk Server-Dokumentation und "Patterns and Best Practices for Enterprise Integration (https://go.microsoft.com/fwlink/?LinkId=140043).

Verwenden Sie .NET-Klassen in Orchestrierungen entsprechend, um die Leistung zu maximieren.

Im Allgemeinen können die in einer Orchestrierung verwendeten .NET-Klassen in zwei verschiedene Kategorien unterteilt werden:

  • Helfer und Dienste - Diese Klassen bieten allgemeine Dienste für Orchestrierungen wie Ablaufverfolgung, Fehlerbehandlung, Zwischenspeicherung und Serialisierung/Deserialisierung. Die meisten dieser Klassen können als statische Klassen ohne internen Zustand und mehrere öffentliche statische Methoden implementiert werden. Dieser Ansatz vermeidet das Erstellen mehrerer Objekte derselben Klasse in verschiedenen Orchestrierungen, die gleichzeitig ausgeführt werden, was dazu beiträgt, den Arbeitsbereich von Hostprozessen zu reduzieren und Speicher zu sparen. Eine Klasse, die zustandslos ist, hilft, die Gesamtgröße des internen Zustands zu reduzieren, der serialisiert und in bizTalk MessageBox beibehalten werden muss, wenn eine Orchestrierung dehydratisiert wird.

  • Entitäten und Geschäftsobjekte - Sie können diese Klassen verwenden, um Entitäten zu verwalten, z. B. Bestellungen, Bestellungen und Kunden. Eine einzelne Orchestrierung kann intern mehrere Instanzen desselben Typs erstellen und verwalten. Diese Klassen sind in der Regel zustandsbehaftet und machen öffentliche Felder und/oder Eigenschaften zusammen mit Methoden verfügbar, um den internen Zustand des Objekts zu ändern. Instanzen dieser Klassen können dynamisch durch Deserialisieren eines XLANGMessage-Teils in ein . NET-Objekt mithilfe der XmlSerializer - oder DataContractSerializer-Klassen oder mithilfe der XLANGPart.RetrieveAs-Methode erstellt werden. Sie sollten eine Orchestrierung mithilfe nichttransaktionaler Bereiche so strukturieren, dass Instanzen zustandsbehafteter Klassen so spät wie möglich erstellt und freigegeben werden, sobald sie nicht mehr benötigt werden. Dieser Ansatz reduziert den Arbeitsbereich von Hostprozessen und minimiert die Gesamtgröße des internen Zustands, der serialisiert und in der MessageBox-Datenbank beibehalten wird, wenn eine Orchestrierung dehydratisiert wird. Weitere Informationen zur Verwendung von Orchestrierungen in BizTalk Server finden Sie im Artikel FAQ für BizTalk Server Orchestrations (https://go.microsoft.com/fwlink/?LinkID=116886).

    Hinweis

    Während dieser Artikel für BizTalk Server 2004 und BizTalk Server 2006 geschrieben ist, gelten die vorgestellten Konzepte auch für BizTalk Server 2010-Orchestrierungen.

Orchestrierungs-Ausnahmebehandlerblöcke

Beim Verwenden von Orchestrierung-Ausnahmehandlerblöcken sollten Sie alle Orchestrierungs-Shapes in einen oder mehrere Bereiche einfügen (möglichst nicht-transaktionale Bereiche) und mindestens die folgenden Ausnahmehandlerblöcke erstellen:

Überlegungen bei der Verwendung von Karten in Orchestrierungen

Die folgenden Überlegungen gelten bei der Verwendung von Karten in Orchestrierungen:

  • Wenn Sie eine Zuordnung verwenden, um Eigenschaften zu extrahieren oder festzulegen, die in einer Orchestrierung mit Geschäftslogik verwendet werden, verwenden Sie unterscheidbare Felder oder beförderte Eigenschaften. Diese Vorgehensweise sollte befolgt werden, da beim Extrahieren oder Festlegen von Werten mit einer Zuordnung das Dokument in den Arbeitsspeicher geladen wird, wenn jedoch ausgewählte Felder oder höhergestufte Eigenschaften verwendet werden, greift die Orchestrierungs-Engine auf den Nachrichtenkontext zu und lädt das Dokument nicht in den Arbeitsspeicher.

  • Wenn Sie eine Zuordnung verwenden, um mehrere Felder in einem Feld zu aggregieren, verwenden Sie unterschiedliche Felder oder promovierte Eigenschaften mit einer Orchestrierungsvariablen, um das Resultset zu sammeln.

Siehe auch

Optimieren der Leistung

  • Last updated on