Adicionar funções de controle em ações para otimizar a execução de regras usando o Microsoft Rules Composer (Visualização)

Artigo
06/13/2024

Aplica-se a: Aplicativos Lógicos do Azure (Padrão)

Importante

Esta funcionalidade está em pré-visualização e está sujeita aos Termos de Utilização Suplementares para Pré-visualizações do Microsoft Azure.

Este guia descreve como otimizar a execução de regras adicionando funções de controle a ações em suas regras usando o Microsoft Rules Composer. As funções de controle ajudam seu aplicativo ou conjunto de regras a controlar os fatos na memória de trabalho do mecanismo de regras. Essas funções incluem as funções Assert, Clear, Halt, Retract, RetractByType, Reassert e Update para o objeto .NET e entidades TypedXmlDocument que você pode usar como fatos. A existência de fatos na memória de trabalho impulsiona as condições que o mecanismo avalia e as ações que executam.

Pré-requisitos

Transfira e instale o Microsoft Rules Composer.
O arquivo XML que contém o conjunto de regras no qual você deseja trabalhar.

Para adicionar fatos, especifique seus valores nos documentos XML para os quais você aponta na janela RuleSet Explorer. Ou, você pode usar um criador de fatos para fornecer seu mecanismo de regras com uma matriz que contém objetos .NET como fatos. Para obter mais informações, consulte Criar criadores e recuperadores de fatos.

Função Assert

Para adicionar instâncias de objeto à memória de trabalho do mecanismo de regras, use a função Assert no Microsoft Rules Composer. O mecanismo processa cada instância de objeto de acordo com as condições e ações que são gravadas em relação ao tipo da instância usando as fases match-conflict resolution-action.

A tabela a seguir resume o comportamento da função Assert para as entidades declaradas e tipos de instância suportados, incluindo o número de instâncias resultantes criadas no mecanismo para cada entidade declarada e o tipo aplicado a cada instância para identificação.

Entidade	Número de instâncias declaradas	Tipo de instância
Objeto .NET	1 (o próprio objeto)	Classe .NET totalmente qualificada
TypedXmlDocument	1-N TypedXmlDocument(s): Com base nas associações de seletor criadas e no conteúdo do documento	DocumentType.Seletor

Afirmar um objeto .NET

O mecanismo de regras suporta nativamente tipos escalares básicos do .NET e objetos para tipos de referência. O processamento de objeto .NET declarado é o mais simples dos tipos de processamento.

No Microsoft Rules Composer, você pode afirmar um objeto .NET de dentro de uma regra.

No Microsoft Rules Composer, carregue o arquivo XML que contém o repositório de regras no qual você deseja trabalhar.
Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Assert como uma ação.
Na janela Facts Explorer, selecione Classes .NET.
Na guia Classes .NET, arraste o método do construtor para o objeto que você deseja para o argumento na ação Assert.

O Microsoft Rules Composer traduz o método do construtor em uma chamada CreateObject na definição da regra.

Nota

Embora o mecanismo de regras tenha uma função CreateObject , a função não aparece como uma função separada no Microsoft Rules Composer.

Cada objeto é declarado na memória de trabalho como uma instância de objeto separada, o que significa que cada predicado que faz referência ao tipo do objeto, como IF Object.Property = 1, analisa a instância. A instância também está disponível para ações de regra que fazem referência ao tipo, com base nos resultados das condições da regra.

Por exemplo, suponha que você tenha as seguintes regras:

Regra 1

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

Regra 2

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

Na Regra 1, apenas as instâncias A com valor 1 têm sua propriedade Status atualizada. Na Regra 2, no entanto, se a condição for avaliada como true, todas as instâncias A terão seu status atualizado. Na verdade, se existirem várias instâncias B , as instâncias A serão atualizadas sempre que a condição for avaliada como true para uma instância B .

Afirmar uma entidade TypedXmlDocument

No Microsoft Rules Composer, você pode afirmar uma entidade TypedXmlDocument de dentro de uma regra.

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Assert como uma ação.
Na janela Facts Explorer, selecione XML Schemas.
Na guia Esquemas XML, arraste o nó desejado para o argumento na ação Afirmar.

Os documentos XML são basicamente texto, mas os valores de campo podem ser de qualquer tipo, que se baseia no tipo especificado quando a regra foi criada. Os campos são expressões XPath, portanto, eles podem retornar um conjunto de nós, o que significa que o primeiro item do conjunto é usado como o valor.

Quando uma entidade TypedXmlDocument é declarada como um fato, o mecanismo de regras cria instâncias filhas TypedXmlDocument , com base nos seletores definidos na regra. Você pode pensar em seletores como uma maneira de isolar os nós em um documento XML e campos como identificação de itens específicos dentro do seletor. O mecanismo de regras agrupa todos os campos dentro de um seletor como um objeto.

Os seletores também são expressões XPath. No Facts Explorer, quando você seleciona um nó na guia Esquemas XML, o Microsoft Rules Composer preenche automaticamente a propriedade XPath Seletor para todos os nós e a propriedade XPath Field para qualquer nó que não contenha nós filho. Como alternativa, você pode inserir suas próprias expressões XPath para XPath Seletor e XPath Field , se necessário. Se o seletor corresponder a várias partes no documento XML, vários objetos desse tipo serão declarados ou retirados da memória de trabalho do mecanismo de regras.

Você pode usar vários seletores dentro do mesmo documento. Dessa forma, você pode visualizar diferentes partes do documento, por exemplo, suponha que uma seção é o pedido e outra seção contém o endereço de entrega. No entanto, tenha em mente que os objetos criados são definidos pela cadeia de caracteres XPath que os criou. Se você usar uma expressão XPath diferente, o resultado será uma entidade TypedXmlDocument exclusiva, mesmo que a expressão seja resolvida para o mesmo nó.

Por exemplo, suponha que você tenha o seguinte 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>

Se você usar o seletor /root/order ou order, os seguintes objetos serão adicionados à memória de trabalho do mecanismo:

Objeto 1

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

Objeto 2

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

Dentro de cada seletor, XPaths referem-se aos campos individuais. Assim, se você usar o seletor /root/order/item, order/item ou item, os seguintes objetos serão adicionados à memória de trabalho do mecanismo com dois itens para Joe e os dois itens para Jane:

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

Cada objeto pode acessar três campos: @name, @quantity e @cost. Você pode fazer referência aos campos pai porque o objeto é uma referência no documento original, por exemplo, .. /@customer.

Nos bastidores, o mecanismo de regras pode converter um valor de campo de texto em qualquer um dos tipos suportados por meio da função XmlConvert . Você pode especificar essa opção definindo o tipo no Microsoft Rules Composer. Se uma conversão não for possível, o mecanismo lançará uma exceção. Você pode recuperar os tipos bool e double apenas como seus respetivos tipos, sejam strings ou objetos.

Limpar função

Para redefinir a memória de trabalho e a agenda de uma instância do mecanismo de regras, use a função Limpar no Microsoft Rules Composer. Para obter mais informações sobre memória de trabalho e agenda, consulte Otimização do mecanismo de regras.

Redefinir a memória de trabalho e a agenda para seu mecanismo de regras

Na janela RuleSet Explorer, localize e selecione a regra onde deseja limpar a memória de trabalho e a agenda do mecanismo de regras.
No painel THEN, em Ações, adicione a função interna Limpar como uma ação.

A função Clear não aceita argumentos.

Função de paragem

Para interromper a execução atual pelo mecanismo de regras, use a função Halt no Microsoft Rules Composer.

Parar a execução do conjunto de regras

Na janela RuleSet Explorer, localize e selecione a regra onde você deseja interromper a execução do conjunto de regras.
No painel THEN, em Actions, adicione a função interna Halt como uma ação.

A função Halt usa um único argumento booleano . Se você especificar o valor como true, o mecanismo de regras limpará a agenda que contém as regras candidatas pendentes.

O método Ruleset.Execute é um wrapper em torno do método RuleEngine.Execute e usa código semelhante ao código a seguir:

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

Se você usar o método Ruleset.Execute para executar um conjunto de regras, o mecanismo de regras retornará o controle para o método Ruleset.Execute quando a função Halt for executada. O método Ruleset.Execute retrai os fatos e retorna o controle para o chamador. Nesse caso, a execução interrompida do conjunto de regras não pode ser retomada.

No entanto, se você usar diretamente o método RuleEngine.Execute para executar o conjunto de regras, poderá retomar a execução interrompida do conjunto de regras com a próxima regra pendente sendo acionada chamando RuleEngine.Execute novamente, desde que você não tenha retraído nenhum objeto necessário entre as duas chamadas.

Nota

O método Ruleset.Execute armazena em cache as instâncias do mecanismo de regras para um melhor desempenho. Se você usar diretamente o método RuleEngine.Execute , as instâncias do mecanismo de regras não serão armazenadas em cache.

O código de exemplo a seguir mostra como retomar a execução interrompida do conjunto de regras:

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

Função de retração

Para remover objetos de um conjunto de regras e da memória de trabalho do mecanismo de regras, use a função Retract no Microsoft Rules Composer.

Retrair um objeto .NET

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Retract como uma ação.
Na janela Facts Explorer, selecione Classes .NET.
Na guia Classes do .NET, arraste a classe desejada, não o assembly ou método, para o argumento do parâmetro Retract.

Se você arrastar um método para a função Retract , o mecanismo tentará retrair o objeto retornado pelo método.

A retração de um objeto .NET tem o seguinte impacto:

As ações na agenda que usam os objetos são removidas da agenda.

Nota

Outras ações mais acima na agenda podem já ter sido executadas antes de você usar a função Retrair .
As regras que usam o objeto em um predicado têm suas ações removidas da agenda, se houver alguma ação na agenda.
O mecanismo não avalia mais o objeto.

Retrair uma entidade ou entidades TypedXmlDocument

Você pode retirar a entidade TypedXmlDocument original que foi declarada no mecanismo de regras ou pode retirar uma das entidades filhas TypedXmlDocument criadas a partir da entidade XmlDocument pai.

Suponha que você tenha o seguinte exemplo XML:

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

Você pode retirar a entidade TypedXmlDocument associada a um objeto order ou pode retirar uma ou ambas as entidades TypedXmlDocument associadas ao objeto orderline . Todas as entidades TypedXmlDocument estão associadas à entidade TypedXmlDocument de nível superior que foi originalmente declarada, não à entidade TypedXmlDocument que aparece acima desse nó TypedXmlDocument de nível superior na hierarquia da árvore XML.

Por exemplo, product é uma entidade TypedXmlDocument abaixo do objeto orderline e está associado à entidade TypedXmlDocument para order, não à entidade TypedXmlDocument para orderline. Na maioria dos casos, essa distinção não é importante. No entanto, se você retirar o objeto order , os objetos orderline e product também serão retraídos. Se você retirar o objeto orderline, somente esse objeto será retraído, não o objeto product.

O mecanismo só funciona com e rastreia as instâncias de objeto, que são instâncias TypedXmlDocument , que o mecanismo criou quando a entidade TypedXmlDocument foi inicialmente declarada. Se você criar nós adicionais, como nós irmãos para um nó que foi selecionado por meio de um seletor no conjunto de regras, esses nós não serão avaliados em regras, a menos que as entidades TypedXmlDocument sejam criadas e declaradas para eles. Se você afirmar essas novas instâncias TypedXmlDocument de nível inferior, o mecanismo avaliará as instâncias nas regras, mas a entidade TypedXmlDocument de nível superior não terá conhecimento sobre elas. Quando o TypedXmlDocument de nível superior é retraído, as novas entidades TypedXmlDocument declaradas de forma independente não são retraídas automaticamente. Como resultado, se novos nós forem criados, execute um Retract and Reassert no XmlDocument completo, que é a etapa típica e mais direta a ser executada.

A classe TypedXmlDocument fornece métodos úteis que você pode chamar dentro de um membro .NET personalizado como parte de uma ação. Esses métodos incluem a capacidade de obter o XmlNode associado com o TypedXmlDocument ou o pai TypedXmlDocument.

Retrair a entidade TypedXmlDocument de nível superior

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Retract como uma ação.
Na janela Facts Explorer e selecione XML Schemas.
Na guia Esquemas XML, arraste o nó de nível superior do esquema para o argumento da função Retract.

Esse nó superior termina na extensão .xsd e representa o nó raiz do documento, não o nó do elemento do documento. O nó tem um / seletor que se refere ao TypedXmlDocument inicial. Quando você retrai o pai TypedXmlDocument, todas as entidades filhas TypedXmlDocument associadas ao TypedXmlDocument são removidas da memória de trabalho, incluindo todas as entidades TypedXmlDocument criadas chamando a função Assert , com base nos seletores usados no conjunto de regras.

Retrair uma entidade filho TypedXmlDocument

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Retract como uma ação.
Na janela Facts Explorer e selecione XML Schemas.
Na guia Esquemas XML, arraste o nó filho para o argumento da função Retract.

Função RetractByType

Para remover todos os objetos com o tipo especificado da memória de trabalho do mecanismo de regras, use a função RetractByType no Microsoft Rules Composer. Esta função difere da função Retract , que remove apenas itens específicos com um determinado tipo.

Retrair todos os objetos .NET com um tipo específico

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna RetractByType como uma ação.
Na janela Facts Explorer, selecione Classes .NET.
Na guia Classes .NET, arraste a classe para o argumento da função RetractByType.

Retrair todas as entidades TypedXmlDocument com um tipo específico

O RetractByType remove todas as entidades TypedXmlDocument com o mesmo DocumentType.Seletor.

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna RetractByType como uma ação.
Na janela Facts Explorer, selecione XML Schemas.
Na guia Esquemas XML, arraste o nó apropriado para a função RetractByType.

Consistente com a função Retract, se você usar a função RetractByType no nó raiz do documento, essa ação não apenas retrairá todas as entidades TypedXmlDocument declaradas com esse DocumentType, mas também todas as entidades filho TypedXmlDocument ou nós XmlNode na hierarquia de árvore, associados a essas entidades TypedXmlDocument pai.

Reafirmar função

Para chamar a função Assert em um objeto que já existe na memória de trabalho do mecanismo, use a função Reassert no Microsoft Rules Composer. O comportamento é equivalente a emitir um comando Retract para o objeto, seguido por um comando Assert .

Por exemplo, se você usar a função Reassert em um objeto .NET, o mecanismo de regras executará as seguintes etapas:

Retraia o objeto .NET da memória de trabalho.
Remova todas as ações na agenda para regras que usam o objeto em um predicado ou ação.
Declare o objeto .NET de volta à memória de trabalho e avalie como um objeto recém-declarado.
Reavalie todas as regras que usam o objeto em um predicado e adicione as ações dessas regras à agenda, conforme apropriado.
Readicione as ações à agenda para quaisquer regras que foram previamente avaliadas como verdadeiras e use apenas o objeto em suas ações.

Reafirmar um objeto .NET

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Reassert como uma ação.
Na janela Facts Explorer, selecione Classes .NET.
Na guia Classes .NET, arraste a classe para o argumento da função Reassert.

Reafirmar uma entidade TypedXmlDocument

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Ações, adicione a função interna Reassert como uma ação.
Na janela Facts Explorer, selecione XML Schemas.
Na guia Esquemas XML, arraste o nó de entidade desejado para o argumento na função Reafirmar.

Se você reafirmar uma entidade TypedXmlDocument de nível superior, as entidades filhas TypedXmlDocument, que foram criadas quando a entidade TypedXmlDocument de nível superior foi declarada pela primeira vez, podem se comportar de forma diferente, dependendo do estado de cada entidade filha TypedXmlDocument.

Por exemplo, se uma entidade filha nova ou existente estiver "suja", o que significa que pelo menos um campo foi alterado no conjunto de regras usando uma ação, então uma função Assert ou Reassert será executada nesse filho. Qualquer criança existente que não esteja suja permanece na memória de trabalho.

Nota

Um nó não é marcado como sujo de operações externas que o mecanismo não conhece, por exemplo, um aplicativo externo adiciona, exclui ou atualiza programaticamente esse nó.

O exemplo a seguir mostra um cenário simplificado que descreve os comportamentos da entidade filha quando sua entidade pai é reafirmada. Suponha que você tenha as seguintes entidades TypedXmlDocument na memória de trabalho: Parent, Child1, Child2 e Child3.

Pai é a entidade TypedXmlDocument de nível superior.
Cada filho contém um campo chamado ExampleField onde o valor é definido como 1, por exemplo, Child1.ExampleField = 1'.

Suponha que uma ação de regra execute as seguintes operações nas entidades filhas:

O valor ExampleField para Child2 é atualizado de 1 para 0.
O código de usuário exclui Child3.
O código de usuário adiciona uma nova entidade filha TypedXmlDocument chamada NewChild a Parent.

O exemplo a seguir mostra a nova representação de objetos na memória de trabalho:

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

Agora, suponha que você reafirme a entidade pai, o que resulta nos seguintes comportamentos de entidade filha:

Child2 é reafirmado porque agora está sujo depois que seu campo foi atualizado.
Child3 é retraído da memória de trabalho.
NewChild é afirmado na memória de trabalho.
Child1 permanece inalterado na memória de trabalho porque não foi atualizado antes de Parent ser reafirmado.

Função Update

Para reafirmar um objeto no mecanismo de regras para reavaliação, com base nos novos dados e estado, use a função Update no Microsoft Rules Composer. O objeto pode ter o tipo de classe .NET ou o tipo TypedXmlDocument . Você também pode usar a função Update para melhorar o desempenho do mecanismo e evitar cenários de loop infinito.

Importante

A contagem máxima de loop padrão para reavaliação de regras é 2^32, portanto, para certas regras, a execução do conjunto de regras pode durar muito tempo. Para reduzir a contagem de loops, altere a propriedade Maximum Execution Loop Depth na versão do conjunto de regras.

Atualizar um objeto .NET

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel DEPOIS, em Ações, adicione a função interna Atualizar como uma ação.
Na janela Facts Explorer, selecione Classes .NET.
Na guia Classes .NET, arraste a classe para o argumento da função Update.

Normalmente, você usa Assert para colocar um novo objeto na memória de trabalho do mecanismo de regras e usa Update para atualizar um objeto já existente na memória de trabalho. Quando você afirma um novo objeto como um fato, o mecanismo reavalia as condições em todas as regras. No entanto, quando você atualiza um objeto existente, o mecanismo reavalia apenas as condições que usam o fato atualizado e adiciona ações à agenda, se essas condições forem avaliadas como verdadeiras.

Por exemplo, suponha que você tenha as seguintes regras e que os objetos chamados ItemA e ItemB já existam na memória de trabalho.

A Regra 1 avalia a propriedade Id em ItemA, define a propriedade Id em ItemB e, em seguida, reafirma ItemB após a alteração. Quando ItemB é reafirmado, o mecanismo trata ItemB como um novo objeto, e o mecanismo reavalia todas as regras que usam ItemB nos predicados ou ações. Esse comportamento garante que o mecanismo reavalie a Regra 2 em relação ao novo valor em ItemB.Id conforme definido na Regra 1.

Regra 1
```
IF ItemA.Id == 1
THEN ItemB.Id = 2
Assert(ItemB)
```
A regra 2 pode falhar na primeira avaliação, mas é avaliada como verdadeira durante a segunda avaliação.

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

A capacidade de reafirmar objetos na memória de trabalho oferece controle explícito sobre o comportamento em cenários de encadeamento de encaminhamento. No entanto, este exemplo revela um efeito colateral da reafirmação em que a Regra 1 também é reavaliada. Com ItemA.Id inalterado, a Regra 1 novamente é avaliada como true e a ação Assert(ItemB) é acionada novamente. Como resultado, a regra cria uma situação de loop infinito.

Evite loops intermináveis

Você deve ser capaz de reafirmar objetos sem criar loops infinitos. Para evitar esses cenários, você pode usar a função Atualizar . Como a função Reassert , a função Update executa as funções Retract e Assert nas instâncias de objeto associadas que são alteradas por ações de regra, mas com as seguintes diferenças principais:

Na agenda, as ações para regras permanecem na agenda quando o tipo de instância é usado apenas nas ações, não nos predicados.
As regras que usam apenas o tipo de instância em ações não são reavaliadas.

Como resultado, as regras que usam os tipos de instância, seja apenas nos predicados ou em ambos os predicados e ações, são reavaliadas e as ações das regras são adicionadas à agenda conforme apropriado.

Ao alterar o exemplo anterior para usar a função Update , você pode certificar-se de que o mecanismo reavalia apenas a Regra 2 porque a condição para a Regra 2 usa ItemB. O mecanismo não reavalia a Regra 1 porque o ItemB é usado apenas nas ações da Regra 1*, eliminando o cenário de looping.

Regra 1

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

Regra 2

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

Apesar de usar a função Update desta forma, ainda existe a possibilidade de criar cenários de looping. Por exemplo, considere a seguinte regra:

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

O predicado usa ItemA, de modo que o mecanismo reavalia a regra quando Update é chamado em ItemA. Se o valor de ItemA.Id não for alterado em outro lugar, a Regra 1 continuará a ser avaliada como verdadeira, o que fará com que chame Update novamente no ItemA.

Como designer de regras, você deve evitar a criação desses cenários de looping. A abordagem apropriada para corrigir esse problema difere com base na natureza das regras.

O exemplo a seguir mostra uma maneira simples de resolver o problema no exemplo anterior adicionando uma verificação em ItemA.Value que impede que a regra seja avaliada como verdadeira novamente após as ações da regra serem executadas pela primeira vez.

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

Atualizar uma entidade TypedXmlDocument

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel DEPOIS, em Ações, adicione a função interna Atualizar como uma ação.
Na janela Facts Explorer, selecione XML Schemas.
Na guia Esquemas XML, arraste o nó de entidade desejado para o argumento na função Atualizar.

Por exemplo, suponha que você tenha as seguintes regras:

A regra 1 avalia a contagem total dos itens em uma mensagem de ordem de compra.

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

A regra 2 define o status como "Precisa de aprovação" se a contagem total for maior ou igual a 10.

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

Se você passar a seguinte mensagem de ordem de compra como entrada para este conjunto de regras, notará que o status não está definido como "Precisa de aprovação", mesmo que o TotalCount seja 14. Esse comportamento acontece porque a regra 2 é avaliada somente no início quando o valor TotalCount é 0. A regra não é avaliada sempre que o TotalCount é atualizado.

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

Para que o mecanismo reavalie as condições sempre que TotalCount for atualizado, você precisa chamar a função Update no nó pai (Items) para o nó atualizado (TotalCount). Se você alterar a Regra 1 da seguinte forma e testar a regra mais uma vez, o campo Status será definido como "Precisa de aprovação":

Artigo 1.º (atualizado)

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)

Partilhar via

Adicionar funções de controle em ações para otimizar a execução de regras usando o Microsoft Rules Composer (Visualização)

Pré-requisitos

Função Assert

Afirmar um objeto .NET

Afirmar uma entidade TypedXmlDocument

Limpar função

Redefinir a memória de trabalho e a agenda para seu mecanismo de regras

Função de paragem

Parar a execução do conjunto de regras

Função de retração

Retrair um objeto .NET

Retrair uma entidade ou entidades TypedXmlDocument

Retrair a entidade TypedXmlDocument de nível superior

Retrair uma entidade filho TypedXmlDocument

Função RetractByType

Retrair todos os objetos .NET com um tipo específico

Retrair todas as entidades TypedXmlDocument com um tipo específico

Reafirmar função

Reafirmar um objeto .NET

Reafirmar uma entidade TypedXmlDocument

Função Update

Atualizar um objeto .NET

Evite loops intermináveis

Atualizar uma entidade TypedXmlDocument

Comentários

Recursos adicionais

Partilhar via

Adicionar funções de controle em ações para otimizar a execução de regras usando o Microsoft Rules Composer (Visualização)

Pré-requisitos

Função Assert

Afirmar um objeto .NET

Afirmar uma entidade TypedXmlDocument

Limpar função

Redefinir a memória de trabalho e a agenda para seu mecanismo de regras

Função de paragem

Parar a execução do conjunto de regras

Função de retração

Retrair um objeto .NET

Retrair uma entidade ou entidades TypedXmlDocument

Retrair a entidade TypedXmlDocument de nível superior

Retrair uma entidade filho TypedXmlDocument

Função RetractByType

Retrair todos os objetos .NET com um tipo específico

Retrair todas as entidades TypedXmlDocument com um tipo específico

Reafirmar função

Reafirmar um objeto .NET

Reafirmar uma entidade TypedXmlDocument

Função Update

Atualizar um objeto .NET

Evite loops intermináveis

Atualizar uma entidade TypedXmlDocument

Conteúdos relacionados

Comentários

Recursos adicionais