Skapa ett Azure Logic Apps Rules Engine-projekt med Visual Studio Code

2025-01-27

Gäller för: Azure Logic Apps (Standard)

När du vill integrera affärslogik med dina Standard-arbetsflöden i Azure Logic Apps kan du skapa och skapa ett Azure Logic Apps Rules Engine-projekt med hjälp av Visual Studio Code. Regler styr affärslogik för hur affärsprocesser fungerar.

Den här instruktionsguiden beskriver hur du skapar ett Azure Logic Apps Rules Engine-projekt:

Krav och konfiguration för att skapa ditt Azure Logic Apps Rules Engine-projekt, inklusive att skapa affärsregler för ditt projekt med Microsoft Rules Composer.
Exportera befintliga regler från Microsoft BizTalk Server om du har några.
Skapa ett Standard logic apps-projekt för Azure Logic Apps Rules Engine med hjälp av Visual Studio Code.

Förutsättningar

Ladda ned och installera Microsoft Rules Composer, som du använder för att skapa regeluppsättningar, affärsregler och vokabulärer.

Information om hur du skapar verksamheten för ditt regelmotorprojekt finns i följande dokumentation:
- Skapa regler med Microsoft Rules Composer
- Beslutshantering och affärslogikintegrering med hjälp av Regelmotorn för Azure Logic Apps
För den här versionen stöder endast Visual Studio Code utvecklingsupplevelsen för ett Azure Logic Apps Rules Engine-projekt. Information om hur du uppfyller kraven för att använda Visual Studio Code finns i Skapa ett standardarbetsflöde för logikappar i Azure Logic Apps med en enda klientorganisation med Hjälp av Visual Studio Code.
Azure Logic Apps-regelmotorn använder funktionen för anpassad kod i Visual Studio Code. Information om hur du uppfyller kraven för att använda den här funktionen finns i Skapa och köra .NET Framework-kod från Standard-arbetsflöden i Azure Logic Apps.

Innan du skapar projektet

För att säkerställa ett lyckat regelmotorprojekt kan du granska och utföra följande allmänna uppgifter och metodtips:

Fastställ hur affärsregler passar in i dina affärsprocesser.
Planera hur du ska införliva affärsregler i ditt program.
Identifiera den affärslogik som du vill representera med regler i ditt program.

Termen "affärslogik" kan referera till många saker. Affärslogik kan till exempel vara "Inköpsorder som är större än 500 dollar kräver chefgodkännande".
Identifiera datakällor för dina regelelement. Du kan också definiera vokabulärer, som är domänspecifika nomenklatur som representerar underliggande bindningar.
Definiera de regler som ska användas från ordförrådsdefinitioner eller direkt från databindningar. Från dessa regler skapar du en regeluppsättning som representerar din affärslogik.

Exportera regler från Microsoft BizTalk Server

Om du vill återanvända befintliga regler från Microsoft BizTalk Server kan du exportera dem. Db-fakta stöds dock inte för närvarande. Innan du exporterar dina regler tar du bort eller omstrukturerar dem till andra typer av fakta med hjälp av Microsoft BizTalk Rules Composer.

Starta distributionsguiden för business rules engine från Microsoft BizTalk Server.
På sidan Välkommen till distributionsguiden för regelmotorn väljer du Nästa.
På sidan Distributionsaktivitet väljer du Exportera princip/vokabulär till fil från databasen och väljer Nästa.
På sidan Principarkiv går du till listan SQL Server-namn och väljer din SQL-server. I listan Konfigurationsdatabas på vald server väljer du BizTalkRuleEngineDb och sedan Nästa.
På sidan Exportera princip/vokabulär väljer du den princip som du vill använda i listan Princip . Om du vill hitta och välja definitionsfilen väljer du Bläddra.
När du är klar väljer du Nästa.
Bekräfta informationen om servern, databasen och principen eller vokabulären och välj Nästa.
När importen eller exporten är klar väljer du Nästa.
Granska slutförandestatusen för importen eller exporten och välj Slutför.

Skapa ett Azure Logic Apps Rules Engine-projekt

I Visual Studio Code går du till aktivitetsfältet och väljer Azure-ikonen. (Tangentbord: Skift+Alt+A)
I azure-fönstret som öppnas går du till verktygsfältet Arbetsyta i Azure Logic Apps-menyn och väljer Skapa ny arbetsyta för logikappar.
I rutan Välj mapp bläddrar du till och väljer den lokala mapp som du skapade för projektet.
När promptrutan Skapa ny logikappsarbetsyta visas anger du ett namn på din arbetsyta:

Det här exemplet fortsätter med MyLogicAppRulesWorkspace.
När rutan Välj en projektmall för arbetsyteprompten för logikappen visas väljer du Logikapp med regelmotorprojekt.

Följ de efterföljande anvisningarna för att ange följande exempelvärden:

Artikel	Exempelvärde
Funktionsnamn för funktionsprojekt	RulesFunction
Namnområdesnamn för funktionsprojekt	Contoso
Logic App	LogicApp
Arbetsflödesmall: - Tillståndskänsligt arbetsflöde - Tillståndslöst arbetsflöde	Tillståndskänsligt arbetsflöde
Arbetsflödesnamn	MyRulesWorkflow

Välj Öppna i aktuellt fönster.

När du har slutfört det här steget skapar Visual Studio Code din arbetsyta, som innehåller ett funktionsprojekt och ett logikappsregelmotorprojekt, som standard, till exempel:

Nod	beskrivning
*< arbetsytans namn>*	Innehåller både ditt funktionsprojekt och logikappens arbetsflödesprojekt.
Funktion	Innehåller artefakterna för funktionsprojektet. Till exempel är funktionsnamnet<.cs filen den kodfil där du kan skapa din kod.
LogicApp	Innehåller artefakterna för logikappens regelmotorprojekt, inklusive ett arbetsflöde.

Skriva kod för regelmotorn

På arbetsytan expanderar du noden Functions, om den inte redan har expanderats.

< Öppna filen function-name>.cs som heter RulesFunction.cs i det här exemplet.

Som standard innehåller den här filen exempelkod som har följande kodelement tillsammans med tidigare angivna exempelvärden där det är lämpligt:

Namn på namnområde
Klassnamn
Funktionsnamn
Funktionsparametrar
Returtyp
Komplex typ

I följande exempel visas den fullständiga exempelkoden för funktionen med namnet 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;}
         }
     }
}

Funktionsdefinitionen för RulesFunction innehåller en standardmetod RunRules som du kan använda för att komma igång. Den här exempelmetoden RunRules visar hur du skickar parametrar till Azure Logic Apps-regelmotorn. I det här exemplet skickar metoden regeluppsättningens namn, indatadokumenttypen, ett XML-faktum och andra värden för vidare bearbetning.

Funktionsnamnet<>.cs filen innehåller ILogger även gränssnittet, som ger stöd för loggningshändelser till en Application Insights-resurs. Du kan skicka spårningsinformation till Application Insights och lagra den informationen tillsammans med spårningsinformationen från dina arbetsflöden. Filen<function-name>.cs innehåller även objektet FileStoreRuleExplorer som får åtkomst till regeluppsättningen. Konstruktorn för FileStoreRuleExplorer använder loggerFactory för att också skicka telemetriinformation till Application Insights.

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

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

    <...>

Regelmotorn för Azure Logic Apps fungerar enligt beskrivningen i följande steg:

Motorn använder objektet FileStoreRuleExplorer för att komma åt regeluppsättningen. Regeluppsättningsfilen lagras i katalogen Regler för standardlogikappen.

I det här exemplet kallas SampleRuleSet.xmlregeluppsättningsfilen , som skapades med antingen Microsoft Rules Composer eller exporterades med Hjälp av Microsoft BizTalk Server.

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.");
}

Viktigt!

Regeluppsättningar innehåller referenser till deras fakta. Microsoft Rules Composer söker efter faktasammansättningar för att verifiera regeluppsättningen för redigering. Om du vill öppna regeluppsättningar som SampleRuleSet.xml i Microsoft Rules Composer måste du placera dem med motsvarande .NET-faktasammansättningar. Annars får du ett undantag.

Motorn använder objektet ruleSet för att skapa en instans av RuleEngine objektet.
Objektet RuleEngine tar emot regelns fakta med hjälp av Execute metoden .

I det här exemplet Execute tar metoden emot två fakta: ett XML-faktum med namnet typedXmlDocument och ett .NET-fakta med namnet currentPurchase.

När motorn har körts skrivs faktavärdena över med de värden som är resultatet av motorkörningen:

// 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;

Motorn använder den RuleExecutionResult anpassade klassen för att returnera värdena till RunRules metoden:

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

             return Task.FromResult(ruleExectionOutput);

Ersätt exempelfunktionskoden med din egen och redigera standardmetoden RunRules för dina egna scenarier.

Det här exemplet fortsätter att använda exempelkoden utan ändringar.

Kompilera och skapa din kod

När du har skrivit koden kompilerar du för att se till att det inte finns några byggfel. Funktionsprojektet innehåller automatiskt bygguppgifter, som kompilerar och sedan lägger till något av dina anpassade kodbibliotek, inklusive dina .NET-faktasammansättningar, i mappen lib\custom i logikappsprojektet där arbetsflöden letar efter anpassade funktioner som ska köras. De här uppgifterna placerar sammansättningarna i mappen lib\custom\net472 .

I Visual Studio Code går du till terminalmenyn och väljer Ny terminal.
I arbetskataloglistan som visas väljer du Functions som din aktuella arbetskatalog för den nya terminalen.

Visual Studio Code öppnar ett terminalfönster med en kommandotolk.
I terminalfönstret i kommandotolken anger du dotnet restore .\RulesFunction.csproj.
När kommandotolken visas igen anger du dotnet build .\RulesFunction.csproj.

Om bygget lyckas rapporterar terminalfönstret att bygget lyckades.
Bekräfta att följande objekt finns i logikappprojektet:
- På din arbetsyta expanderar du följande mappar: LogicApp>lib\custom>net472. Bekräfta att undermappen med namnet net472 innehåller de flera sammansättningar som krävs för att köra koden, inklusive en fil med namnet< function-name>.dll.
- På arbetsytan expanderar du följande mappar: LogicApp>lib\custom><function-name.> Bekräfta att undermappen med namnet <function-name> innehåller en function.json fil, som innehåller metadata om funktionskoden som du skrev. Arbetsflödesdesignern använder den här filen för att fastställa nödvändiga indata och utdata när du anropar koden.
I följande exempel visas exempelgenererade sammansättningar och andra filer i logikappprojektet:

Anropa dina regler från ett arbetsflöde

När du har bekräftat att koden kompileras och att logikappens regelmotorprojekt har de filer som krävs för att koden ska köras öppnar du standardarbetsflödet som ingår i logikappsprojektet.

Under LogicApp på arbetsytan expanderar <>, öppnar snabbmenyn för workflow.json och väljer Öppna designer.

I arbetsflödesdesignern som öppnas visas standardarbetsflödet, som ingår i ditt logikappsprojekt, med följande utlösare och åtgärder:
- Den inbyggda utlösaren för begäran med namnet När en HTTP-begäran tas emot.
- Den inbyggda åtgärden med namnet Anropa en lokal regelfunktion i den här logikappen.
- Den inbyggda svarsåtgärden med namnet Svar, som du använder för att svara anroparen endast när du använder utlösaren Förfrågning.
Välj åtgärden Anropa en lokal regelfunktion i den här logikappen.

Åtgärdens informationsfönster öppnas till höger.
Granska och bekräfta att parametervärdet funktionsnamn är inställt på den regelfunktion som du vill köra. Granska eller ändra andra parametervärden som din funktion använder.

Felsöka din kod och ditt arbetsflöde

Upprepa följande steg för att starta Azurite Storage-emulatorn tre gånger: en gång var för följande Azure Storage-tjänster:
- Azure Blob Service
- Azure Kötjänst
- Azure Tabelltjänst
1. Välj Kommandopalett på menyn i Visual Studio Code-vyn.
2. I kommandotolken som visas letar du upp och väljer Azurite: Starta Blob Service.
3. I arbetskataloglistan som visas väljer du LogicApp.
4. Upprepa de här stegen för Azurite: Start Queue Service och Azurite: Start Table Service.
Du lyckas när Aktivitetsfältet i Visual Studio Code längst ned på skärmen visar de tre lagringstjänster som körs, till exempel:
I aktivitetsfältet i Visual Studio Code väljer du Kör och Felsöka. (Tangentbord: Ctrl+Skift+D)
I listan Kör och felsök väljer du Anslut till logikappen (LogicApp), om den inte redan är markerad, och väljer sedan Spela upp (grön pil).

Terminalfönstret öppnas och visar den startade felsökningsprocessen. Fönstret Felsökningskonsol visas sedan och visar felsökningsstatusen. Längst ned i Visual Studio Code blir aktivitetsfältet orange, vilket anger att .NET-felsökningsprogrammet läses in.
Om du vill ange brytpunkter i funktionsdefinitionen (<.cs) eller arbetsflödesdefinitionen (>) letar du reda på radnumret där du vill ha brytpunkten och väljer kolumnen till vänster, till exempel:
Om du vill köra utlösaren Begäran manuellt i arbetsflödet öppnar du arbetsflödets översiktssida.
1. Öppna workflow.json-filens snabbmeny i logikappsprojektet och välj Översikt.
  
  På arbetsflödets översiktssida är knappen Kör utlösare tillgänglig för när du vill starta arbetsflödet manuellt. Under Egenskaper för arbetsflöde är värdet för återanrops-URL:en URL:en för en anropsbar slutpunkt som skapas av utlösaren Förfrågning i arbetsflödet. Du kan skicka begäranden till den här URL:en för att utlösa arbetsflödet från andra appar, inklusive andra arbetsflöden för logikappar.
I verktygsfältet Översikt väljer du Kör utlösare.

När arbetsflödet har börjat köras aktiverar felsökningsprogrammet din första brytpunkt.
I verktygsfältet Kör eller felsökaren väljer du en felsökningsåtgärd.

När arbetsflödeskörningen har slutförts visar sidan Översikt den färdiga körningen och grundläggande information om den körningen.
Om du vill granska mer information om arbetsflödeskörningen väljer du den färdiga körningen. I listan bredvid kolumnen Varaktighet väljer du Visa körning.
Om du vill distribuera dina logikappar med Projektet Regelmotor till Azure Logic Apps följer du stegen i Förbereda för distribution.

Feedback

Var den här sidan till hjälp?