Crie criadores de fatos e recuperadores para usar com regras e conjuntos de regras (Visualização)
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.
Para criar fatos para o mecanismo de regras usar durante o desenvolvimento e o teste de regras de negócios, você pode criar um criador de fatos, que fornece ao mecanismo uma matriz de objetos .NET. Você também pode criar um fact retriever que insere fatos de longo prazo ou que mudam lentamente em suas regras de avaliação durante a execução.
Este guia de instruções mostra como criar um criador de fatos e um recuperador de fatos para seu projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure usar.
Crie um criador de fatos
Para criar suas instâncias de fato, implemente a interface IFactCreator e seus métodos, CreateFacts e GetFactTypes. Depois de criar o assembly .NET (arquivo DLL) para seu primeiro criador de fatos, você pode selecionar o assembly no recurso de teste de 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 fatos:
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;
}
}
Crie um fact retriever
Um fact retriever é um objeto .NET que implementa métodos padrão e normalmente os usa para fornecer fatos de longo prazo e que mudam 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 fact retriever submete o fato pela primeira vez e, em seguida, atualiza o fato na memória apenas quando necessário. Em vez de enviar um fato cada vez que você invocar o mecanismo de regras, crie um recuperador de fatos que envie o fato pela primeira vez e, em seguida, atualize o fato na memória somente quando necessário.
Para fornecer instâncias de fatos ao seu mecanismo de regras, implemente a interface IFactRetriever e o método UpdateFacts . Em seguida, você pode configurar a versão do conjunto de regras para usar essa implementação para trazer fatos em tempo de execução. Em seguida, a 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 fact retriever. O mecanismo de regras pode então 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 quaisquer alterações no banco de dados ou retirar quaisquer instâncias de objeto da memória de trabalho do mecanismo de regras.
Você pode projetar seu 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 afirmar novas instâncias de fatos 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 fact retriever retorna um objeto que é análogo a um token que o retriever pode usar com o objeto factsHandleIn para determinar se deve atualizar fatos existentes ou afirmar fatos novos. Quando uma versão do conjunto de regras chama o recuperador de fatos pela primeira vez, o objeto factsHandleIn é sempre definido como null, mas assume o valor do objeto de retorno depois que o recuperador de fatos conclui a execução.
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.
Rastreie qualquer instância do mecanismo de regras que use quaisquer 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 Composer ou escrever seu próprio código, conforme mostrado no exemplo a seguir, que usa uma classe chamada "MyFactRetriever" no assembly chamado "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;
Nota
Se você usar um nome de assembly genérico simples, como "MyAssembly", como o primeiro parâmetro para o construtor RuleEngineComponentConfiguration , o mecanismo de regras procurará o assembly na pasta do aplicativo.