Partilhar via

Executar tarefas avançadas em conjuntos de regras com o Microsoft Rules Composer (Pré-visualização)

  • Artigo

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 operações mais avançadas que você pode executar em conjuntos de regras no Microsoft Rules Composer.

Pré-requisitos

  • Transfira e instale o Microsoft Rules Composer.

  • O arquivo XML que contém o conjunto de regras no qual você deseja trabalhar.

Copiar uma versão do conjunto de regras

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

  1. Abra o Microsoft Rules Composer. Na janela RuleSet Explorer, 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.

    Nota

    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 de assembly .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 nova 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 do conjunto 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, você pode 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 falsee, em seguida, verificar o valor da propriedade ou elemento/coluna após a execução do conjunto de regras:

  • Um objeto .NET que tem uma propriedade com Boolean tipo
  • Um documento XML que tem um elemento com Boolean tipo

Configurar um recuperador de fatos para um conjunto de regras

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

Você tem duas maneiras de associar um fact retriever 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 RuleSetExecutionConfiguration objeto.

Nota

Você pode associar apenas uma implementação do fact retriever 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 RuleSet Explorer, selecione a versão do conjunto de regras que você deseja associar ao recuperador de fatos.

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

    Nota

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

Chamar um conjunto de regras filho de um conjunto de regras pai

Para essa tarefa, use um dos seguintes métodos:

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

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

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

Chame 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 Ruleset pai usando o Ruleset.Execute método. O procedimento a seguir mostra as etapas para adicionar o Ruleset.Execute método como uma ação ao conjunto de regras pai que passa um documento XML como um fato para o conjunto de regras filho.

Nota

Neste cenário de exemplo, um documento XML é enviado como um fato para o conjunto de regras pai. Este documento é passado como um fato para o conjunto de regras filho. No entanto, você pode chamar um método .NET que cria os fatos para o conjunto de regras filho em vez disso.

  1. Abra o Microsoft Rules Composer. Na janela Facts Explorer, selecione a guia .NET Classes.

  2. Abra o menu de atalho para assemblies .NET e selecione Procurar.

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

  4. Expanda Ruleset 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 para o documento XML que você deseja passar como um fato e, em seguida, selecione Abrir.

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

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

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

    Nota

    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 então 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 Ruleset com o nome filho do conjunto de regras como um parâmetro e passa essa instância como um fato para o conjunto de regras pai junto 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 do BizTalk, talvez seja necessário 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 Regras de Chamada.

Chamar um método de wrapper .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 encapsula a chamada para o método Ruleset.Execute do conjunto de regras pai.

Criar a classe .NET do utilitário

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

  2. Adicione um método estático que chame o Ruleset.Execute método para invocar o conjunto de regras cujo nome é passado como um 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 seguinte código de exemplo 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();

    Nota

    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 aja separadamente em cada instância do tipo que é afirmado no mecanismo. No entanto, em alguns cenários, você deseja que o mecanismo analise simultaneamente várias instâncias que têm 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 Membros da Família em que um é Pai e outro é Filho. Se as instâncias estiverem relacionadas por sobrenome, a regra adicionará a instância Filho a uma coleção de filhos na instância Pai . Se o mecanismo analisar separadamente cada instância de FamilyMember , a regra nunca será acionada porque, nesse cenário, o FamilyMember terá 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. Este campo está disponível na janela Propriedades quando você seleciona um fato no Facts Explorer.

Importante

Se você 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 Son da classe FamilyMember , altere o valor de ID da instância do padrão de 0 para 1. Quando você altera o valor de ID de instância de 0 e arrasta o fato ou membro para o Editor de regras, o valor de ID de instância aparece na regra após 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 são afirmadas no mecanismo. O mecanismo avalia a regra em relação às várias combinações dessas instâncias. Supondo que a instância Pai e Filho tenham o mesmo sobrenome, a instância Filho é adicionada à instância Pai conforme o esperado.

Nota

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

Conteúdos relacionados