Erstellen eines Azure Logic Apps Rules Engine-Projekts mit Visual Studio Code

2025-06-23

Gilt für: Azure Logic Apps (Standard)

Wenn Sie Geschäftslogik in Ihre Standardworkflows in Azure Logic Apps integrieren möchten, können Sie mit Visual Studio Code ein Azure Logic Apps-Regel-Engine-Projekt erstellen. Regeln steuern die Geschäftslogik für die Ausführung von Geschäftsprozessen.

In dieser Schrittanleitung erfahren Sie, wie Sie ein Azure Logic Apps-Regel-Engine-Projekt erstellen:

Voraussetzungen und Setup für das Erstellen Ihres Azure Logic Apps-Regel-Engine-Projekts, einschließlich der Erstellung der Geschäftsregeln für Ihr Projekt mit Microsoft Rules Composer
Exportieren Sie ggf. vorhandene Regeln aus Microsoft BizTalk Server.
Erstellen Sie mit Visual Studio Code ein Standard-Logic Apps-Projekt für die Azure Logic Apps-Regel-Engine.

Voraussetzungen

Laden Sie Microsoft Rules Composer herunter, den Sie zum Erstellen von Regelsätzen, Geschäftsregeln und Vokabularen verwenden, und installieren Sie das Programm.

Weitere Informationen zum Erstellen der Geschäftslogik für Ihr Regel-Engine-Projekt finden Sie in der folgenden Dokumentation:
- Erstellen von Regeln mit Microsoft Rules Composer
- Integration von Entscheidungsverwaltung und Geschäftslogik mithilfe der Azure Logic Apps-Regel-Engine
Bei diesem Release unterstützt nur Visual Studio Code die Entwicklungsumgebung für ein Azure Logic Apps-Regel-Engine-Projekt. Weitere Informationen zur Erfüllung der Voraussetzungen für die Verwendung von Visual Studio Code finden Sie unter Erstellen eines Standard-Logic Apps-Workflows in Azure Logic Apps für Einzelmandanten mit Visual Studio Code.
Die Azure Logic Apps-Regel-Engine verwendet die Funktionen für benutzerdefinierten Code in Visual Studio Code. Weitere Informationen zur Erfüllung der Voraussetzungen für die Verwendung dieser Funktion finden Sie unter Erstellen und Ausführen von .NET Framework-Code aus Standardworkflows in Azure Logic Apps.

Bevor Sie Ihr Projekt erstellen

Um ein erfolgreiches Regel-Engine-Projekt sicherzustellen, führen Sie die folgenden allgemeinen Aufgaben und bewährten Methoden aus:

Bestimmen Sie, wie sich die Geschäftsregeln in Ihre Geschäftsprozesse einfügen.
Planen Sie, wie Sie Geschäftsregeln in die Anwendung integrieren.
Identifizieren Sie die Geschäftslogik, die in der Anwendung durch Regeln dargestellt werden soll.

Der Begriff „Geschäftslogik“ kann sich auf viele Dinge beziehen. Beispielsweise kann eine Geschäftslogik „Für Bestellungen über 500 Dollar eine Genehmigung durch Vorgesetzte erzwingen“ lauten.
Identifizieren Sie Datenquellen für die Regelelemente. Sie können auch Vokabulare definieren, die domänenspezifische Terminologie für die zugrunde liegenden Bindungen repräsentiert.
Definieren Sie die anzuwendenden Regeln aus den Vokabulardefinitionen oder direkt aus Datenbindungen. Erstellen Sie aus diesen Regeln ein Regelsatz, der Ihre Geschäftslogik darstellt.

Exportieren von Regeln aus Microsoft BizTalk Server

Um vorhandene Regeln aus Microsoft BizTalk Server wiederzuverwenden, können Sie sie exportieren. Datenbankfakten werden derzeit jedoch nicht unterstützt. Bevor Sie Ihre Regeln exportieren, müssen Sie diese mithilfe von Microsoft BizTalk Rules Composer entfernen oder in andere Faktentypen umgestalten.

Starten Sie in Microsoft BizTalk Server den Assistenten für die Bereitstellung von Geschäftsregel-Engines.
Wählen Sie auf der Seite Willkommen die Option Weiter aus.
Wählen Sie auf der Seite Bereitstellungsaufgabe die Option Richtlinie/Vokabular aus einer Datei in eine Datenbank exportieren und dann Weiter aus.
Wählen Sie auf der Seite Richtlinienspeicher in der Liste SQL Server-Name Ihren SQL Server aus. Wählen Sie in der Konfigurationsdatenbank in der ausgewählten Serverliste BizTalkRuleEngineDb und dann Weiter aus.
Wählen Sie auf der Seite Richtlinie/Vokabular exportieren in der Liste Richtlinie die gewünschte Richtlinie aus. Um die Definitionsdatei zu suchen und auszuwählen, wählen Sie Durchsuchen aus.
Klicken Sie abschließend auf Weiter.
Überprüfen Sie die Informationen zu Server, Datenbank und Richtlinie oder Vokabular, und wählen Sie Weiter aus.
Wählen Sie nach dem Abschluss von Import oder Export Weiter aus.
Überprüfen Sie den Abschlussstatus des Import- bzw. Exportvorgangs, und wählen Sie dann auf Fertig stellen aus.

Erstellen eines Azure Logic Apps-Regel-Engine-Projekts

Wählen Sie auf der Aktivitätsleiste in Visual Studio Code das Azure-Symbol aus. (Tastatur: UMSCHALT+ALT+A)
Wählen Sie im dadurch geöffneten Fenster Azure auf der Symbolleiste des Abschnitts Arbeitsbereich im Menü Azure Logic Apps die Option Neuen Logik-App-Arbeitsbereich erstellen aus.
Navigieren Sie im Feld Ordner auswählen zum lokalen Ordner, den Sie für Ihr Projekt erstellt haben.
Wenn das Eingabeaufforderungsfeld Erstellen eines neuen Logik-App-Arbeitsbereichs angezeigt wird, geben Sie einen Namen für Ihren Arbeitsbereich ein:

Dieses Beispiel wird mit MyLogicAppRulesWorkspace fortgesetzt.
Wenn das Eingabeaufforderungsfeld "Auswählen einer Projektvorlage für Ihren Logik-App-Arbeitsbereich " angezeigt wird, wählen Sie "Logik-App mit Regelmodulprojekt" aus.

Geben Sie anhand der nachfolgenden Eingabeaufforderungen die folgenden Informationen an:

Artikel	Beispielswert
Funktionsname für Funktionsprojekt	RulesFunction
Namespacename für Funktionsprojekt	Contoso
Logik-App:	LogicApp-
Workflowvorlage: - Zustandsbehafteter Workflow - Zustandsloser Workflow	Zustandsbehafteter Workflow
Workflowname	MyRulesWorkflow

Wählen Sie In aktuellem Fenster öffnen aus.

Nachdem Sie diesen Schritt abgeschlossen haben, erstellt Visual Studio Code Ihren Arbeitsbereich, der standardmäßig ein Funktionsprojekt und ein Logik-App-Regel-Engine-Projekt enthält, z. B.:

Knoten	BESCHREIBUNG
*< arbeitsbereichname>*	Enthält sowohl Ihr Funktionsprojekt als auch Ihr Logik-App-Workflowprojekt.
Funktion	Enthält die Artefakte für Ihr Funktionsprojekt. Beispielsweise ist die Datei *<funktionsname>.cs* die Codedatei, in der Sie Ihren Code erstellen können.
LogicApp-	Enthält die Artefakte für Ihr Logik-App-Regel-Engine-Projekt, einschließlich eines Workflows.

Schreiben des Codes für die Regel-Engine

Erweitern Sie in Ihrem Arbeitsbereich den Knoten Funktionen, falls dieser noch nicht erweitert ist.

Öffnen Sie die Datei <funktionsname>.cs (in diesem Beispiel RulesFunction.cs).

Standardmäßig enthält diese Datei Beispielcode, der die folgenden Codeelemente sowie ggf. die zuvor bereitgestellten Beispielwerte enthält:

Namespacename
Klassenname
Funktionsname
Funktionsparameter
Rückgabetyp
Komplexer Typ

Das folgende Beispiel zeigt den vollständigen Beispielcode für die Funktion mit dem Namen RulesFunction:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso
{
     using System;
     using System.Collections.Generic;
     using System.Threading.Tasks;
     using Microsoft.Azure.Functions.Extensions.Workflows;
     using Microsoft.Azure.WebJobs;
     using Microsoft.Azure.Workflows.RuleEngine;
     using Microsoft.Azure.Workflows.RuleEngine.Common;
     using Microsoft.Extensions.Logging;
     using System.Xml;
     using System.Text;

     /// <summary>
     /// Represents the RulesFunction flow invoked function.
     /// </summary>
     public class RulesFunction
     {
         private readonly ILogger<RulesFunction> logger;

         private FileStoreRuleExplorer ruleExplorer;

         public RulesFunction(ILoggerFactory loggerFactory)
         {
             logger = loggerFactory.CreateLogger<RulesFunction>();
             this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); 
         }

         /// <summary>
         /// Executes the logic app workflow.
         /// </summary>
         /// <param name="ruleSetName">The rule set name.</param>
         /// <param name="documentType">document type of input xml.</param>
         /// <param name="inputXml">input xml type fact</param>
         /// <param name="purchaseAmount">purchase amount, value used to create .NET fact </param>
         /// <param name="zipCode">zip code value used to create .NET fact .</param>
         [FunctionName("RulesFunction")]
         public Task<RuleExecutionResult> RunRules(
             [WorkflowActionTrigger] string ruleSetName, 
             string documentType, 
             string inputXml, 
             int purchaseAmount, 
             string zipCode)
         {
         /***** Summary of steps below *****
              * 1. Get the rule set to Execute 
              * 2. Check if the rule set was retrieved successfully
              * 3. create the rule engine object
              * 4. Create TypedXmlDocument facts for all xml document facts
              * 5. Initialize .NET facts
              * 6. Execute rule engine
              * 7. Retrieve relevant updates facts and send them back
         */

             try
             {
                 var ruleSet = this.ruleExplorer.GetRuleSet(ruleSetName);

                 // Check if ruleset exists
                 if(ruleSet == null)
                 {
                     // Log an error in finding the rule set
                     this.logger.LogCritical($"RuleSet instance for '{ruleSetName}' was not found(null)");
                     throw new Exception($"RuleSet instance for '{ruleSetName}' was not found.");
                 }             

                 // Create rule engine instance
                 var ruleEngine = new RuleEngine(ruleSet: ruleSet);

                 // Create a typedXml Fact(s) from input xml(s)
                 XmlDocument doc = new XmlDocument();
                 doc.LoadXml(inputXml);
                 var typedXmlDocument = new TypedXmlDocument(documentType, doc);

                 // Initialize .NET facts
                 var currentPurchase = new ContosoNamespace.ContosoPurchase(purchaseAmount, zipCode);

                 // Provide facts to rule engine and run it
                 ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });

                 // Send the relevant results(facts) back
                 var updatedDoc = typedXmlDocument.Document as XmlDocument;
                 var ruleExectionOutput = new RuleExecutionResult()
                 {
                     XmlDoc = updatedDoc.OuterXml,
                     PurchaseAmountPostTax = currentPurchase.PurchaseAmount + currentPurchase.GetSalesTax()
                 };

                 return Task.FromResult(ruleExectionOutput);
             }
             catch(RuleEngineException ruleEngineException)
             {
                 // Log any rule engine exceptions
                 this.logger.LogCritical(ruleEngineException.ToString());
                 throw;
             }
             catch(XmlException xmlException)
             {
                 // Log any xml exceptions
                 this.logger.LogCritical("Encountered exception while handling xml. " + xmlException.ToString());
                 throw;
             }
             catch(Exception ex)
             {
                 // Log any other exceptions
                 this.logger.LogCritical(ex.ToString());
                 throw;
             }
         }

         /// <summary>
         /// Results of the rule execution
         /// </summary>
         public class RuleExecutionResult
         {
             /// <summary>
             /// rules updated xml document
             /// </summary>
             public string XmlDoc { get; set;}

             /// <summary>
             /// Purchase amount post tax
             /// </summary>
             public int PurchaseAmountPostTax { get; set;}
         }
     }
}

Die Funktionsdefinition für RulesFunction enthält eine RunRules-Standardmethode, die Sie für die ersten Schritte verwenden können. Diese RunRules-Beispielmethode zeigt, wie Parameter an die Azure Logic Apps-Regel-Engine übergeben werden. In diesem Beispiel übergibt die Methode den Regelsatznamen, den Eingabedokumenttyp, einen XML-Fakt und noch andere Werte für die weitere Verarbeitung.

Die Datei <function-name>.cs enthält außerdem die ILogger-Schnittstelle, die Unterstützung für die Protokollierung von Ereignissen einer Application Insights-Ressource bietet. Sie können Ablaufverfolgungsinformationen an Application Insights senden und diese Informationen zusammen mit den Ablaufverfolgungsinformationen aus Ihren Workflows speichern. Die <Datei "Funktionsname>.cs " enthält auch das FileStoreRuleExplorer Objekt, das auf das Regelset zugreift. Wie Sie beobachten können, verwendet der Konstruktor für das FileStoreRuleExplorerloggerFactory Senden von Telemetrieinformationen auch an Application Insights:

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

public RulesFunction(ILoggerFactory loggerFactory)
     {
         logger = loggerFactory.CreateLogger<RulesFunction>();
         this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); 
     }

    <...>

Die Azure Logic Apps-Regel-Engine funktioniert wie in den folgenden Schritten beschrieben:

Die Engine verwendet das FileStoreRuleExplorer-Objekt, um auf den Regelsatz zuzugreifen. Die Regelsatzdatei wird im Verzeichnis Rules für Ihre Standard-Logik-App gespeichert.

In diesem Beispiel hat die Regelsatzdatei die Bezeichnung SampleRuleSet.xml und wurde entweder mit Microsoft Rules Composer erstellt oder mit Microsoft BizTalk Server exportiert.

var ruleSet = this.ruleExplorer.GetRuleSet(ruleSetName);

// Check if ruleset exists
if(ruleSet == null)
{
// Log an error in finding the rule set
  this.logger.LogCritical($"RuleSet instance for '{ruleSetName}' was not found(null)");
  throw new Exception($"RuleSet instance for '{ruleSetName}' was not found.");
}

Wichtig

Regelsätze enthalten Verweise auf ihre Fakten. Microsoft Rules Composer sucht nach den Assemblys der Fakten, um das Regelset für die Bearbeitung zu validieren. Zum Öffnen von Regelsätzen wie SampleRuleSet.xml in Microsoft Rules Composer müssen Sie sie zusammen mit den zugehörigen .NET-Faktenassemblys speichern. Andernfalls wird eine Ausnahme ausgelöst.

Die Engine verwendet das ruleSet-Objekt, um eine Instanz des RuleEngine-Objekts zu erstellen.
Das RuleEngine-Objekt empfängt die Fakten der Regel mit der Execute-Methode.

In diesem Beispiel empfängt die Execute-Methode zwei Fakten: einen XML-Fakt namens typedXmlDocument und einen .NET-Fakt namens currentPurchase.

Nachdem die Engine ausgeführt wurde, werden die Faktenwerte mit den Werten überschrieben, die sich aus der Engine-Ausführung ergeben:

// Create rule engine instance
var ruleEngine = new RuleEngine(ruleSet: ruleSet);
// Create a typedXml Fact(s) from input xml(s)
XmlDocument doc = new XmlDocument();
doc.LoadXml(inputXml);
var typedXmlDocument = new TypedXmlDocument(documentType, doc);
// Initialize .NET facts
var currentPurchase = new ContosoNamespace.ContosoPurchase(purchaseAmount, zipCode);
// Provide facts to rule engine and run it
ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });
// Send the relevant results(facts) back
   var updatedDoc = typedXmlDocument.Document as XmlDocument;

Das Modul verwendet die benutzerdefinierte RuleExecutionResult-Klasse, um die Werte an die RunRules-Methode zurückzugeben:

var ruleExectionOutput = new RuleExecutionResult()
             {
                 XmlDoc = updatedDoc.OuterXml,
                 PurchaseAmountPostTax = currentPurchase.PurchaseAmount + currentPurchase.GetSalesTax()
             };

             return Task.FromResult(ruleExectionOutput);

Ersetzen Sie den Beispielfunktionscode durch Ihren eigenen, und bearbeiten Sie die RunRules-Standardmethode für Ihre eigenen Szenarien.

In diesem Beispiel wird der Beispielcode weiterhin ohne Änderungen genutzt.

Kompilieren und Erstellen Ihres Codes

Nachdem Sie das Schreiben des Codes abgeschlossen haben, kompilieren Sie ihn, um sicherzustellen, dass keine Buildfehler vorhanden sind. Ihr Funktionsprojekt enthält automatisch Buildaufgaben, die Ihre benutzerdefinierten Codebibliotheken, einschließlich Ihrer .NET-Faktenassemblys, kompilieren und dann im Ordner lib\custom in Ihrem Logik-App-Projekt hinzufügen. In diesem Ordner suchen Workflows nach benutzerdefinierten Funktionen, die ausgeführt werden sollen. Diese Aufgaben legen die Assemblys im Ordner lib\custom\net472 ab.

Wählen Sie in Visual Studio Code im Menü Terminal die Option Neues Terminal aus.
Wählen Sie in der angezeigten Arbeitsverzeichnisliste Funktionen als aktuelles Arbeitsverzeichnis für das neue Terminal aus.

Visual Studio Code öffnet ein Terminalfenster mit einer Eingabeaufforderung.
Geben Sie im Terminalfenster an der Eingabeaufforderung dotnet restore .\RulesFunction.csproj ein.
Wenn die Eingabeaufforderung wieder angezeigt wird, geben Sie dotnet build .\RulesFunction.csproj ein.

Wenn Ihr Build erfolgreich ist, wird im Terminalfenster die Meldung Build erfolgreich ausgegeben.
Vergewissern Sie sich, dass die folgenden Elemente in Ihrem Logik-App-Projekt vorhanden sind:
- Erweitern Sie in Ihrem Arbeitsbereich die folgenden Ordner: LogicApp>lib\custom>net472. Vergewissern Sie sich, dass der Unterordner net472 die verschiedenen Assemblys enthält, die zum Ausführen des Codes erforderlich sind, einschließlich einer Datei namens <funktionsname>.dll.
- Erweitern Sie in Ihrem Arbeitsbereich die folgenden Ordner: LogicApp>lib\custom><function-name>. Vergewissern Sie sich, dass der Unterordner <function-name> eine Datei namensfunction.json enthält, die die Metadaten für den von Ihnen geschriebenen Funktionscode enthält. Der Workflow-Designer verwendet diese Datei, um die erforderlichen Eingaben und Ausgaben zu bestimmen, wenn Ihr Code aufgerufen wird.
Das folgende Beispiel zeigt generierte Assemblys und andere Dateien im Logik-App-Projekt:

Aufrufen Ihrer Regeln aus einem Workflow

Nachdem Sie sich vergewissert haben, dass Ihr Code kompiliert wird und dass Ihr Logik-App-Regel-Engine-Projekt die erforderlichen Dateien für die Ausführung Ihres Codes enthält, öffnen Sie den Standardworkflow, der in Ihrem Logik-App-Projekt enthalten ist.

Erweitern Sie in Ihrem Arbeitsbereich unter LogicApp den Knoten <workflowname>, öffnen Sie das Kontextmenü für workflow.json, und wählen Sie Designer öffnen aus.

Im Workflow-Designer, der geöffnet wird, wird der Standardworkflow, der in Ihrem Logik-App-Projekt enthalten ist, mit dem folgenden Trigger und den folgenden Aktionen angezeigt:
- Dem integrierten Anforderungstrigger namens Beim Empfang einer HTTP-Anforderung
- Der integrierten Aktion namens Lokale Funktion in dieser Logik-App aufrufen
- Der integrierten Antwortaktion namens Antwort, mit der Sie dem Aufrufer nur antworten, wenn Sie den Anforderungstrigger verwenden
Wählen Sie die Aktion namens Lokale Funktion in dieser Logik-App aufrufen aus.

Der Informationsbereich der Aktion wird auf der rechten Seite geöffnet.
Überprüfen Sie, ob der Parameterwert Funktionsname auf die auszuführende Regelfunktion festgelegt ist. Überprüfen oder ändern Sie alle anderen Parameterwerte, die ihre Funktion verwendet.

Debuggen von Code und Workflow

Wiederholen Sie die folgenden Schritte, um den Azurite-Speicheremulator drei Mal zu starten: jeweils ein Mal für die folgenden Azure Storage-Dienste:
- Azure-Blob-Dienst
- Azure Queue Service
- Azure-Tabellendienst
1. Wählen Sie in Visual Studio Code im Menü Ansicht die Option Befehlspalette aus.
2. Suchen Sie an der angezeigten Eingabeaufforderung nach Azurite: Blobdienst starten, und wählen Sie diese Option aus.
3. Wählen Sie in der angezeigten Arbeitsverzeichnisliste LogicApp aus.
4. Wiederholen Sie diese Schritte für Azurite: Warteschlangendienst starten und Azurite: Tabellendienst starten.
Sie sind erfolgreich, wenn die Taskleiste von Visual Studio Code unten auf dem Bildschirm die drei ausgeführten Speicherdienste anzeigt, z. B.:
Wählen Sie auf der Aktivitätsleiste von Visual Studio Code Ausführen und Debuggen aus. (Tastenkombination: STRG+UMSCHALT+D)
Wählen Sie in der Liste Ausführen und Debuggen die Option An Logik-App anfügen (LogicApp) aus, falls nicht bereits ausgewählt, und wählen Sie dann Wiedergeben (grüner Pfeil) aus.

Das Terminalfenster wird geöffnet und zeigt den gestarteten Debugprozess an. Anschließend wird das Fenster Debugkonsole angezeigt, in dem die Debugstatus angezeigt werden. Unten in Visual Studio Code färbt sich die Taskleiste orange und zeigt damit an, dass der .NET-Debugger geladen ist.
Um Haltepunkte festzulegen, suchen Sie in Ihrer Funktionsdefinition (<funktionsname>.cs) oder Workflowdefinition (workflow.json) nach der Zeilennummer, an der Sie den Haltepunkt verwenden möchten, und wählen Sie die Spalte auf der linken Seite aus, z. B.:
Um den Anforderungstrigger in Ihrem Workflow manuell auszuführen, öffnen Sie die Seite Übersicht des Workflows.
1. Öffnen Sie in Ihrem Logik-App-Projekt das Kontextmenü der Datei workflow.json, und wählen Sie Übersicht aus.
  
  Auf der Seite Übersicht des Workflows ist die Schaltfläche Trigger ausführen verfügbar, wenn Sie den Workflow manuell starten möchten. Unter Workfloweigenschaften ist der Wert der Rückruf-URL die URL für einen aufrufbaren Endpunkt, der vom Anforderungstrigger in Ihrem Workflow erstellt wird. Sie können Anforderungen an diese URL senden, um Ihren Workflow aus anderen Apps auszulösen, einschließlich anderer Logik-App-Workflows.
Wählen Sie in der Symbolleiste der Seite Übersicht die Option Trigger ausführen aus.

Nachdem der Workflow mit der Ausführung begonnen hat, aktiviert der Debugger Ihren ersten Breakpoint.
Wählen Sie im Menü Ausführen oder in der Symbolleiste des Debuggers eine Debugaktion aus.

Nach Abschluss der Workflowausführung werden auf der Seite Übersicht die fertige Ausführung und grundlegende Details zu dieser Ausführung angezeigt.
Wählen Sie die beendete Ausführung aus, um weitere Informationen zur Workflowausführung zu überprüfen. Sie können auch in der Liste neben der Spalte Dauer die Option Ausführung anzeigen auswählen.
Führen Sie die Schritte unter "Vorbereiten für die Bereitstellung" aus, um Ihre Logik-Apps mit dem Regelmodul-Projekt in Azure Logic Apps bereitzustellen.