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

Articolo
06/13/2024

Si applica: App per la logica di Azure (Standard)

Importante

Questa funzionalità è in anteprima ed è soggetta alle Condizioni supplementari per l'utilizzo per le anteprime di Microsoft Azure.

Questa guida descrive come ottimizzare l'esecuzione delle regole aggiungendo funzioni di controllo alle azioni nelle regole usando Microsoft Rules Composer. Le funzioni di controllo consentono all'applicazione o al set di regole di controllare i fatti nella memoria di lavoro del motore regole. Queste funzioni includono le funzioni Assert, Clear, Halt, Retract, RetractByType, Reassert e Update per l'oggetto .NET e le entità TypedXmlDocument che è possibile usare 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 altre informazioni, vedere Creare creatori di fatti e retriever.

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 usando le fasi di azione di risoluzione dei conflitti di corrispondenza.

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.

Entità	Numero di istanze asserte	Tipo di istanza
Oggetto .NET	1 (oggetto stesso)	Classe .NET completa
TypedXmlDocument	1-N TypedXmlDocument(s): in base alle associazioni del selettore create e al contenuto del documento	DocumentType.Selector

Asserire un oggetto .NET

Il motore regole supporta in modo nativo i tipi scalari e gli oggetti scalari .NET di base per i tipi di riferimento. L'elaborazione degli oggetti .NET asserta è la più semplice dei tipi di elaborazione.

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

In Microsoft Rules Composer caricare il file XML contenente l'archivio regole su cui si vuole lavorare.
Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Assert come azione.
Nella finestra Esplora fatti selezionare Classi .NET.
Dalla scheda Classi .NET trascinare il metodo del costruttore per l'oggetto che si desidera impostare sull'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 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.

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Assert come azione.
Nella finestra Esplora fatti selezionare XML Schema.
Dalla scheda XML Schema trascinare il nodo che si desidera visualizzare nell'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 set di nodi, il che significa che il primo elemento del set viene usato come valore.

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 regole raggruppa tutti i campi all'interno di un selettore come oggetto .

I selettori sono anche espressioni XPath. In Esplora fatti, quando si seleziona un nodo nella scheda XML Schema, Microsoft Rules Composer compila automaticamente la proprietà Selettore XPath per tutti i nodi e la proprietà Campo XPath per qualsiasi nodo che non contiene 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 asserzionati o ritirati dalla memoria di lavoro del motore 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 usa il selettore /root/order o l'ordine, 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 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 Clear

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

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

Nella finestra Esplora regole trovare e selezionare la regola in cui si desidera cancellare la memoria di lavoro e l'agenda per il motore regole.
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 dal motore regole, usare la funzione Halt in Microsoft Rules Composer.

Arrestare l'esecuzione del set di regole

Nella finestra Esplora regole individuare e selezionare la regola in cui si vuole arrestare l'esecuzione del set di regole.
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 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.

Nota

Il metodo Ruleset.Execute memorizza nella cache le istanze del motore regole per ottenere prestazioni migliori. Se si usa direttamente il metodo RuleEngine.Execute , le istanze del motore regole non vengono memorizzate nella cache.

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 ritiro

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

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.
Nella finestra Esplora fatti selezionare Classi .NET.
Dalla scheda Classi .NET trascinare la classe desiderata, non l'assembly o il metodo, nell'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 un'entità TypedXmlDocument o entità

È possibile ritirare l'entità TypedXmlDocument originale asserta nel motore regole oppure ritirare una delle entità figlio 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 ritirare l'entità TypedXmlDocument associata a un oggetto order oppure ritirare 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, la nuova entità TypedXmlDocument con asserzione indipendente non viene ritirata 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

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.
Nella finestra Esplora fatti selezionare XML Schema.
Dalla scheda XML Schema trascinare il nodo di primo livello per lo schema nell'argomento per la funzione Ritiro.

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 all'oggetto TypedXmlDocument iniziale. Quando si ritira il TypedXmlDocument padre, tutte le entità figlio TypedXmlDocument associate a TypedXmlDocument vengono rimosse dalla memoria di lavoro, incluse tutte le entità TypedXmlDocument create chiamando la funzione Assert, in base ai selettori usati nel set di regole.

Ritirare un'entità TypedXmlDocument figlio

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Ritiro come azione.
Nella finestra Esplora fatti selezionare XML Schema.
Dalla scheda XML Schema trascinare il nodo figlio nell'argomento per la funzione Ritiro.

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

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita RetractByType come azione.
Nella finestra Esplora fatti selezionare Classi .NET.
Dalla scheda Classi .NET trascinare la classe nell'argomento per la funzione RetractByType.

Ritirare tutte le entità TypedXmlDocument con un tipo specifico

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

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita RetractByType come azione.
Nella finestra Esplora fatti selezionare XML Schema.
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 Reassert

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:

Ritirare l'oggetto .NET dalla memoria di lavoro.
Rimuovere tutte le azioni nell'agenda per le regole che usano l'oggetto in un predicato o in un'azione.
Asserire l'oggetto .NET nella memoria di lavoro e valutare come oggetto appena assertto.
Rivalutare le regole che usano l'oggetto in un predicato e aggiungere tali azioni all'agenda in base alle esigenze.
Le azioni sono state lette nell'ordine del giorno per tutte le regole che in precedenza hanno valutato su true e usano solo l'oggetto nelle azioni.

Rivalutare un oggetto .NET

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Riassert come azione.
Nella finestra Esplora fatti selezionare Classi .NET.
Dalla scheda Classi .NET trascinare la classe nell'argomento per la funzione Reassert.

Rivalutare un'entità TypedXmlDocument

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni, aggiungere la funzione predefinita Riassert come azione.
Nella finestra Esplora fatti selezionare XML Schema.
Dalla scheda XML Schema 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 è sporco rimane in memoria funzionante.

Nota

Un nodo non è contrassegnato come dirty dalle operazioni esterne che il motore non conosce, ad esempio un'applicazione esterna aggiunge, elimina o aggiorna tale nodo a livello di codice.

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 in cui il valore è impostato su 1, Child1.ExampleField ad esempio = 1'.

Si supponga che un'azione regola esegua le operazioni seguenti 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

Si supponga ora di rivalutare l'entità Parent , che comporta i comportamenti di entità figlio seguenti:

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 della rivalutazione di Parent .

Funzione Update

Per rivalutare un oggetto nel motore regole per la rivalutazione, in base ai nuovi dati e allo stato, usare la funzione Update in 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.

Importante

Il numero massimo di cicli predefinito per la rivalutazione delle regole è 2^32, quindi per determinate regole l'esecuzione del set di regole potrebbe durare molto tempo. Per ridurre il numero di cicli, modificare la proprietà Maximum Execution Loop Depth nella versione del set di regole.

Aggiornare un oggetto .NET

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Aggiorna come azione.
Nella finestra Esplora fatti selezionare Classi .NET.
Dalla scheda Classi .NET trascinare 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 usano il fatto aggiornato e aggiunge azioni all'agenda, se queste condizioni restituiscono true.

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 non riuscire la prima valutazione, ma restituisce true durante la seconda valutazione.

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

La possibilità di rivalutare gli oggetti nella memoria di lavoro offre un controllo esplicito sul comportamento negli scenari di concatenamento in avanti. 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 Progettazione regole, è necessario assicurarsi di evitare di creare scenari di ciclo 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

Nella finestra Esplora set di regole trovare e selezionare la regola desiderata.
Nel riquadro THEN, in Azioni aggiungere la funzione predefinita Aggiorna come azione.
Nella finestra Esplora fatti selezionare XML Schema.
Dalla scheda XML Schemas trascinare il nodo dell'entità che si desidera visualizzare nell'argomento nella 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 rivaluta le condizioni ogni volta che viene aggiornato TotalCount , è necessario chiamare la funzione Update nel 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)

Condividi tramite

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

Prerequisiti

Funzione Assert

Asserire un oggetto .NET

Asserzione di un'entità TypedXmlDocument

Funzione Clear

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

Funzione Halt

Arrestare l'esecuzione del set di regole

Funzione Di ritiro

Ritirare un oggetto .NET

Ritirare un'entità TypedXmlDocument o entità

Ritirare l'entità TypedXmlDocument di primo livello

Ritirare un'entità TypedXmlDocument figlio

Funzione RetractByType

Ritirare tutti gli oggetti .NET con un tipo specifico

Ritirare tutte le entità TypedXmlDocument con un tipo specifico

Funzione Reassert

Rivalutare un oggetto .NET

Rivalutare un'entità TypedXmlDocument

Funzione Update

Aggiornare un oggetto .NET

Evitare i cicli infiniti

Aggiornare un'entità TypedXmlDocument

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

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

Prerequisiti

Funzione Assert

Asserire un oggetto .NET

Asserzione di un'entità TypedXmlDocument

Funzione Clear

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

Funzione Halt

Arrestare l'esecuzione del set di regole

Funzione Di ritiro

Ritirare un oggetto .NET

Ritirare un'entità TypedXmlDocument o entità

Ritirare l'entità TypedXmlDocument di primo livello

Ritirare un'entità TypedXmlDocument figlio

Funzione RetractByType

Ritirare tutti gli oggetti .NET con un tipo specifico

Ritirare tutte le entità TypedXmlDocument con un tipo specifico

Funzione Reassert

Rivalutare un oggetto .NET

Rivalutare un'entità TypedXmlDocument

Funzione Update

Aggiornare un oggetto .NET

Evitare i cicli infiniti

Aggiornare un'entità TypedXmlDocument

Contenuto correlato

Commenti e suggerimenti

Risorse aggiuntive