Compartilhar via

Executar tarefas avançadas em conjuntos de regras com o Microsoft Rules Composer (Versão prévia)

  • Artigo

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 operações mais avançadas que podem ser executadas em conjuntos de regras no Microsoft Rules Composer.

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.

Copiar uma versão do conjunto de regras

Você pode criar uma cópia de uma versão do conjunto de regras existente, mas com um número de versão diferente.

  1. Abra o Microsoft Rules Composer. Na janela Explorador do Conjunto de Regras, abra o menu de atalho da versão do conjunto de regras e selecione Copiar.

  2. Abra o menu de atalho do conjunto de regras e selecione Colar Versão do Conjunto de Regras.

    O Microsoft Rules Composer cria uma nova versão do conjunto de regras com os mesmos elementos da versão copiada, mas com um número diferente.

    Observação

    Se você atualizar o assembly .NET usado para fornecer fatos ao seu conjunto de regras, certifique-se de atualizar as referências da versão do conjunto de regras para esse assembly. Para obter mais informações, consulte Atualizar referências do assembly do .NET.

Criar uma versão vazia do conjunto de regras

Depois de adicionar regras a uma versão do conjunto de regras, você pode criar uma nova versão vazia do conjunto de regras com um número diferente e salvar essa versão para trabalhar mais tarde.

  1. Abra o Microsoft Rules Composer. No menu de atalho do conjunto de regras, selecione Adicionar Nova Versão.

    O Microsoft Rules Composer cria uma versão vazia do conjunto de regras com um número diferente.

  2. Abra o menu de atalho da nova versão do conjunto de regras e selecione Salvar.

Agora você pode copiar regras de outras versões de conjuntos de regras e colá-las na nova versão.

Passar tipos de fatos para um conjunto de regras

Embora não seja possível especificar diretamente um tipo de retorno para um conjunto de regras, é possível passar um dos seguintes tipos de fatos para o conjunto de regras, fazer com que o conjunto de regras altere o valor do fato para true ou false e, em seguida, verificar o valor da propriedade ou elemento/coluna após a execução do conjunto de regras:

  • Um objeto .NET que tenha uma propriedade do tipo Boolean
  • Um documento XML que tenha um elemento com o tipo Boolean

Configurar um recuperador de fatos para um conjunto de regras

Ao usar um recuperador de fatos com seu conjunto de regras, você pode armazenar fatos que não são alterados com frequência antes do primeiro ciclo de execução do aplicativo host. Dessa forma, é possível recuperar esses fatos do armazenamento, apresentá-los uma vez ao mecanismo de regras para armazenamento em cache e reutilizá-los em vários ciclos de execução. Para obter mais informações, consulte Criar criadores e recuperadores de fatos.

Há duas maneiras de associar um recuperador de fatos a um conjunto de regras:

  • Selecione manualmente um recuperador de fatos para uma versão do conjunto de regras no Microsoft Rules Composer.

  • Programaticamente, usando o objeto RuleSetExecutionConfiguration.

Observação

É possível associar apenas uma implementação do recuperador de fatos a uma versão do conjunto de regras.

Selecionar manualmente um recuperador de fatos para um conjunto de regras

  1. Abra o Microsoft Rules Composer. No Explorador do Conjunto de Regras, selecione a versão do conjunto de regras que deseja associar ao recuperador de fatos.

  2. Na janela Propriedades, selecione a linha de propriedade FactRetriever e, em seguida, selecione o botão reticências (...) para localizar e selecionar um objeto recuperador de fatos existente.

    Observação

    O botão reticências (...) não aparecerá até que você selecione a linha FactRetriever na janela Propriedades.

Chamar um conjunto de regras filho a partir de um conjunto de regras pai

Para essa tarefa, use um dos métodos a seguir:

  • Chamar o método Ruleset.Execute diretamente do conjunto de regras pai.

  • No conjunto de regras pai, chame um método de um componente .NET auxiliar que encapsula o método Ruleset.Execute.

    Com o segundo método, você pode adicionar código de pré-processamento e pós-processamento ao método Ruleset.Execute. Por exemplo, é possível criar quaisquer fatos necessários do conjunto de regras filho dentro desse método wrapper. As seções a seguir fornecem um exemplo para cada método.

Chamar o método Ruleset.Execute diretamente do conjunto de regras pai

Esta seção fornece etapas de alto nível para chamar o conjunto de regras filho diretamente do Conjunto de Regras pai utilizando o método Ruleset.Execute. O procedimento a seguir mostra as etapas para adicionar o método Ruleset.Execute como uma ação ao conjunto de regras pai que passa um documento XML como um fato para o conjunto de regras filho.

Observação

Neste cenário de exemplo, um documento XML é enviado como um fato para o conjunto de regras pai. Esse documento é transmitido como um fato para o conjunto de regras filho. No entanto, é possível chamar um método .NET que crie os fatos para o conjunto de regras filho.

  1. Abra o Microsoft Rules Composer. Na janela Gerenciador de Fatos, selecione a guia Classes do .NET.

  2. Abra o menu de atalho de Assemblies do .NET e selecione Procurar.

  3. Na lista Assemblies do .NET, selecione Microsoft.RuleEngine e, em seguida, OK.

  4. Expanda o Conjunto de Regras e arraste Execute(Object facts) ou Execute(Object facts, IRuleSetTrackingInterceptor trackingInterceptor) para o painel THEN.

  5. Selecione o nó Esquemas XML, abra o menu de atalho para Esquemas e selecione Procurar.

  6. Selecione o esquema do documento XML que deseja transmitir como fato e, em seguida, selecione Abrir.

  7. Para passar o documento XML que foi passado ao conjunto de regras pai como fato para o conjunto de regras filho, arraste <schema-name>.xsd para o primeiro argumento do método Ruleset.Execute.

  8. Se você usar o método Executar que não usa IRuleSetTrackingInterceptor como segundo argumento, ignore as etapas a seguir.

  9. Selecione a guia Classes do .NET e arraste DebugTrackingInterceptor em Microsoft.RuleEngine para o segundo argumento do método Ruleset.Execute.

    Observação

    Se você executar essa ação, o cliente deverá passar uma instância da classe DebugTrackingInterceptor como um fato para o conjunto de regras pai, que, por sua vez, passará a instância como um fato para o conjunto de regras filho. Em vez disso, você pode arrastar o construtor da classe DebugTrackingInterceptor para que a instância seja criada automaticamente para você.

Modificar o aplicativo cliente que chama o conjunto de regras pai

O cliente que invoca o conjunto de regras pai cria uma instância da classe Conjunto de Regras com o nome do conjunto de regras filho como parâmetro e passa essa instância como um fato para o conjunto de regras pai, juntamente com outros fatos. O código de exemplo a seguir ilustra essa ação:

DebugTrackingInterceptor dti = new DebugTrackingInterceptor("RulesetTracking.txt");
Ruleset Ruleset = new Ruleset("ParentRuleset");
object[] facts = new object[3];
facts[0] = txd;
facts[1] = new Ruleset("ChildRuleset");
facts[2] = new DebugTrackingInterceptor("RulesetTracking2.txt");
Ruleset.Execute(facts, dti);
Ruleset.Dispose();

Se o cliente for uma orquestração BizTalk, você pode precisar colocar o código em uma forma de Expressão para criar fatos e, em seguida, passar os fatos como parâmetros para a forma Chamar Regras.

Chamar um método wrapper do .NET a partir do conjunto de regras pai

Esta seção apresenta as etapas de alto nível para invocar um método .NET que envolve a chamada ao método Ruleset.Execute do conjunto de regras pai.

Criar a classe .NET utilitária

  1. Criar um projeto de biblioteca de classes .NET. Adicione uma classe ao projeto.

  2. Adicione um método estático que chame o método Ruleset.Execute para invocar o conjunto de regras cujo nome é passado como parâmetro, por exemplo, como mostra o código de exemplo a seguir:

    public static void Execute(string RulesetName, TypedXmlDocument txd)
{
    DebugTrackingInterceptor dti = new   DebugTrackingInterceptor("RulesetTracking.txt");
    Ruleset Ruleset = new Ruleset("ParentRuleset");
    object[] facts = new object[3];
    facts[0] = txd;
    facts[1] = new Ruleset("ChildRuleset");
    facts[2] = new DebugTrackingInterceptor("RulesetTracking2.txt");
    Ruleset.Execute(facts, dti);
    Ruleset.Dispose();
}

    O cliente invoca o conjunto de regras pai, e o conjunto de regras pai chama o método auxiliar que invoca o conjunto de regras filho, por exemplo, como mostra o código de exemplo a seguir para o cliente:

    facts[0] = txd;
facts[1] = new RulesetExecutor(txd);

// Call the first or parent ruleset.
Ruleset Ruleset = new Ruleset(RulesetName);
DebugTrackingInterceptor dti = new DebugTrackingInterceptor("RulesetTracking.txt");
Ruleset.Execute(facts, dti);
Ruleset.Dispose();

    Observação

    Se o método for um método de instância, o cliente deverá criar uma instância da classe .NET auxiliar e passar essa instância como um fato para o conjunto de regras pai.

Analisar vários objetos com o mesmo tipo em uma regra

Em muitos cenários, você escreve uma regra de negócios em relação a um tipo e espera que o mecanismo analise e atue separadamente em cada instância do tipo que é inserida no mecanismo. Entretanto, em alguns cenários, deseje que o mecanismo analise simultaneamente várias instâncias que tenham o mesmo tipo. Por exemplo, a regra de exemplo a seguir usa várias instâncias da classe FamilyMember:

IF FamilyMember.Role == Father
AND FamilyMember.Role == Son
AND FamilyMember.Surname == FamilyMember.Surname
THEN FamilyMember.AddChild(FamilyMember)

A regra identifica várias instâncias de FamilyMember em que uma é Pai e a outra é Filho. Se as instâncias estiverem relacionadas por sobrenome, a regra adiciona a instância Filho a uma coleção de filhos da instância Pai. Se o mecanismo analisar separadamente cada instância FamilyMember, a regra nunca será disparada porque, nesse cenário, FamilyMember tem apenas uma função, Pai ou Filho.

Portanto, nesse cenário, você deve indicar que o mecanismo analisa várias instâncias juntas na regra e precisa de uma maneira de diferenciar a identidade de cada instância na regra. Você pode usar o campo ID da Instância para fornecer essa funcionalidade. Esse campo está disponível na janela Propriedades quando você seleciona um fato no Gerenciador de Fatos.

Importante

Se optar por usar o campo ID da Instância, certifique-se de alterar seu valor antes de arrastar um fato ou membro para uma regra.

Quando você usa o campo ID da Instância, a regra é reconstruída. Para os argumentos de regra que usam a instância Filho da classe FamilyMember, altere o valor da ID da Instância do padrão 0 para 1. Quando você altera o valor da ID da Instância de 0 e arrasta o fato ou membro para o Editor de Regras, o valor da ID da Instância aparece na regra que segue a classe, por exemplo:

IF FamilyMember.Role == Father
AND FamilyMember(1).Role== Son
AND FamilyMember.Surname == FamilyMember(1).Surname
THEN FamilyMember.AddChild(FamilyMember(1))

Agora, suponha que uma instância Pai e uma instância Filho sejam declaradas no mecanismo. O mecanismo avalia a regra em relação às várias combinações dessas instâncias. Supondo que as instâncias Pai e Filho tenham o mesmo sobrenome, a instância Filho é adicionada à instância Pai conforme esperado.

Observação

O campo ID da Instância só é usado no contexto de uma avaliação de regra específica. Este campo não é fixado a uma instância de objeto durante a execução do conjunto de regras e não está relacionado à ordem usada para declarar objetos. Cada instância de objeto é avaliada em todos os argumentos de regra para esse tipo.

Conteúdo relacionado