Aggiungere funzioni di controllo nelle azioni per ottimizzare l'esecuzione delle regole usando Microsoft Rules Composer

Si applica: Azure Logic Apps (Standard)

Questa guida illustra come ottimizzare l'esecuzione delle regole aggiungendo funzioni di controllo alle azioni nelle regole usando Microsoft Rules Composer. Le funzioni di controllo aiutano l'applicazione o il ruleset a controllare i fatti nella memoria di lavoro del motore di regole. Queste funzioni includono le funzioni Assert, Clear, Halt, Retract, RetractByType, Reassert e Update per l'oggetto .NET e le entità TypedXmlDocument utilizzabili come fatti. L'esistenza di fatti nella memoria funzionante determina le condizioni valutate dal motore e le azioni eseguite.

Prerequisiti

• Scaricare e installare Microsoft Rules Composer.

• File XML contenente il set di regole su cui si desidera lavorare.

  Per aggiungere fatti, specificare i relativi valori nei documenti XML a cui si punta dalla finestra Esplora RuleSet. In alternativa, è possibile usare un creatore di fatti per fornire al motore regole una matrice che contiene oggetti .NET come fatti. Per ulteriori informazioni, vedere Creare generatori e recuperatori di dati.

Funzione Assert

Per aggiungere istanze di oggetti alla memoria di lavoro del motore regole, usare la funzione Assert in Microsoft Rules Composer. Il motore elabora ogni istanza dell'oggetto in base alle condizioni e alle azioni scritte sul tipo dell'istanza, utilizzando le fasi di corrispondenza, risoluzione dei conflitti e azione.

La tabella seguente riepiloga il comportamento della funzione Assert per le entità e i tipi di istanza asserzione supportati, incluso il numero di istanze risultanti create nel motore per ogni entità asserta e il tipo applicato a ogni istanza per l'identificazione.

Asserire un oggetto .NET

Il motore delle regole supporta nativamente i tipi scalari .NET di base e gli oggetti per i tipi di riferimento. L'elaborazione degli oggetti .NET asserita è la più semplice tra i tipi di elaborazione.

In Microsoft Rules Composer è possibile asserire un oggetto .NET dall'interno di una regola.

1. In Microsoft Rules Composer caricare il file XML contenente l'archivio regole su cui si vuole lavorare.

2. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

3. Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Assert come azione.

4. Nella finestra Facts Explorer, selezionare Classi .NET.

5. Dalla scheda Classi .NET trascinare il metodo del costruttore dell'oggetto desiderato verso l'argomento nell'azione Assert.

   Microsoft Rules Composer converte il metodo del costruttore in una chiamata CreateObject nella definizione della regola.

   Nota

   Anche se il motore regole ha una funzione CreateObject , la funzione non viene visualizzata come funzione separata in Microsoft Rules Composer.

Ogni oggetto viene asserito in memoria di lavoro come istanza di oggetto separata, ovvero ogni predicato che fa riferimento al tipo dell'oggetto, ad esempio IF Object.Property = 1, analizza l'istanza. L'istanza è disponibile anche per le azioni della regola che fanno riferimento al tipo, in base ai risultati delle condizioni della regola.

Si supponga, ad esempio, di avere le regole seguenti:

Regola 1

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

Regola 2

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

Nella regola 1 solo le istanze A con valore 1 hanno la proprietà Status aggiornata. Nella regola 2, tuttavia, se la condizione restituisce true, tutte le istanze A hanno lo stato aggiornato. Infatti, se esistono più istanze B , le istanze A vengono aggiornate ogni volta che la condizione restituisce true per un'istanza B .

Asserzione di un'entità TypedXmlDocument

In Microsoft Rules Composer è possibile asserire un'entità TypedXmlDocument dall'interno di una regola.

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Assert come azione.

3. Nella finestra Esploratore dei fatti, selezionare Schemi XML.

4. Dalla scheda Schemi XML, trascinare il nodo desiderato nell'argomento dell'azione Assert.

I documenti XML sono fondamentalmente testo, ma i valori dei campi potrebbero essere qualsiasi tipo, che si basa sul tipo specificato al momento della compilazione della regola. I campi sono espressioni XPath, quindi possono restituire un insieme di nodi, il che significa che viene utilizzato come valore il primo elemento dell'insieme.

Quando un'entità TypedXmlDocument viene asserta come fatto, il motore regole crea istanze figlio TypedXmlDocument, in base ai selettori definiti nella regola. È possibile considerare i selettori come un modo per isolare i nodi in un documento XML e campi come identificazione di elementi specifici all'interno del selettore. Il motore di regole raggruppa tutti i campi all'interno di un selettore come un oggetto.

I selettori sono anche espressioni XPath. Nell'Esplora Fatti, quando si seleziona un nodo nella scheda Schemi XML, il Microsoft Rules Composer compila automaticamente la proprietà Selettore XPath per tutti i nodi e la proprietà Campo XPath per qualsiasi nodo privo di nodi figlio. In alternativa, è possibile immettere le proprie espressioni XPath per XPath Selector e XPath Field , se necessario. Se il selettore corrisponde a più parti del documento XML, più oggetti di questo tipo vengono inseriti o rimossi dalla memoria di lavoro del motore delle regole.

È possibile usare più selettori all'interno dello stesso documento. In questo modo, è possibile visualizzare parti diverse del documento, ad esempio, si supponga che una sezione sia l'ordine e un'altra sezione contenga l'indirizzo di spedizione. Tenere tuttavia presente che gli oggetti creati sono definiti dalla stringa XPath che li ha creati. Se si usa un'espressione XPath diversa, il risultato è un'entità TypedXmlDocument univoca, anche se l'espressione viene risolta nello stesso nodo.

Si supponga, ad esempio, di avere il codice XML seguente:

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

Se si usano i selettori /root/order o //order, gli oggetti seguenti vengono aggiunti alla memoria di lavoro del motore:

Oggetto 1

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

Oggetto 2

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

All'interno di ogni selettore, I percorsi XPath fanno riferimento ai singoli campi. Pertanto, se si usa il selettore /root/order/item, order/item o item, gli oggetti seguenti vengono aggiunti alla memoria di lavoro del motore con due elementi per Joe e i due elementi per Jane:

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

Ogni oggetto può accedere a tre campi: @name, @quantity e @cost. È possibile fare riferimento ai campi padre perché l'oggetto è un riferimento al documento originale, ad esempio . /@customer.

Dietro le quinte, il motore delle regole può convertire un valore di campo di testo in uno dei tipi supportati tramite la funzione XmlConvert. È possibile specificare questa opzione impostando il tipo in Microsoft Rules Composer. Se non è possibile eseguire una conversione, il motore genera un'eccezione. È possibile recuperare i tipi bool e double solo come tipo rispettivo, ovvero stringhe o oggetti.

Funzione Cancella

Per reimpostare la memoria di lavoro e l'agenda di un'istanza del motore di regole, utilizzare la funzione Clear in Microsoft Rules Composer. Per altre informazioni sulla memoria di lavoro e sull'agenda, vedere Ottimizzazione del motore di regole.

Reimpostare la memoria di lavoro e l'agenda per il motore di regole

1. Nella finestra Esplora set di regole, trovare e selezionare la regola in cui si desidera cancellare la memoria di lavoro e l'agenda per il motore di regole.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Cancella come azione.

   La funzione Clear non accetta argomenti.

Funzione Halt

Per arrestare l'esecuzione corrente del motore delle regole, usare Halt in Microsoft Rules Composer.

Arrestare l'esecuzione del set di regole

1. Nella finestra RuleSet Explorer, individuare e selezionare la regola in cui si vuole arrestare l'esecuzione del set di regole.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Interrompi come azione.

La funzione Halt accetta un singolo argomento booleano . Se si specifica il valore come true, il motore delle regole cancella l'agenda contenente le regole candidate in sospeso.

Il metodo Ruleset.Execute è un wrapper intorno al metodo RuleEngine.Execute e usa codice simile al codice seguente:

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

Se si usa il metodo Ruleset.Execute per eseguire un set di regole, il motore regole restituisce il controllo al metodo Ruleset.Execute quando viene eseguita la funzione Halt . Il metodo Ruleset.Execute ritira i fatti e restituisce il controllo al chiamante. In questo caso, l'esecuzione del set di regole interrotta non può riprendere.

Tuttavia, se si usa direttamente il metodo RuleEngine.Execute per eseguire il set di regole, è possibile riprendere l'esecuzione del set di regole interrotta con la successiva regola in sospeso attiva chiamando di nuovo RuleEngine.Execute , purché non siano stati ritirati gli oggetti necessari tra le due chiamate.

Il codice di esempio seguente illustra come riprendere l'esecuzione del set di regole interrotta:

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

Funzione di retrazione

Per rimuovere oggetti da un set di regole e dalla memoria di lavoro del motore regole, usare la funzione Ritiro in Microsoft Rules Composer.

Ritirare un oggetto .NET

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.

3. Nella finestra Esplora fatti, selezionare Classi .NET.

4. Dalla scheda .NET Classi, trascina la classe desiderata, non l'assembly o il metodo, nello spazio dell'argomento per il parametro Retract.

   Se si trascina un metodo nella funzione Retract , il motore tenta di ritirare l'oggetto restituito dal metodo .

Il ritiro di un oggetto .NET ha l'impatto seguente:

• Le azioni sull'agenda che utilizzano gli oggetti vengono rimosse dall'agenda.

  Nota

  Altre azioni più in alto nell'agenda potrebbero essere già state eseguite prima di usare la funzione Ritiro .

• Le regole che usano l'oggetto in un predicato hanno le azioni rimosse dall'agenda, se sono presenti azioni nell'agenda.

• Il motore non valuta più l'oggetto.

Ritirare una o più entità TypedXmlDocument

È possibile ritirare l'entità TypedXmlDocument originale che è stata asserita nel motore di regole, oppure ritirare una delle entità figlia TypedXmlDocument create dall'entità XmlDocument padre.

Si supponga di avere il codice XML di esempio seguente:

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

È possibile revocare l'entità TypedXmlDocument associata a un oggetto ordine oppure revocare una o entrambe le entità TypedXmlDocument associate all'oggetto orderline. Tutte le entità TypedXmlDocument sono associate all'entità TypedXmlDocument di primo livello originariamente asserta, non con l'entità TypedXmlDocument visualizzata sopra il nodo TypedXmlDocument di primo livello nella gerarchia dell'albero XML.

Ad esempio, product è un'entità TypedXmlDocument sotto l'oggetto orderline ed è associata all'entità TypedXmlDocument per l'ordine, non all'entità TypedXmlDocument per orderline. Nella maggior parte dei casi, questa distinzione non è importante. Tuttavia, se si ritira l'oggetto ordine , vengono ritirati anche gli oggetti orderline e product . Se si ritira l'oggetto orderline , solo l'oggetto viene ritirato, non l'oggetto prodotto .

Il motore funziona solo con e tiene traccia delle istanze dell'oggetto, ovvero istanze TypedXmlDocument , create dal motore al momento dell'asserzione iniziale dell'entità TypedXmlDocument . Se si creano nodi aggiuntivi, ad esempio nodi di pari livello per un nodo selezionato tramite un selettore nel set di regole, questi nodi non vengono valutati nelle regole a meno che le entità TypedXmlDocument non vengano create e dichiarate. Se si asserisce queste nuove istanze TypedXmlDocument di livello inferiore, il motore valuta le istanze nelle regole, ma l'entità TypedXmlDocument di primo livello non ne ha conoscenza. Quando il TypedXmlDocument di primo livello viene ritirato, le nuove entità TypedXmlDocument asserite indipendentemente non vengono ritirate automaticamente. Di conseguenza, se vengono creati nuovi nodi, eseguire un'istruzione Retract e Reassert sull'intero XmlDocument, che è il passaggio più semplice e tipico da eseguire.

La classe TypedXmlDocument fornisce metodi utili che è possibile chiamare all'interno di un membro .NET personalizzato come parte di un'azione. Questi metodi includono la funzionalità per ottenere xmlNode associato a TypedXmlDocument o al TypedXmlDocument padre.

Ritirare l'entità TypedXmlDocument di primo livello

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.

3. Nella finestra Facts Explorer, seleziona XML Schemas.

4. Dalla scheda Schemi XML, trascinare il nodo al livello superiore dello schema nell'argomento per la funzione Ritrarre.

   Questo nodo superiore termina nell'estensione xsd e rappresenta il nodo radice del documento, non il nodo dell'elemento documento. Il nodo ha un / selettore che fa riferimento al TypedXmlDocument iniziale. Quando si ritira il documento TypedXmlDocument padre, tutte le entità figlio TypedXmlDocument associate a TypedXmlDocument vengono rimosse dalla memoria di lavoro, incluse tutte le entità TypedXmlDocument create mediante chiamata alla funzione Assert, in base ai selettori usati nel set di regole.

Ritirare un'entità TypedXmlDocument figlio

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.

3. Nella finestra Esplora Fatti, seleziona XML Schemi.

4. Dalla scheda schemi XML, trascina il nodo figlio nell'argomento della funzione Ritrarre.

Funzione RetractByType

Per rimuovere tutti gli oggetti con il tipo specificato dalla memoria di lavoro del motore regole, utilizzare la funzione RetractByType in Microsoft Rules Composer. Questa funzione è diversa dalla funzione Retract , che rimuove solo elementi specifici con un determinato tipo.

Ritirare tutti gli oggetti .NET con un tipo specifico

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita RetractByType come azione.

3. Nella finestra Esplora Fatti, selezionare Classi .NET.

4. Dalla scheda .NET Classi, trascina la classe nell'argomento della funzione RetractByType.

Ritirare tutte le entità TypedXmlDocument con un tipo specifico

L'oggetto RetractByType rimuove tutte le entità TypedXmlDocument con lo stesso DocumentType.Selector.

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita RetractByType come azione.

3. Nella finestra Facts Explorer, selezionare Schemi XML.

4. Dalla scheda XML Schema trascinare il nodo appropriato nella funzione RetractByType.

Coerente con la funzione Retract, se si utilizza la funzione RetractByType nel nodo radice del documento, questa azione non solo ritira tutte le entità TypedXmlDocument asserte con tale DocumentType, ma anche tutti i nodi TypedXmlDocument figlio o XmlNode nella gerarchia dell'albero, associati a tali entità TypedXmlDocument padre.

Funzione di riaffermazione

Per chiamare la funzione Assert su un oggetto già esistente nella memoria di lavoro del motore, usare la funzione Reassert in Microsoft Rules Composer. Il comportamento equivale all'emissione di un comando Di ritiro per l'oggetto, seguito da un comando Assert .

Ad esempio, se si usa la funzione Reassert in un oggetto .NET, il motore regole esegue i passaggi seguenti:

1. Ritirare l'oggetto .NET dalla memoria di lavoro.

2. Rimuovere qualsiasi azione dall'agenda per le regole che usano l'oggetto come predicato o azione.

3. Asserire l'oggetto .NET nella memoria di lavoro e valutarlo come oggetto appena asserto.

4. Rivalutare le regole che usano l'oggetto in un predicato e aggiungere tali azioni all'agenda in base alle esigenze.

5. Riaggiungere le azioni all'agenda per tutte le regole che in precedenza sono state valutate come true e usano solo l'oggetto nelle loro azioni.

Rivalutare un oggetto .NET

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Riassert come azione.

3. Nella finestra Esplora Fatti, seleziona Classi .NET.

4. Dalla scheda Classi .NET trascinare la classe nell'argomento per la funzione Reassert.

Riaffermare un oggetto TypedXmlDocument

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Riassert come azione.

3. Nella finestra Facts Explorer selezionare XML Schemi.

4. Dalla scheda Schemi XML trascinare il nodo dell'entità che si desidera visualizzare nella funzione Riassert.

Se si riassesta un'entità TypedXmlDocument di primo livello, le entità figlio TypedXmlDocument create al momento della prima asserzione dell'entità TypedXmlDocument di primo livello possono comportarsi in modo diverso, a seconda dello stato di ogni entità figlio TypedXmlDocument.

Ad esempio, se un'entità figlio nuova o esistente è "dirty", ovvero almeno un campo è stato modificato nel set di regole usando un'azione, viene eseguita una funzione Assert o Reassert su tale elemento figlio. Qualsiasi elemento figlio esistente che non è dirty rimane in memoria funzionante.

L'esempio seguente illustra uno scenario semplificato che descrive i comportamenti dell'entità figlio quando viene rivalutata l'entità padre. Si supponga di avere le entità TypedXmlDocument seguenti nella memoria di lavoro: Parent, Child1, Child2 e Child3.

• Parent è l'entità TypedXmlDocument di primo livello.
• Ogni figlio contiene un campo denominato ExampleField dove il valore è impostato a 1, ad esempio, Child1.ExampleField = 1.

Si supponga che un'azione di una regola esegua le seguenti operazioni sulle entità figlio:

• Il valore ExampleField per Child2 viene aggiornato da 1 a 0.
• Il codice utente elimina Child3.
• Il codice utente aggiunge una nuova entità figlio TypedXmlDocument denominata NewChild a Parent.

Nell'esempio seguente viene illustrata la nuova rappresentazione degli oggetti nella memoria di lavoro:

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

Supponiamo di riaffermare l'entità Parent, che comporta i seguenti comportamenti delle entità figlie:

• Child2 viene rivalutato perché è ora dirty dopo l'aggiornamento del relativo campo.
• Child3 viene ritirato dalla memoria di lavoro.
• NewChild viene asserito nella memoria di lavoro.
• Child1 rimane invariato nella memoria di lavoro perché non è stato aggiornato prima che Parent fosse riasserito.

Funzione Update

Per reinserire un oggetto nel motore regole per una nuova valutazione, basata sui nuovi dati e sullo stato, usare la funzione Update nel Microsoft Rules Composer. L'oggetto può avere un tipo di classe .NET o un tipo TypedXmlDocument . È anche possibile usare la funzione Update per migliorare le prestazioni del motore e impedire scenari di cicli infiniti.

Aggiornare un oggetto .NET

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Aggiorna come azione.

3. Nella finestra Facts Explorer, selezionare Classi .NET.

4. Dalla scheda .NET Classi, trascina la classe nell'argomento per la funzione Update.

In genere, si usa Assert per inserire un nuovo oggetto nella memoria di lavoro del motore regole e usare Update per aggiornare un oggetto già esistente in memoria di lavoro. Quando si asserisce un nuovo oggetto come fatto, il motore rivaluta le condizioni in tutte le regole. Tuttavia, quando si aggiorna un oggetto esistente, il motore rivaluta solo le condizioni che utilizzano il dato aggiornato e aggiunge azioni all'agenda, se queste condizioni sono vere.

Si supponga, ad esempio, di avere le regole seguenti e che gli oggetti denominati ItemA e ItemB esistano già in memoria di lavoro.

• La regola 1 valuta la proprietà Id in ItemA, imposta la proprietà Id su ItemB e quindi rivaluta ItemB dopo la modifica. Quando ItemB viene rivalutato, il motore considera ItemB come nuovo oggetto e il motore rivaluta tutte le regole che usano ItemB nei predicati o nelle azioni. Questo comportamento assicura che il motore rivaluta la regola 2 rispetto al nuovo valore in ItemB.Id impostato nella regola 1.

  Regola 1

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

• La regola 2 potrebbe fallire al primo tentativo di valutazione, ma risulta true durante la seconda valutazione.

  Regola 2

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

La possibilità di reinserire gli oggetti nella memoria di lavoro offre un controllo diretto sul comportamento negli scenari di concatenazione diretta. Tuttavia, questo esempio rivela un effetto collaterale dalla rivalutazione in cui viene rivalutata anche la regola 1 . Con ItemA.Id invariato, la regola 1 restituisce true e l'azione Assert(ItemB) viene nuovamente attivata. Di conseguenza, la regola crea una situazione di ciclo infinito.

Evitare i cicli infiniti

È necessario essere in grado di rivalutare gli oggetti senza creare cicli infiniti. Per evitare questi scenari, è possibile usare la funzione Update . Analogamente alla funzione Reassert , la funzione Update esegue le funzioni Retract e Assert nelle istanze dell'oggetto associate modificate dalle azioni regola, ma con le differenze principali seguenti:

• Nell'ordine del giorno le azioni per le regole rimangono all'ordine del giorno quando il tipo di istanza viene usato solo nelle azioni, non nei predicati.

• Le regole che usano solo il tipo di istanza nelle azioni non vengono rivalutate.

Di conseguenza, le regole che usano i tipi di istanza, solo nei predicati o in entrambi i predicati e le azioni, vengono rivalutate e le azioni delle regole vengono aggiunte all'agenda in base alle esigenze.

Modificando l'esempio precedente per usare la funzione Update , è possibile assicurarsi che il motore rivaluta solo la regola 2 perché la condizione per la regola 2 usa ItemB. Il motore non rivaluta la regola 1 perché ItemB viene usato solo nelle azioni per la regola 1*, eliminando lo scenario di ciclo.

Regola 1

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

Regola 2

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

Nonostante l'uso della funzione Update in questo modo, la possibilità esiste ancora per la creazione di scenari di ciclo. Si consideri ad esempio la regola seguente:

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

Il predicato usa ItemA, quindi il motore rivaluta la regola quando viene chiamato Update in ItemA. Se il valore per ItemA.Id non viene modificato altrove, la regola 1 continua a valutare come true, causando la chiamata di nuovo a Update in ItemA.

In qualità di progettista di regole, è necessario assicurarsi di evitare di creare scenari di loop di questo tipo. L'approccio appropriato per risolvere il problema è diverso in base alla natura delle regole.

Nell'esempio seguente viene illustrato un modo semplice per risolvere il problema nell'esempio precedente aggiungendo un controllo su ItemA.Value che impedisce alla regola di valutare nuovamente come true dopo la prima esecuzione delle azioni della regola.

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

Aggiornare un'entità TypedXmlDocument

1. Nella finestra Esplora Set Regole, trova e seleziona la regola desiderata.

2. Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Aggiorna come azione.

3. Nella finestra Esploratore dei fatti, selezionare Schemi XML.

4. Dalla scheda XML Schemas, trascina il nodo dell'entità desiderata nell'argomento della funzione Update.

Si supponga, ad esempio, di avere le regole seguenti:

• La regola 1 valuta il conteggio totale degli articoli in un messaggio di ordine di acquisto.

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

• La regola 2 imposta lo stato su "Richiede approvazione" se il conteggio totale è maggiore o uguale a 10.

  Regola 2

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

Se passi il seguente messaggio di ordine di acquisto come input a questo set di regole, noterai che lo stato non è impostato su "Richiede approvazione", anche se TotalCount è 14. Questo comportamento si verifica perché la regola 2 viene valutata solo all'inizio quando il valore TotalCount è 0. La regola non viene valutata ogni volta che viene aggiornato TotalCount .

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

Affinché il motore rivaluti le condizioni ogni volta che TotalCount viene aggiornato, è necessario eseguire la funzione Update sul nodo padre (Items) per il nodo aggiornato (TotalCount). Se si modifica la regola 1 come indicato di seguito e si testa la regola una volta di più, il campo Stato è impostato su "Richiede approvazione":

Regola 1 (aggiornata)

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)

Contenuto correlato

• Creare regole con Microsoft Rules Composer
• Aggiungere operatori aritmetici e logici alle regole
• Testare i set di regole
• Creare un progetto Motore delle Regole per le Logic Apps di Azure