Készíts projekteket Azure Logic Apps Rules Engine-hez a Visual Studio Code használatával

A következőkre vonatkozik: Azure Logic Apps (Standard)

Ha integrálni szeretné az üzleti logikát a Standard munkafolyamatokkal az Azure Logic Appsben, létrehozhat és létrehozhat egy Azure Logic Apps Szabálymotor-projektet a Visual Studio Code használatával. Az üzleti folyamatok működésének üzleti logikáját szabályok szabályozzák.

A szabályok futtatásához egy munkafolyamatból használj egy helyi egyedi függvényt olyan szabályhalmazokhoz, amelyek tartalmazzák a .NET tényeket. Azoknál a szabályhalmazoknál, amelyek csak XML tényeket használnak, helyette használhatod a beépített Execute Rules Engine műveletet, amely jelenleg előnézetben van.

Ez az útmutató bemutatja, hogyan hozhat létre Azure Logic Apps Szabálymotor-projektet:

Az Azure Logic Apps Rules Engine projekt létrehozásához szükséges előfeltételek és beállítások, beleértve az üzleti szabályok létrehozását a Microsoft Rules Composer segítségével.
Ha van ilyen, exportálja a meglévő szabályokat a Microsoft BizTalk Serverből.
Készíts egy Standard Logic apps projektet az Azure Logic Apps Rules Engine-hez a Visual Studio Code használatával.
A munkafolyamatból futtathatod a szabálykészleteket είτε egy helyi egyéni függvény használatával a .NET-tényekhez, είτε kizárólag a Execute Rules Engine művelettel az XML-tényekhez.

Előfeltételek

Töltse le és telepítse a Microsoft Rules Composert, amellyel szabálykészleteket, üzleti szabályokat és vokabulárokat hozhat létre.

A szabálymotor-projekt üzleti felépítéséhez tekintse meg a következő dokumentációt:
- Szabályok létrehozása a Microsoft Rules Composerrel
- Döntéskezelés és üzleti logika integrálása az Azure Logic Apps szabálymotor használatával
Ebben a kiadásban csak a Visual Studio Code támogatja egy Azure Logic Apps Rules Engine-projekt fejlesztési élményét. A Visual Studio Code használatának előfeltételeinek teljesítéséhez tekintse meg a Standard logikai alkalmazás munkafolyamatának létrehozása egybérlős Azure Logic Appsben a Visual Studio Code használatával című témakört.
A .NET tények használatához az Azure Logic Apps Rules Engine a Visual Studio Code egyedi kódfunkció funkcióját használja. A funkció használatának előfeltételeinek teljesítéséhez tekintse meg .NET-keretrendszer kód létrehozása és futtatása standard munkafolyamatokból az Azure Logic Appsben című témakört.

A projekt létrehozása előtt

A szabálymotor sikeres projektjének biztosításához tekintse át és hajtsa végre az alábbi általános feladatokat és ajánlott eljárásokat:

Határozza meg, hogyan illeszkednek az üzleti szabályok az üzleti folyamatokba.
Tervezze meg, hogyan építhet be üzleti szabályokat az alkalmazásba.
Azonosítsa az alkalmazás szabályaival képviselni kívánt üzleti logikát.

Az "üzleti logika" kifejezés számos dologra utalhat. Az üzleti logika például a következő lehet: "Az 500 dollárnál nagyobb megrendelések vezetői jóváhagyást igényelnek".
Azonosítsa a szabályelemek adatforrásait. Igény szerint definiálhat vokabulárokat, amelyek tartományspecifikus nómenklatúrák, amelyek az alapul szolgáló kötéseket jelölik.
Definiálja a szókincsdefiníciókból vagy közvetlenül adatkötésekből használandó szabályokat. Ezekből a szabályokból hozzon létre egy olyan szabálykészletet, amely az üzleti logikát képviseli.

Szabályok exportálása a Microsoft BizTalk Serverből

A Microsoft BizTalk Server meglévő szabályainak újbóli felhasználásához exportálhatja őket. A db-tények azonban jelenleg nem támogatottak. Mielőtt exportálja a szabályokat, távolítsa el vagy bontsa újra őket más típusú tényekbe a Microsoft BizTalk Rules Composer használatával.

A Microsoft BizTalk Server alkalmazásból indítsa el az Üzleti szabályok motor központi telepítési varázslót.
A Szabálymotor üzembe helyezési varázsló kezdőlapján válassza a Tovább gombot.
Az Üzembe helyezési feladat lapon válassza a Házirend/szókészlet exportálása adatbázisból fájlba lehetőséget, majd válassza a Tovább lehetőséget.
A Szabályzattár lapon, az SQL Server névlistájában válassza ki az SQL Servert. A kiválasztott kiszolgálólistában válassza a Konfigurációs adatbázis listában a BizTalkRuleEngineDb lehetőséget, majd válassza a Tovább lehetőséget.
A Házirend/Szókincs exportálása lapon válassza ki a kívánt szabályzatot a Szabályzatok listájából. A definíciófájl megkereséséhez és kiválasztásához válassza a Tallózás lehetőséget.
Ha készen áll, válassza a Tovább gombot.
Erősítse meg a kiszolgáló, az adatbázis és a szabályzat vagy a szókincs adatait, és válassza a Tovább gombot.
Az importálás vagy exportálás befejezése után válassza a Tovább gombot.
Tekintse át az importálás vagy exportálás befejezési állapotát, és válassza a Befejezés lehetőséget.

Azure Logic Apps Rules Engine-projekt létrehozása

A projekt sablon létrehoz egy funkciós projektet és egy logikai alkalmazás projektet. A függvények projektje és egyedi kódja csak akkor van szükség, ha a szabálykészleted tartalmaz .NET tényeket. Azoknál a szabályhalmazoknál, amelyek csak XML tényeket használnak, használd a munkafolyamatodban található beépített Execute Rules Engine műveletet.

A Visual Studio Code tevékenységsávján válassza az Azure ikont. (Billentyűzet: Shift+Alt+A)
A megnyíló Azure-ablakban, a Munkaterület szakasz eszköztárán, az Azure Logic Apps menüben válassza az Új logikaialkalmazás-munkaterület létrehozása lehetőséget.
A Mappa kiválasztása párbeszédpanelen keresse meg és válassza ki a projekthez létrehozott helyi mappát.
Amikor megjelenik az Új logikaialkalmazás-munkaterület létrehozása párbeszédpanel, adja meg a munkaterület nevét:

Ez a példa a MyLogicAppRulesWorkspace használatával folytatódik.
Amikor megjelenik a Select a project template for your logic app workspace prompt box, válassza a Logikai alkalmazás szabálymotor-projekttel lehetőséget.

Kövesse a következő utasításokat a következő példaértékek megadásához:

Elem	Példaérték
Függvényprojekt neve a függvényekhez	RulesFunction
Függvényprojekt névterének neve	Contoso
Logikai alkalmazás:	Logikai alkalmazás
Munkafolyamat-sablon: - Állapotalapú munkafolyamat - Állapot nélküli munkafolyamat	Állapotalapú munkafolyamat
Munkafolyamat neve	MyRulesWorkflow

Válassza a Megnyitás az aktuális ablakban lehetőséget.

A lépés befejezése után a Visual Studio Code létrehozza a munkaterületet, amely alapértelmezés szerint tartalmaz egy függvényprojektet és egy logikaialkalmazás-szabálymotor-projektet, például:

Node	Leírás
*< munkaterület neve>*	A függvényprojektet és a logikai alkalmazás munkafolyamat-projektét is tartalmazza.
Függvény	A függvényprojekt összetevőit tartalmazza. A *<függvénynév>.cs* fájl az a kódfájl, ahol megírhatja a kódját.
Logikai alkalmazás	A logikai alkalmazás szabálymotor-projektjének összetevőit tartalmazza, beleértve a munkafolyamatot is.

Írd meg a .NET-tényekhez való szabálymotor-kódot

Ha a szabálykészleted csak XML tényeket használ, ugord ezt a részt, és használd a beépített Execute Rules Engine műveletet. Ha a szabálykészleted tartalmaz .NET tényeket, hozz létre egy helyi egyedi függvényt ebben a szakaszban leírt szerint.

A munkaterületen bontsa ki a Functions csomópontot, ha még nem bontotta ki.

Nyissa meg a <function-name>.cs fájlt, amely ebben a példában RulesFunction.cs néven szerepel.

Alapértelmezés szerint ez a fájl mintakódot tartalmaz, amely a következő kódelemeket tartalmazza a korábban megadott példaértékekkel együtt, ha szükséges:

Névtér neve
Osztály neve
Függvénynév
Függvényparaméterek
Visszatérési típus
Összetett típus

Az alábbi példa a következő nevű függvény RulesFunctionteljes mintakódját mutatja be:

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

A függvénydefiníció RulesFunction tartalmaz egy alapértelmezett RunRules metódust, amelyet az első lépésekhez használhat. Ez a mintametódus RunRules bemutatja, hogyan adhatja át a paramétereket az Azure Logic Apps szabálymotorjának. Ebben a példában a metódus átadja a szabálykészlet nevét, a bemeneti dokumentum típusát, egy XML-tényt és más értékeket a további feldolgozáshoz.

A <függvénynév>.cs fájl tartalmazza a ILogger felületet is, amely támogatja az Application Insights-erőforrásokba történő naplózást. Nyomkövetési információkat küldhet az Application Insightsnak, és ezeket az információkat a munkafolyamatokból származó nyomkövetési információk mellett tárolhatja. A <függvénynév>.cs fájl tartalmazza a FileStoreRuleExplorer szabálykészlethez hozzáférő objektumot is. Mint látható, a konstruktor a telemetriai adatoknak az FileStoreRuleExplorerloggerFactory Application Insightsba való küldéséhez is használható:

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

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

    <...>

Az Azure Logic Apps szabálymotorja az alábbi lépésekben leírtak szerint működik:

A motor az FileStoreRuleExplorer objektummal éri el a szabálykészletet. A szabálykészletfájl a Standard logikai alkalmazás Szabályok könyvtárában van tárolva.

Ebben a példában a szabálykészletfájl neve SampleRuleSet.xmla Microsoft Rules Composer használatával jött létre, vagy a Microsoft BizTalk Server használatával lett exportálva.

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

Fontos

A szabálykészletek hivatkoznak a tényeikre. A Microsoft Rules Composer a tények komponenseit keresi a szabálykészlet szerkesztés előtti ellenőrzéséhez. Ha olyan szabálykészleteket szeretne megnyitni, mint például SampleRuleSet.xml a Microsoft Rules Composerben, a megfelelő .NET-tényösszesítésekkel kell őket elhelyeznie. Ellenkező esetben kivételt kap.

A motor az ruleSet objektum használatával hozza létre az objektum egy példányát RuleEngine .
Az RuleEngine objektum a Execute metódussal fogadja a szabály tényeit.

Ebben a példában a Execute metódus két tényt kap: egy XML tényezőt, amelyet typedXmlDocument-nek neveznek, és egy .NET tényezőt, amelyet currentPurchase-nek neveznek.

A motor futtatása után a tények értékei felülíródnak a motor végrehajtásából eredő értékekkel:

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

A motor az RuleExecutionResult egyéni osztály használatával adja vissza az értékeket a RunRules metódusnak:

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

             return Task.FromResult(ruleExectionOutput);

Cserélje le a mintakódot a sajátjára, és szerkessze az Ön saját eseteihez az alapértelmezett RunRules metódust.

Ez a példa továbbra is módosítás nélkül használja a mintakódot.

Fordítsd le és készítsd el a kódodat a .NET-hez

Ha a szabálykészleted csak XML tényeket használ, és a beépített Execute Rules Engine műveletet tervezed, hagyd ki ezt a részt. Ha a szabálykészleted tartalmaz .NET tényeket, a kód megírása után fordítsd le, hogy biztosan ne legyenek build-hiba. A funkcióprojekted automatikusan tartalmazza a build feladatokat, amelyek lefordítják és hozzáadnak bármilyen egyedi kódkönyvtárat, beleértve a .NET tényösszeállításokat is, a logikai alkalmazás projektjében található lib\custom mappába, ahol a munkafolyamatok egyedi függvényeket keresnek futtatni. Ezek a feladatok a szerelvényeket a lib\custom\net472 mappába helyezik.

A Visual Studio Code Terminál menüjében válassza az Új terminál lehetőséget.
A megjelenő munkakönyvtár-listából válassza a Functions elemet az új terminál aktuális munkakönyvtáraként.

A Visual Studio Code egy parancssort tartalmazó terminálablakot nyit meg.
A terminálablak parancssorában adja meg a dotnet restore .\RulesFunction.csproj parancsot.
Miután a parancssor ismét megjelent, adja meg a dotnet build .\RulesFunction.csproj parancsot.

Ha a build sikeres, a terminálablak azt jelenti, hogy a build sikeres volt.
Győződjön meg arról, hogy a következő elemek szerepelnek a logikai alkalmazás projektjében:
- A munkaterületen bontsa ki a következő mappákat: LogicApp>lib\custom>net472. Ellenőrizze, hogy a net472 nevű almappa tartalmazza-e a kód futtatásához szükséges több összetevőt, beleértve a <függvénynév>.dll fájlt.
- A munkaterületen bontsa ki a következő mappákat: LogicApp>lib\custom><function-name.> Győződjön meg arról, hogy a <függvénynév> almappában található egy function.json fájl, amely tartalmazza az Ön által írt függvénykód metaadatait. A munkafolyamat-tervező ezzel a fájllal határozza meg a kód meghívásakor szükséges bemeneteket és kimeneteket.
Az alábbi példa a logikai alkalmazás projektjében létrehozott mintaszerelvényeket és más fájlokat mutatja be:

Szabályok meghívása munkafolyamatból

.NET-tények meghívása helyi egyéni függvényekkel

Olyan szabályhalmazokhoz, amelyek tartalmaznak .NET tényeket, használj egy helyi egyedi függvényt. Miután ellenőrizte, hogy a kód lefordítva van-e, és hogy a logikai alkalmazás szabálymotor-projektje rendelkezik-e a kód futtatásához szükséges fájlokkal, nyissa meg a logikai alkalmazás projektjéhez tartozó alapértelmezett munkafolyamatot.

A munkaterületen a LogicApp alatt bontsa ki a <workflow-name> csomópontot, nyissa meg a workflow.json helyi menüt, és válassza a Tervező megnyitása lehetőséget.

A megnyíló munkafolyamat-tervezőben a logikai alkalmazás projektjéhez tartozó alapértelmezett munkafolyamat a következő eseményindítóval és műveletekkel jelenik meg:
- A HTTP-kérés fogadásakor elnevezett beépített kérelem-eseményindító.
- A logikai alkalmazás beépített művelete a „Helyi szabályok meghívása nevű” függvényt hívja meg.
- A Válasz nevű beépített válaszművelet, amellyel csak a Kérés eseményindító használatakor válaszolhat a hívónak.
Válassza ki a helyi szabályok meghívása függvény meghívása nevű műveletet ebben a logikai alkalmazásban.

A művelet információs panelje a jobb oldalon nyílik meg.
Ellenőrizze és ellenőrizze, hogy a függvénynév paraméter értéke a futtatni kívánt szabályfüggvényre van-e beállítva. Tekintse át vagy módosítsa a függvény által használt egyéb paraméterértékeket.

XML tények hívása a Execute Rules Engine művelet használatával

Azoknál a szabályhalmazoknál, amelyek csak XML tényeket használnak, használd a beépített Execute Rules Engine műveletet. Nem kell helyi egyedi függvényt írnod, fordítanod vagy hívnod.

Fontos

A Execute Rules Engine művelet előnézetben van, és csak XML tényeket támogat. A .NET tények használatához hívjunk egy helyi egyedi függvényt.

A munkaterületen a LogicApp alatt bontsa ki a <workflow-name> csomópontot, nyissa meg a workflow.json helyi menüt, és válassza a Tervező megnyitása lehetőséget.
A munkafolyamattervezőn, a trigger vagy akció alatt, ahol a szabálykészletet futtatni szeretnéd, add hozzá a Execute Rules Engine nevű műveletet az általános lépések követésével, hogy egy műveletet hozzáadj a munkafolyamathoz.
Az akcióinformációk sávjában, a Szabálykészlet listájából válaszd ki azt a szabálykészletet, amit futtatni szeretnél. Ez a példa a Validációt választja.
Nyisd meg az Advanced paraméterek listáját.

Minden XML tény esetén, amelyet a kiválasztott szabálykészlet vár, a lista tartalmaz egy paramétert, amely a Fact előtaggal kezdődik. Ez a példa a Fact: Backend opciót választja.
Válaszd ki minden tényparamétert, amit meg akarsz adni.
Minden tényparaméterhez megadja a megfelelő XML dokumentumot.

Beléphetsz XML-be, vagy választhatsz XML kimenetet egy korábbi munkafolyamat-műveletből. Ez a példa egy előző Compose XML with schema műveletBody XML kimenetét használja.

Amikor az akció elindul, a szabálymotor alkalmazza a kiválasztott szabálykészletet az XML tényekre. Az akció kimenetét a következő munkafolyamat-műveletekben is használhatod. Ebben a példában a munkafolyamat Parse XML-t és sémát használ a kapott XML feldolgozásához.

A kód és a munkafolyamat hibakeresése

A következő lépések akkor érvényesek, ha helyi egyedi függvényt használsz olyan szabályhalmazokhoz, amelyek tartalmazzák a .NET tényeket. Egy csak XML-t használó szabálykészlet esetén, amely a beépített Execute Rules Engine műveletet használja, hibakeresse a munkafolyamatot, és tekintse át a művelet bemeneteit és kimeneteit a munkafolyamat futtatási előzményeiben.

Ismételje meg a következő lépéseket az Azurite Storage Emulator háromszori elindításához: egyenként a következő Azure Storage-szolgáltatásokhoz:
- Azure Blob Service
- Az Azure üzenetsor-kezelési szolgáltatása
- Microsoft Azure Táblaszolgáltatás
1. A Visual Studio Code View menüjében válassza a Parancskatalógus lehetőséget.
2. A megjelenő parancssorban keresse meg és válassza az Azurite: Blob Service indítása lehetőséget.
3. A megjelenő munkakönyvtár-listából válassza a LogicApp lehetőséget.
4. Ismételje meg ezeket a lépéseket az Azurite: Queue Service indítása és az Azurite: Table Service indítása esetén.
Sikeresnek bizonyul, ha a képernyő alján található Visual Studio Code tálcán látható a három futó tárolási szolgáltatás, például:
A Visual Studio Code tevékenységsávján válassza a Futtatás és hibakeresés lehetőséget. (Billentyűzet: Ctrl+Shift+D)
A Futtatás és hibakeresés listában válassza a Csatolás a logikai alkalmazáshoz (LogicApp) lehetőséget, ha még nincs kijelölve, majd válassza a Lejátszás (zöld nyíl) lehetőséget.

Megnyílik a terminálablak , és megjeleníti az elindított hibakeresési folyamatot. Ekkor megjelenik a Hibakeresési konzol ablak, és megjeleníti a hibakeresési állapotokat. A Visual Studio Code alján a tevékenységsáv narancssárgára változik, ami azt jelzi, hogy a .NET-hibakereső be van töltve.
Töréspontok beállításához a függvénydefinícióban (<.cs) vagy munkafolyamat-definícióban (>) keresse meg azt a sorszámot, ahol a töréspontot használni szeretné, és válassza ki a bal oldalon lévő oszlopot, például:
Ha manuálisan szeretné futtatni a Kérelem eseményindítót a munkafolyamatban, nyissa meg a munkafolyamat Áttekintés lapját.
1. A logikai alkalmazás projektjében nyissa meg a workflow.json fájl helyi menüjét, és válassza az Áttekintés lehetőséget.
  
  A munkafolyamat Áttekintés lapján a Futtatás eseményindító gomb érhető el, ha manuálisan szeretné elindítani a munkafolyamatot. A Munkafolyamat tulajdonságai területen a visszahívási URL-érték egy hívható végpont URL-címe, amelyet a munkafolyamat Kérés eseményindítója hoz létre. Erre az URL-címre küldhet kéréseket a munkafolyamat más alkalmazásokból való aktiválásához, beleértve az egyéb logikai alkalmazások munkafolyamatait is.
Az Áttekintés lap eszköztárán válassza az Indító futtatása lehetőséget.

A munkafolyamat futtatása után a hibakereső aktiválja az első töréspontot.
A Futtatás menüben vagy a hibakereső eszköztáron válasszon egy hibakeresési műveletet.

A munkafolyamat lefutását követően az Áttekintés lapon megjelenik a befejezett futtatás és annak alapvető részletei.
A munkafolyamat futtatásával kapcsolatos további információk áttekintéséhez válassza ki a befejezett futtatás lehetőséget. Vagy az Időtartam oszlop melletti listából válassza a Futtatás megjelenítése lehetőséget.
Ha a logikai alkalmazásokat a Szabálymotor projekttel szeretné üzembe helyezni az Azure Logic Appsben, kövesse a Felkészülés az üzembe helyezésre című témakörben leírt lépéseket.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Utolsó frissítés időpontja: 2026-09-16