Dela via

Lägga till kontrollfunktioner i åtgärder för att optimera regelkörning med Microsoft Rules Composer (förhandsversion)

  • Artikel

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

Viktigt!

Den här funktionen är i förhandsversion och omfattas av kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Den här guiden beskriver hur du optimerar regelkörning genom att lägga till kontrollfunktioner i åtgärder i dina regler med hjälp av Microsoft Rules Composer. Kontrollfunktioner hjälper ditt program eller regeluppsättning att kontrollera fakta i regelmotorns arbetsminne. Dessa funktioner omfattar funktionerna Assert, Clear, Halt, Retract, RetractByType, Reassert och Update för de .NET-objekt och TypedXmlDocument-entiteter som du kan använda som fakta. Förekomsten av fakta i arbetsminnet styr de villkor som motorn utvärderar och de åtgärder som körs.

Förutsättningar

  • Ladda ned och installera Microsoft Rules Composer.

  • XML-filen som innehåller den regeluppsättning som du vill arbeta med.

    Om du vill lägga till fakta anger du deras värden i DE XML-dokument som du pekar på från fönstret RuleSet Explorer. Eller så kan du använda en faktaskapare för att förse regelmotorn med en matris som innehåller .NET-objekt som fakta. Mer information finns i Skapa faktaskapare och hämtningar.

Assert-funktion

Om du vill lägga till objektinstanser i regelmotorns arbetsminne använder du funktionen Assert i Microsoft Rules Composer. Motorn bearbetar varje objektinstans enligt de villkor och åtgärder som skrivs mot instansens typ med hjälp av match-conflict resolution-action-faserna.

I följande tabell sammanfattas funktionen Assert för de enheter och instanstyper som stöds, inklusive antalet resulterande instanser som skapats i motorn för varje bekräftad entitet och den typ som tillämpas på varje instans för identifiering.

Enhet Antal instanser som har hävdats Instanstyp
.NET-objekt 1 (själva objektet) Fullständigt kvalificerad .NET-klass
TypedXmlDocument 1-N TypedXmlDocument(s): Baserat på de selektorbindningar som skapats och dokumentinnehåll DocumentType.Selector

Bekräfta ett .NET-objekt

Regelmotorn har inbyggt stöd för grundläggande .NET-skalära typer och objekt för referenstyper. Den mest enkla bearbetningen av .NET-objekt är bearbetningstyperna.

I Microsoft Rules Composer kan du göra anspråk på ett .NET-objekt inifrån en regel.

  1. I Microsoft Rules Composer läser du in XML-filen som innehåller det regelarkiv som du vill arbeta med.

  2. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  3. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen Assert som en åtgärd.

  4. I fönstret Faktautforskaren väljer du .NET-klasser.

  5. Dra konstruktormetoden för det objekt som du vill använda till argumentet i åtgärden Assert på fliken .NET-klasser.

    Microsoft Rules Composer översätter konstruktormetoden till ett CreateObject-anrop i regeldefinitionen.

    Kommentar

    Även om regelmotorn har en CreateObject-funktion visas inte funktionen som en separat funktion i Microsoft Rules Composer.

Varje objekt hävdas i arbetsminnet som en separat objektinstans, vilket innebär att varje predikat som refererar till objektets typ, till exempel IF Object.Property = 1, analyserar instansen. Instansen är också tillgänglig för regelåtgärder som refererar till typen, baserat på resultatet av regelvillkoren.

Anta till exempel att du har följande regler:

Regel 1

IF A.Value = 1
THEN A.Status = "good"

Regel 2

IF B.Value = 1
THEN A.Status = "good"

I regel 1 uppdateras endast A-instanser med värdet 1. I regel 2 har dock alla A-instanser statusen uppdaterad om villkoret utvärderas till sant. Om det finns flera B-instanser uppdateras A-instanserna varje gång villkoret utvärderas till sant för en B-instans.

Bekräfta en TypedXmlDocument-entitet

I Microsoft Rules Composer kan du ange en TypedXmlDocument-entitet inifrån en regel.

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen Assert som en åtgärd.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. Dra den nod som du vill använda till argumentet i åtgärden Assert på fliken XML-scheman.

XML-dokument är i princip text, men fältvärdena kan vara valfri typ, vilket baseras på den angivna typen när regeln skapades. Fält är XPath-uttryck, så de kan returnera en noduppsättning, vilket innebär att det första objektet i uppsättningen används som värde.

När en TypedXmlDocument-entitet hävdas som ett faktum skapar regelmotorn TypedXmlDocument underordnade instanser baserat på de väljare som definierats i regeln. Du kan se väljare som ett sätt att isolera noderna i ett XML-dokument och fält som identifierar specifika objekt i väljaren. Regelmotorn grupperar alla fält i en väljare som ett objekt.

Väljare är också XPath-uttryck. När du väljer en nod på fliken XML-scheman i Faktautforskaren fyller Microsoft Rules Composer automatiskt i egenskapen XPath Selector för alla noder och egenskapen XPath Field för alla noder som inte innehåller underordnade noder. Du kan också ange dina egna XPath-uttryck för XPath Selector och XPath Field om det behövs. Om väljaren matchar flera delar i XML-dokumentet bekräftas flera objekt av den här typen till eller återkallas från regelmotorns arbetsminne.

Du kan använda flera väljare i samma dokument. På så sätt kan du visa olika delar av dokumentet, till exempel anta att ett avsnitt är beställningen och ett annat avsnitt innehåller leveransadressen. Tänk dock på att de skapade objekten definieras av XPath-strängen som skapade dem. Om du använder ett annat XPath-uttryck är resultatet en unik TypedXmlDocument-entitet , även om uttrycket matchas till samma nod.

Anta till exempel att du har följande XML:

<root>
    <order customer="Joe">
        <item name="router" quantity="10" cost="550" />
        <item name="switch" quantity="3" cost="300" />
    </order>
    <order customer="Jane">
        <item name="switch" quantity="1" cost="300" />
        <item name="cable" quantity="23" cost="9.99" />
    </order>
</root>

Om du använder väljaren /root/order eller ordning läggs följande objekt till i motorns arbetsminne:

Objekt 1

<order customer="Joe">
    <item name="router" quantity="10" cost="550" />
    <item name="switch" quantity="3" cost="300" />
</order>

Objekt 2

<order customer="Jane">
    <item name="switch" quantity="1" cost="300" />
    <item name="cable" quantity="23" cost="9.99" />
</order>

I varje väljare refererar XPaths till de enskilda fälten. Om du använder väljaren /root/order/item, order/item eller item läggs följande objekt till i motorns arbetsminne med två objekt för Joe och de två objekten för Jane:

<root>
    <order customer="Joe">
    </order>
    <order customer="Jane">
    </order>
</root>

Varje objekt har åtkomst till tre fält: @name, @quantity och @cost. Du kan referera till de överordnade fälten eftersom objektet är en referens till det ursprungliga dokumentet, till exempel .. /@customer.

I bakgrunden kan regelmotorn konvertera ett textfältvärde till någon av de typer som stöds via funktionen XmlConvert . Du kan ange det här alternativet genom att ange typen i Microsoft Rules Composer. Om en konvertering inte är möjlig utlöser motorn ett undantag. Du kan endast hämta bool - och dubbeltyperna som deras respektive typ, antingen strängar eller objekt.

Funktionen Rensa

Om du vill återställa arbetsminnet och agendan för en regelmotorinstans använder du funktionen Clear i Microsoft Rules Composer. Mer information om arbetsminne och agenda finns i Regelmotoroptimering.

Återställa arbetsminnet och agendan för regelmotorn

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel där du vill rensa arbetsminnet och agendan för regelmotorn.

  2. I fönstret THEN under Åtgärder lägger du till funktionen Rensa inbyggd som en åtgärd.

    Funktionen Clear tar inga argument.

Funktionen Stoppa

Om du vill stoppa den aktuella körningen av regelmotorn använder du funktionen Halt i Microsoft Rules Composer.

Stoppa körning av regeluppsättningar

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel där du vill stoppa körningen av regeluppsättningen.

  2. I fönstret THEN under Åtgärder lägger du till funktionen Stoppa inbyggd som en åtgärd.

Funktionen Halt tar ett enda booleskt argument. Om du anger värdet som sant rensar regelmotorn den agenda som innehåller de väntande kandidatreglerna.

Metoden Ruleset.Execute är en omslutning runt metoden RuleEngine.Execute och använder kod som liknar följande kod:

RuleEngine.Assert(facts);
RuleEngine.Execute();
RuleEngine.Retract(facts);

Om du använder metoden Ruleset.Execute för att köra en regeluppsättning returnerar regelmotorn kontrollen till metoden Ruleset.Execute när funktionen Stoppa körs. Metoden Ruleset.Execute återkallar fakta och returnerar kontrollen till anroparen. I det här fallet kan körningen av stoppade regeluppsättningar inte återupptas.

Men om du använder metoden RuleEngine.Execute direkt för att köra regeluppsättningen kan du återuppta körningen av den stoppade regeluppsättningen med nästa väntande regel som utlöses genom att anropa RuleEngine.Execute igen, förutsatt att du inte har återkallat några objekt som behövs mellan de två anropen.

Kommentar

Metoden Ruleset.Execute cachelagrar regelmotorinstanserna för bättre prestanda. Om du använder metoden RuleEngine.Execute direkt cachelagras inte regelmotorinstanserna.

Följande exempelkod visar hur du återupptar körningen av stoppade regeluppsättningar:

// Assert facts into working memory of the rules engine instance.
RuleEngine.Assert(facts);

// Execute the ruleset.
RuleEngine.Execute();

// The ruleset invokes the Halt method when executing actions.
// Control returns here when the Halt function is called. 
// When engine halts, do the following tasks.

// Add your code here.

// Resume the halted rules engine execution.
RuleEngine.Execute();

// Retract or remove facts from working memory in the rules engine.
RuleEngine.Retract(facts);

Funktionen Återkalla

Om du vill ta bort objekt från en regeluppsättning och från regelmotorns arbetsminne använder du funktionen Återkalla i Microsoft Rules Composer.

Återkalla ett .NET-objekt

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. Under Åtgärder i fönstret THEN lägger du till den inbyggda funktionen Återkalla som en åtgärd.

  3. I fönstret Faktautforskaren väljer du .NET-klasser.

  4. På fliken .NET-klasser drar du den klass som du vill använda, inte sammansättningen eller metoden, till argumentet för parametern Retract.

    Om du drar en metod till funktionen Återkalla försöker motorn återkalla objektet som returneras av metoden.

Om du återkallar ett .NET-objekt påverkas följande:

  • Åtgärder på dagordningen som använder objekten tas bort från dagordningen.

    Kommentar

    Andra åtgärder högre upp på dagordningen kanske redan har utförts innan du använder funktionen Återkalla .

  • Regler som använder objektet i en predikat får sina åtgärder borttagna från dagordningen, om det finns några åtgärder på dagordningen.

  • Motorn utvärderar inte längre objektet.

Återkalla en TypedXmlDocument-entitet eller entiteter

Du kan återkalla den ursprungliga TypedXmlDocument-entiteten som har försäkrats i regelmotorn, eller så kan du återkalla en av de underordnad entiteterna TypedXmlDocument som skapats från den överordnade XmlDocument-entiteten .

Anta att du har följande xml-exempel:

<order>
    <orderline customer="Joe" linenumber="001">
        <product name="router" quantity="10" cost="550" />
    </orderline>
    <orderline customer="Jane" linenumber="002">
        <product name="switch" quantity="1" cost="300" />
    </orderline>
</order>

Du kan antingen återkalla entiteten TypedXmlDocument som är associerad med ett orderobjekt eller återkalla en eller båda av de TypedXmlDocument-entiteter som är associerade med orderline-objektet. Alla TypedXmlDocument-entiteter är associerade med entiteten TypedXmlDocument på den översta nivån som ursprungligen hävdades, inte med entiteten TypedXmlDocument som visas ovanför noden TypedXmlDocument på den översta nivån i XML-trädhierarkin.

Produkten är till exempel en TypedXmlDocument-entitet under orderradsobjektet och är associerad med entiteten TypedXmlDocument för beställning, inte entiteten TypedXmlDocument för orderraden. I de flesta fall är den här skillnaden inte viktig. Men om du återkallar orderobjektet återkallas även orderraden och produktobjekten. Om du återkallar orderline-objektet återkallas bara det objektet, inte produktobjektet .

Motorn fungerar bara med och spårar objektinstanserna, som är TypedXmlDocument-instanser , som motorn skapade när entiteten TypedXmlDocument ursprungligen hävdades. Om du skapar ytterligare noder, till exempel syskonnoder för en nod som har valts via en väljare i regeluppsättningen, utvärderas inte dessa noder i regler såvida inte TypedXmlDocument-entiteter skapas och hävdas för dem. Om du hävdar dessa nya TypedXmlDocument-instanser på lägre nivå utvärderar motorn instanserna i reglerna, men entiteten TypedXmlDocument på den översta nivån har ingen kunskap om dem. När den översta nivån TypedXmlDocument återkallas återkallas inte de nya, oberoende indragna TypedXmlDocument-entiteterna automatiskt. Om nya noder skapas utför du därför en Återkalla och bekräfta på den fullständiga XmlDocument, vilket är det typiska och enklaste steget att ta.

Klassen TypedXmlDocument innehåller användbara metoder som du kan anropa inom en anpassad .NET-medlem som en del av en åtgärd. Dessa metoder omfattar möjligheten att hämta XmlNode som är associerad med TypedXmlDocument eller det överordnade TypedXmlDocument.

Återkalla entiteten TypedXmlDocument på den översta nivån

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. Under Åtgärder i fönstret THEN lägger du till den inbyggda funktionen Återkalla som en åtgärd.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. På fliken XML-scheman drar du noden på den översta nivån för schemat till argumentet för funktionen Återkalla .

    Den översta noden slutar i .xsd-tillägget och representerar dokumentets rotnod, inte noden för dokumentelementet. Noden har en / väljare som refererar till den första TypedXmlDocument. När du återkallar den överordnade TypenedXmlDocument tas alla typedXmlDocument-underordnade entiteter som är associerade med TypedXmlDocument bort från arbetsminnet, inklusive alla TypedXmlDocument-entiteter som skapats genom att anropa funktionen Assert, baserat på väljare som används i regeluppsättningen.

Återkalla en underordnad TypedXmlDocument-entitet

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. Under Åtgärder i fönstret THEN lägger du till den inbyggda funktionen Återkalla som en åtgärd.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. Dra den underordnade noden till argumentet för funktionen Retract från fliken XML-scheman.

Funktionen RetractByType

Om du vill ta bort alla objekt med den angivna typen från regelmotorns arbetsminne använder du funktionen RetractByType i Microsoft Rules Composer. Den här funktionen skiljer sig från funktionen Återkalla , som endast tar bort specifika objekt med en viss typ.

Återkalla alla .NET-objekt med en viss typ

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen RetractByType som en åtgärd.

  3. I fönstret Faktautforskaren väljer du .NET-klasser.

  4. Dra klassen till argumentet för funktionen RetractByType från fliken .NET-klasser.

Återkalla alla TypedXmlDocument-entiteter med en viss typ

RetractByType tar bort alla TypedXmlDocument-entiteter med samma DocumentType.Selector.

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen RetractByType som en åtgärd.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. Dra lämplig nod från fliken XML-scheman till funktionen RetractByType.

Om du använder funktionen RetractByType på rotnoden för dokument är det inte bara den här åtgärden som återkallar alla TypedXmlDocument-entiteter som hävdas med documenttype, utan även alla underordnade TypedXmlDocument-entiteter eller XmlNode-noder i trädhierarkin, som är associerade med dessa överordnade TypedXmlDocument-entiteter.

Bekräfta funktionen igen

Om du vill anropa funktionen Assert på ett objekt som redan finns i motorns arbetsminne använder du funktionen Reassert i Microsoft Rules Composer. Beteendet motsvarar utfärdandet av ett Återkalla-kommando för objektet, följt av ett Assert-kommando .

Om du till exempel använder funktionen Reassert på ett .NET-objekt utför regelmotorn följande steg:

  1. Återkalla .NET-objektet från arbetsminnet.

  2. Ta bort alla åtgärder på dagordningen för regler som använder objektet i en predikat eller åtgärd.

  3. Kontrollera .NET-objektet tillbaka till arbetsminnet och utvärdera som ett nyligen kontrollerat objekt.

  4. Omvärdera alla regler som använder objektet i ett predikat och lägg till dessa reglers åtgärder på dagordningen efter behov.

  5. Läste åtgärderna till agendan för alla regler som tidigare utvärderats till true och endast använder objektet i sina åtgärder.

Bekräfta ett .NET-objekt igen

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. Lägg till den inbyggda funktionen Reassert som en åtgärd under Åtgärder i fönstret THEN.

  3. I fönstret Faktautforskaren väljer du .NET-klasser.

  4. Dra klassen till argumentet för funktionen Reassert på fliken .NET-klasser.

Bekräfta en TypedXmlDocument-entitet igen

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. Lägg till den inbyggda funktionen Reassert som en åtgärd under Åtgärder i fönstret THEN.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. Dra den entitetsnod som du vill använda till argumentet i funktionen Reassert på fliken XML-scheman.

Om du återupprättar en typedXmlDocument-entitet på toppnivå kan de underordnade entiteterna TypedXmlDocument, som skapades när den översta nivån typedXmlDocument-entiteten först hävdades, bete sig annorlunda, beroende på tillståndet för varje TypedXmlDocument-underordnad entitet.

Om till exempel en ny eller befintlig underordnad entitet är "smutsig", vilket innebär att minst ett fält har ändrats i regeluppsättningen med hjälp av en åtgärd, utförs en Assert-funktion eller återerövringsfunktion på det underordnade objektet. Alla befintliga barn som inte är smutsiga finns kvar i arbetsminnet.

Kommentar

En nod är inte markerad som smutsig från externa åtgärder som motorn inte känner till, till exempel att ett externt program programmässigt lägger till, tar bort eller uppdaterar noden.

I följande exempel visas ett förenklat scenario som beskriver de underordnade entitetsbeteendena när deras överordnade entitet bekräftas igen. Anta att du har följande TypedXmlDocument-entiteter i arbetsminnet: Parent, Child1, Child2 och Child3.

  • Överordnad är entiteten TypedXmlDocument på den översta nivån.
  • Varje underordnad innehåller ett fält med namnet ExampleField där värdet är inställt på 1, Child1.ExampleField till exempel = 1'.

Anta att en regelåtgärd utför följande åtgärder på de underordnade entiteterna:

  • ExampleField-värdet för Child2 uppdateras från 1 till 0.
  • Användarkoden tar bort Underordnad 3.
  • Användarkoden lägger till en ny underordnad TypedXmlDocument-entitet med namnet NewChild till Överordnad.

I följande exempel visas den nya representationen av objekt i arbetsminnet:

Parent
Child1 // Where Child1.ExampleField = 1
Child2 // Where Child2.ExampleField = 0
NewChild

Anta nu att du återerövrar den överordnade entiteten, vilket resulterar i följande underordnade entitetsbeteenden:

  • Child2 bekräftas igen eftersom det nu är smutsigt efter att dess fält har uppdaterats.
  • Child3 återkallas från arbetsminnet.
  • NewChild hävdas i arbetsminnet.
  • Child1 förblir oförändrat i arbetsminnet eftersom det inte uppdaterades innan Överordnad återerövrades.

Funktionen Update

Om du vill återupprätta ett objekt i regelmotorn för omvärdering, baserat på nya data och tillstånd, använder du funktionen Uppdatera i Microsoft Rules Composer. Objektet kan ha .NET-klasstyp eller TypedXmlDocument-typ . Du kan också använda funktionen Uppdatera för att förbättra motorns prestanda och förhindra oändliga loopscenarier.

Viktigt!

Standardvärdet för maximalt antal loopar för regelomvärdering är 2^32, så för vissa regler kan regeluppsättningskörningen pågå länge. Om du vill minska antalet loopar ändrar du egenskapen Maximum Execution Loop Depth (Maximalt körningsslingdjup) i regeluppsättningsversionen.

Uppdatera ett .NET-objekt

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen Uppdatera som en åtgärd.

  3. I fönstret Faktautforskaren väljer du .NET-klasser.

  4. Dra klassen till argumentet för funktionen Update på fliken .NET-klasser.

Vanligtvis använder du Assert för att placera ett nytt objekt i regelmotorns arbetsminne och använda Uppdatera för att uppdatera ett redan befintligt objekt i arbetsminnet. När du hävdar ett nytt objekt som ett faktum omvärderar motorn villkoren i alla regler. Men när du uppdaterar ett befintligt objekt utvärderar motorn endast villkor som använder det uppdaterade faktumet och lägger till åtgärder i agendan, om dessa villkor utvärderas till sanna.

Anta till exempel att du har följande regler och att objekten med namnet ItemA och ItemB redan finns i arbetsminnet.

  • Regel 1 utvärderar ID-egenskapen i ItemA, anger ID-egenskapen på ItemB och bekräftar sedan ItemB igen efter ändringen. När ItemB bekräftas igen behandlar motorn ItemB som ett nytt objekt, och motorn omvärderar alla regler som använder ItemB i predikaten eller åtgärderna. Det här beteendet ser till att motorn omvärderar regel 2 mot det nya värdet i ItemB.Id som anges i regel 1.

    Regel 1

    IF ItemA.Id == 1
THEN ItemB.Id = 2
Assert(ItemB)

  • Regel 2 kan misslyckas med den första utvärderingen, men utvärderas till true under den andra utvärderingen.

    Regel 2

    IF ItemB.Id == 2
THEN ItemB.Value = 100

Möjligheten att återerövrar objekt till arbetsminnet ger dig explicit kontroll över beteendet i scenarier med framåtlänkning. Det här exemplet visar dock en bieffekt från en omvärdering där även regel 1 omvärderas. Med ItemA.Id oförändrad utvärderas regel 1 igen till true och åtgärden Assert(ItemB) utlöses igen. Därför skapar regeln en oändlig loopsituation.

Förhindra oändliga loopar

Du måste kunna återupprätta objekt utan att skapa oändliga loopar. Om du vill undvika sådana scenarier kan du använda funktionen Uppdatera . Precis som funktionen Reassert utför funktionen Update funktionerna Retract och Assert på de associerade objektinstanser som ändras av regelåtgärder, men med följande viktiga skillnader:

  • På dagordningen står åtgärder för regler kvar på dagordningen när instanstypen endast används i åtgärderna, inte predikaten.

  • Regler som endast använder instanstypen i åtgärder omvärderas inte.

Därför omvärderas regler som använder instanstyperna, antingen endast i predikaten eller både predikaten och åtgärderna, och reglernas åtgärder läggs till på dagordningen efter behov.

Genom att ändra föregående exempel så att funktionen Uppdatera används kan du se till att motorn endast omvärderar regel 2 eftersom villkoret för regel 2 använder ItemB. Motorn omvärderar inte regel 1 eftersom ItemB endast används i åtgärderna för regel 1*, vilket eliminerar loopningsscenariot.

Regel 1

IF ItemA.Id == 1
THEN ItemB.Id = 2
Update(ItemB)

Regel 2

IF ItemB.Id == 2
THEN ItemB.Value = 100

Trots att funktionen Uppdatera används på det här sättet finns det fortfarande möjlighet att skapa loopningsscenarier. Tänk till exempel på följande regel:

IF ItemA.Id == 1
THEN ItemA.Value = 20
Update(ItemA)

Predikatet använder ItemA, så motorn omvärderar regeln när Uppdatering anropas på ItemA. Om värdet för ItemA.Id inte ändras någon annanstans fortsätter regel 1 att utvärderas som sant, vilket gör att uppdatering anropas igen på ItemA.

Som regeldesigner måste du undvika att skapa sådana loopningsscenarier. Den lämpliga metoden för att åtgärda det här problemet skiljer sig beroende på reglernas art.

I följande exempel visas ett enkelt sätt att lösa problemet i föregående exempel genom att lägga till en kontroll av ItemA.Value som hindrar regeln från att utvärderas som true igen efter att regelns åtgärder kördes första gången.

IF ItemA.Id == 1 and ItemA.Value != 20
THEN ItemA.Value = 20
Update(ItemA)

Uppdatera en TypedXmlDocument-entitet

  1. I fönstret RuleSet Explorer letar du upp och väljer den regel som du vill använda.

  2. I fönstret THEN under Åtgärder lägger du till den inbyggda funktionen Uppdatera som en åtgärd.

  3. I fönstret Faktautforskaren väljer du XML-scheman.

  4. Dra den entitetsnod som du vill använda till argumentet i funktionen Uppdatera på fliken XML-scheman.

Anta till exempel att du har följande regler:

  • Regel 1 utvärderar det totala antalet artiklar i ett inköpsordermeddelande.

    IF 1 == 1
THEN ProcessPO.Order:/Order/Items/TotalCount = (ProcessPO.Order:/Order/Items/TotalCount + ProcessPO:/Order/Items/Item/Count)

  • Regel 2 anger statusen till "Behöver godkännande" om det totala antalet är större än eller lika med 10.

    Regel 2

    IF ProcessPO.Order:/Order/Items/TotalCount >= 10
THEN ProcessPO.Order:/Order/Status = "Needs approval"

Om du skickar följande inköpsordermeddelande som indata till den här regeluppsättningen ser du att statusen inte är inställd på "Behöver godkännande", även om TotalCount är 14. Det här beteendet inträffar eftersom regel 2 endast utvärderas i början när TotalCount-värdet är 0. Regeln utvärderas inte varje gång TotalCount uppdateras.

<ns0:Order xmlns:ns0="http://ProcessPO.Order">
    <Items>
        <Item>
            <Id>ITM1</Id>
            <Count>2</Count>
        </Item>
        <Item>
            <Id>ITM2</Id>
            <Count>5</Count>
        </Item>
        <Item>
            <Id>ITM3</Id>
            <Count>7</Count>
        </Item>
        <TotalCount>0</TotalCount>
    </Items>
    <Status>No approval needed</Status>
</ns0:Order>

Om du vill att motorn ska utvärdera villkoren varje gång totalkontot uppdateras måste du anropa funktionen Uppdatera på den överordnade noden (Objekt) för den uppdaterade noden (TotalCount). Om du ändrar regel 1 på följande sätt och testar regeln en gång till anges fältet Status till "Behöver godkännande":

Regel 1 (uppdaterad)

IF 1 == 1
THEN ProcessPO.Order:/Order/Items/TotalCount = (ProcessPO.Order:/Order/Items/TotalCount + ProcessPO:/Order/Items/Item/Count) AND
Update(ProcessPO.Order:/Order/Items)

Relaterat innehåll