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

Artigo
06/17/2024

Aplica-se a: Aplicativos Lógicos do Azure (Standard)

Importante

Esse recurso está em versão prévia e está sujeito aos Termos de uso suplementares para versões prévias 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 o Assert, Clear, Halt, Retract, RetractByType, Reasserte Atualizar funções 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 executadas.

Pré-requisitos

Faça o download e instale o Microsoft Rules Composer.
O arquivo XML que contém o conjunto de regras com o qual você deseja trabalhar.

Para adicionar fatos, especifique seus valores nos documentos XML que você aponta da janela do Gerenciador do RuleSet. Ou você pode usar um criador de fatos para fornecer ao mecanismo de regras uma matriz que contenha objetos .NET como fatos. Para obter mais informações, confira 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 no tipo da instância usando as fases de ação de resolução de conflito de correspondência.

A tabela a seguir resume o comportamento da função Assert para as entidades e tipos de instância com suporte, 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.

Entity	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.Selector

Afirmar um objeto .NET

O mecanismo de regras dá suporte nativo a tipos escalares e objetos .NET básicos 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 com o qual você deseja trabalhar.
Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna Assert como uma ação.
Na janela Gerenciador de Fatos, selecione a guia Classes do .NET.
Na guia Classes do .NET, arraste o método de construtor para o objeto que você deseja para o argumento na ação Afirmar.

O Microsoft Rules Composer converte o método construtor em uma chamada CreateObject na definição de regra.

Observação

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, somente as instâncias A com um valor de 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 houver várias instâncias de B existirem, as instâncias de A serão atualizadas sempre que a condição for avaliada como true para uma instância de 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 Actions, adicione a função interna Assert como uma ação.
Na janela do Gerenciador de Fatos, selecione esquemas XML.
Na guia esquemas XML, arraste o nó que você deseja para o argumento na ação Assert.

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

Quando uma entidade TypedXmlDocument é declarada como um fato, o mecanismo de regras cria TypedXmlDocument instâncias filho, 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 identificando itens específicos dentro do seletor. O mecanismo de regras agrupa todos os campos dentro de um seletor como um objeto.

Seletores também são expressões XPath. Na do Gerenciador de Fatos, quando você seleciona um nó na guia esquemas XML, o Microsoft Rules Composer preenche automaticamente a propriedade seletor XPath para todos os nós e a propriedade campo XPath para qualquer nó que não contenha nós filho. Como alternativa, você pode inserir suas próprias expressões XPath para seletor XPath e campo XPath, se necessário. Se o seletor corresponder a várias partes no documento XML, vários objetos desse tipo serão declarados ou retraídos da memória de trabalho do mecanismo de regras.

Você pode usar vários seletores no mesmo documento. Dessa forma, você pode exibir diferentes partes do documento, por exemplo, suponha que uma seção seja a ordem e outra seção contenha o endereço de envio. 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/orderou //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>

Em cada seletor, XPaths referem-se aos campos individuais. Portanto, se você usar o seletor /root/order/item, //order/itemou //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, @quantitye @cost. Você pode consultar os campos pai porque o objeto é uma referência ao documento original, por exemplo, .. /@customer.

Nos bastidores, o mecanismo de regras pode converter um valor de campo de texto em qualquer um dos tipos com suporte 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 gerará uma exceção. Você pode recuperar o bool e tipos de duplos apenas como seu respectivo tipo, cadeias de caracteres ou objetos.

Função Clear

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

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

Na janela Explorador do RuleSet, localize e selecione a regra em que deseja limpar a memória de trabalho e a agenda do mecanismo de regras.
No painel THEN, em Actions, adicione a função interna Clear como uma ação.

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

Função Halt

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

Interromper a execução do conjunto de regras

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna Clear como uma ação.

A função Halt usa um único argumento booliano. Se você especificar o valor como verdadeiro, 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 um código semelhante ao seguinte código:

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 retira os fatos e retorna o controle ao chamador. Nesse caso, a execução do conjunto de regras interrompida 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 do conjunto de regras interrompido com a próxima regra pendente disparando chamando RuleEngine.Execute novamente, desde que não tenha retraído os objetos necessários entre as duas chamadas.

Observação

O método Ruleset.Execute armazena em cache as instâncias do mecanismo de regras para obter 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 do conjunto de regras interrompido:

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

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 Actions, adicione a função interna Halt como uma ação.
Na janela Gerenciador de Fatos, selecione a guia Classes do .NET.
Na guia Classes do .NET, arraste a classe desejada, não o assembly ou o método, para o argumento do parâmetro Retrair.

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

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

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

Observação

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

Retrair uma entidade ou entidade TypedXmlDocument

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

Suponha que você tenha o seguinte exemplo de 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 retrair a entidade typedXmlDocument associada a um objeto de ordem ou retrair uma ou ambas as entidades TypedXmlDocument associadas ao objeto orderline. Todas as entidades TypedXmlDocument são associadas à entidade TypedXmlDocument de nível superior que foi originalmente declarada, não com a entidade TypedXmlDocument que aparece acima desse de nível superior TypedXmlDocument nó na hierarquia da árvore XML.

Por exemplo, product é uma entidade TypedXmlDocument abaixo do objeto orderline e está associada à entidade TypedXmlDocument para order, não a 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 produto.

O mecanismo só funciona 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ó selecionado por meio de um seletor no conjunto de regras, esses nós não serão avaliados em regras, a menos que TypedXmlDocument entidades sejam criadas e declaradas para elas. Se você afirmar essas novas instâncias TypedXmlDocument, o mecanismo avaliará as instâncias nas regras, mas a entidade de nível superior TypedXmlDocument não terá conhecimento sobre elas. Quando o TypedXmlDocument de nível superior é retraído, o novo, o typedXmlDocument entidades independentemente declarados não são retraídos automaticamente. Como resultado, se novos nós forem criados, execute um Retrair e Reafirmar no XmlDocument completo, que é a etapa típica e mais simples a ser tomada.

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 ao 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 Actions, adicione a função interna Halt como uma ação.
Na janela do Gerenciador de Fatos, selecione esquemas XML.
Na guia esquemas XML , arraste o nó de nível superior para o esquema para o argumento da função Retrair.

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 de / que se refere ao TypedXmlDocument inicial. Quando você retrai o pai TypedXmlDocument, todas as entidades TypedXmlDocument filho associadas ao TypedXmlDocument são removidas da memória de trabalho, incluindo todas as entidades TypedXmlDocument criadas chamando a função Afirmar, com base nos seletores usados no conjunto de regras.

Retrair uma entidade TypedXmlDocument filho

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna Halt como uma ação.
Na janela do Gerenciador de Fatos, selecione esquemas XML.
Na guia esquemas XML, arraste o nó filho para o argumento da função Retrair.

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. Essa função difere da função Retrair, 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 Gerenciador de Fatos, selecione a guia Classes do .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.Selector.

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 do Gerenciador de Fatos, selecione esquemas XML.
Na guia esquemas XML, arraste o nó apropriado para a função RetractByType.

Consistente com a função Retrair, 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 TypedXmlDocument, filho, ou nós XmlNode na hierarquia de árvore, associados às entidades TypedXmlDocument pai.

Função reafirmar

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 à emissão de 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:

Retire 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.
Afirme o objeto .NET de volta à memória de trabalho e avalie como um objeto recém-declarado.
Reavaliar todas as regras que usam o objeto em um predicado e adicionar as ações dessas regras à agenda conforme apropriado.
Leia as ações na agenda de todas as regras avaliadas anteriormente para verdadeiro e use apenas o objeto em suas ações.

Afirmar um objeto .NET

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna Reassert como uma ação.
Na janela Gerenciador de Fatos, selecione a guia Classes do .NET.
Na guia classes .NET, arraste a classe para o argumento da função Reafirmar.

Reafirmar uma entidade TypedXmlDocument

Na janela RuleSet Explorer, localize e selecione a regra desejada.
No painel THEN, em Actions, adicione a função interna Reassert como uma ação.
Na janela do Gerenciador de Fatos, selecione esquemas XML.
Na guia Esquemas XML, arraste o nó de entidade que você deseja para o argumento na função Reassert.

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

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

Observação

Um nó não está 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 de entidade filho 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 em que o valor é definido como 1, por exemplo, Child1.ExampleField = 1'.

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

O valor ExampleField para Child2 é atualizado de 1 para 0.
O código do usuário exclui Child3.
O código do usuário adiciona um novo TypedXmlDocument entidade filho chamada NewChild para 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ê reatribua a entidade Pai, o que resulta nos seguintes comportamentos de entidade filho:

Child2 é reafirmada porque agora está suja depois que seu campo foi atualizado.
Child3 é retraída da memória de trabalho.
NewChild é declarado na memória de trabalho.
Child1 permanece inalterado na memória de trabalho porque não foi atualizado antes de pai foi reafirmada.

Função Update

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

Importante

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

Atualizar um objeto .NET

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

Normalmente, você usa Assert para colocar um novo objeto na memória de trabalho do mecanismo de regras e usar Atualizar para atualizar um objeto já existente na memória de trabalho. Quando você declara 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.

Regra 1 avalia a propriedade Id em ItemA, define a propriedade Id no ItemB, e em seguida reafirma ItemB após a alteração. Quando itemB for reafirmado, o mecanismo tratará itemB como um novo objeto e o mecanismo reavaliará todas as regras que usam itemB nos predicados ou ações. Esse comportamento garante que o mecanismo reavalia 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)
```
Regra 2 pode falhar na primeira avaliação, mas avalia verdadeiro 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 fornece 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 Regra 1 também é reavaliada. Com ItemA.Id inalterado, regra 1 novamente é avaliada como verdadeiroe a ação Assert(ItemB) é disparada novamente. Como resultado, a regra cria uma situação de loop sem fim.

Impedir loops infinitos

Você deve ser capaz de reafirmar objetos sem criar loops sem fim. Para evitar esses cenários, você pode usar a função Atualizar. Assim como a função Reafirmar, a função Atualizar executa as funções Retrair e Afirmar 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, somente nos predicados ou 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 Atualizar, você pode verificar se o mecanismo reavalia apenas regra 2 porque a condição para Regra 2 usa ItemB. O mecanismo não reavalia regra 1 porque ItemB é usado apenas nas ações para 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 Atualizar dessa 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 Atualização é chamado no ItemA. Se o valor de ItemA.Id não for alterado em outro lugar, regra 1 continuará a ser avaliada como true, o que faz com que a chamada Atualização novamente no itemA.

Como o 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 ItemA.Value que impede que a regra avalie como verdadeiro novamente após as ações da regra 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 THEN, em Actions, adicione a função interna Atualizar como uma ação.
Na janela do Gerenciador de Fatos, selecione esquemas XML.
Na guia Esquemas XML, arraste o nó de entidade que você deseja para o argumento na função Atualizar.

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

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 pedido de compra como entrada para este conjunto de regras, observe que o status não está definido como "Precisa de aprovação", mesmo que o TotalCount seja 14. Esse comportamento ocorre porque regra 2 é avaliado somente no início, quando o valor de TotalCount é 0. A regra não é avaliada sempre que 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 regra 1 da seguinte maneira e testar a regra mais uma vez, o campo status será definido como "Precisa de aprovação":

Regra 1 (atualizada)

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)

Compartilhar via

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

Pré-requisitos

Função Assert

Afirmar um objeto .NET

Afirmar uma entidade TypedXmlDocument

Função Clear

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

Função Halt

Interromper a execução do conjunto de regras

Função Retract

Retrair um objeto .NET

Retrair uma entidade ou entidade TypedXmlDocument

Retrair a entidade TypedXmlDocument de nível superior

Retrair uma entidade TypedXmlDocument filho

Função RetractByType

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

Retrair todas as entidades TypedXmlDocument com um tipo específico

Função reafirmar

Afirmar um objeto .NET

Reafirmar uma entidade TypedXmlDocument

Função Update

Atualizar um objeto .NET

Impedir loops infinitos

Atualizar uma entidade TypedXmlDocument

Comentários

Recursos adicionais

Compartilhar via

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

Pré-requisitos

Função Assert

Afirmar um objeto .NET

Afirmar uma entidade TypedXmlDocument

Função Clear

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

Função Halt

Interromper a execução do conjunto de regras

Função Retract

Retrair um objeto .NET

Retrair uma entidade ou entidade TypedXmlDocument

Retrair a entidade TypedXmlDocument de nível superior

Retrair uma entidade TypedXmlDocument filho

Função RetractByType

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

Retrair todas as entidades TypedXmlDocument com um tipo específico

Função reafirmar

Afirmar um objeto .NET

Reafirmar uma entidade TypedXmlDocument

Função Update

Atualizar um objeto .NET

Impedir loops infinitos

Atualizar uma entidade TypedXmlDocument

Conteúdo relacionado

Comentários

Recursos adicionais