Compilar criadores e recuperadores de fatos para usar com regras e conjuntos de regras (versão prévia)
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.
Para criar fatos para o mecanismo de regras a ser usado durante o desenvolvimento e o teste de regras de negócios, você pode compilar um criador de fatos, que fornece ao seu mecanismo uma matriz de objetos .NET. Você também pode compilar um recuperador de fatos que insere fatos de longo prazo ou de alteração lenta em suas regras para avaliação durante a execução.
Este guia de instruções mostra como compilar um criador de fatos e um recuperador de fatos para seu projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure a ser usado.
Compilar um criador de fatos
Para criar suas instâncias de fatos, implemente a interface de IFactCreator e seus métodos, CreateFactse GetFactTypes. Depois de compilar o assembly .NET (arquivo DLL) para seu primeiro criador de fatos, você pode selecionar o assembly na funcionalidade de teste do conjunto de regras no Microsoft Rules Composer. Para obter mais informações, consulte conjuntos de regras de teste.
O exemplo a seguir mostra um exemplo de implementação do criador de fato:
public class MyFactCreator : IFactCreator
{
private object[] myFacts;
public MyFactCreator()
{
}
public object[] CreateFacts ( RuleSetInfo rulesetInfo )
{
myFacts = new object[1];
myFacts.SetValue(new MySampleBusinessObject(),0);
return myFacts;
}
public Type[] GetFactTypes (RuleSetInfo rulesetInfo)
{
return null;
}
}
Compilação um recuperador de fatos
Um recuperador de fatos é um objeto .NET que implementa métodos padrão e normalmente os usa para fornecer fatos de longo prazo e alterando lentamente para o mecanismo de regras antes que o mecanismo execute o conjunto de regras. O mecanismo armazena esses fatos em cache e os usa em vários ciclos de execução. O recuperador de fatos envia o fato pela primeira vez e, em seguida, atualiza o fato na memória somente quando necessário. Em vez de enviar um fato sempre que você invocar o mecanismo de regras, crie um recuperador de fatos que envie o fato pela primeira vez e atualize o fato na memória somente quando necessário.
Para fornecer instâncias de fatos ao mecanismo de regras, implemente a interface IFactRetriever e o método UpdateFacts. Em seguida, você pode configurar sua versão do conjunto de regras para usar essa implementação para trazer fatos em tempo de execução. Sua versão do conjunto de regras chama o método UpdateFacts em cada ciclo de execução.
Opcionalmente, você pode implementar a interface IFactRemover em um componente do recuperador de fatos. Em seguida, o mecanismo de regras pode chamar o método chamado UpdateFactsAfterExecution da interface IFactRemover quando o conjunto de regras é descartado. Dessa forma, você pode fazer qualquer trabalho pós-execução, como confirmar qualquer alteração de banco de dados ou retirar quaisquer instâncias de objeto da memória de trabalho do mecanismo de regras.
Você pode projetar o recuperador de fatos com a lógica específica do aplicativo necessária para executar as seguintes tarefas:
Conecte-se às fontes de dados necessárias.
Afirme os dados como fatos de longo prazo no mecanismo.
Especifique a lógica para atualizar ou declarar novas instâncias de fato de longo prazo no mecanismo.
O mecanismo usa os valores inicialmente declarados e armazenados em cache em ciclos de execução subsequentes até que esses valores sejam atualizados.
A implementação do recuperador de fatos retorna um objeto que é análogo a um token que o recuperador pode usar com o objeto factsHandleIn para determinar se deve atualizar fatos existentes ou declarar novos fatos. Quando uma versão do conjunto de regras chama o recuperador de fatos pela primeira vez, o objeto factsHandleIn sempre é definido como nulo, mas assume o valor do objeto de retorno após a conclusão da execução do recuperador de fatos.
O código de exemplo a seguir mostra como afirmar fatos .NET e XML usando uma implementação de recuperador de fatos:
using System;
using System.Xml;
using System.Collections;
using Microsoft.Azure.Workflows.RuleEngine;
using System.IO;
using System.Data;
using System.Data.SqlClient;
namespace MyApplication.FactRetriever
{
public class myFactRetriever:IFactRetriever
{
public object UpdateFacts(RuleSetInfo rulesetInfo, RuleEngine engine, object factsHandleIn)
{
object factsHandleOut;
if (factsHandleIn == null)
{
// Create .NET object instances.
bookInstance = new Book();
magazineInstance = new Magazine();
// Create XML object instance.
XmlDocument xd = new XmlDocument();
// Load the XML document.
xd.Load(@"..\myXMLInstance.xml");
// Create and instantiate a TypedXmlDocument class instance.
TypedXmlDocument doc = new TypedXmlDocument("mySchema",xd1);
engine.Assert(bookInstance);
engine.Assert(magazineInstance);
engine.Assert(doc);
factsHandleOut = doc;
}
else
factsHandleOut = factsHandleIn;
return factsHandleOut;
}
}
}
Para incluir os seguintes recursos, escreva sua própria implementação de código:
Determine quando atualizar os fatos de longo prazo.
Acompanhe qualquer instância do mecanismo de regras que use todos os fatos de longo prazo.
Especificar um recuperador de fatos para um conjunto de regras
Para configurar o fact retriever para sua versão do conjunto de regras, você pode definir a propriedade Fact Retriever no Microsoft Rules Composerou escrever seu próprio código, conforme mostrado no exemplo a seguir, que usa uma classe chamada “MyFactRetriever” no assembly denominado “MyAssembly”:
RuleEngineComponentConfiguration fr = new RuleEngineComponentConfiguration("MyAssembly", "MyFactRetriever");
RuleSet rs = new RuleSet("ruleset");
// Associate the execution configuration with a ruleset version.
RuleSetExecutionConfiguration rsCfg = rs.ExecutionConfiguration;
rsCfg.FactRetriever = factRetriever;
Observação
Se você usar um nome de assembly genérico simples, como “MyAssembly”, como o primeiro parâmetro do construtor RuleEngineComponentConfiguration, o mecanismo de regras procurará o assembly na pasta do aplicativo.