Compilación de creadores y recuperadores de hechos para usarlos con reglas y conjuntos de reglas (versión preliminar)
Se aplica a: Azure Logic Apps (estándar)
Importante
Esta funcionalidad está en versión preliminar y está sujeta a las Condiciones de uso complementarias para las versiones preliminares de Microsoft Azure.
Para compilar hechos que el motor de reglas se pueda usar durante el desarrollo y las pruebas de reglas de negocios, puede compilar un creador de hechos, que proporciona al motor una matriz de objetos .NET. También puede compilar un recuperador de hechos que inserte hechos a largo plazo o que cambien lentamente en las reglas para su evaluación durante la ejecución.
En esta guía paso a paso se muestra cómo compilar un creador de hechos y un recuperador de hechos para el proyecto del motor de reglas de Azure Logic Apps que se va a usar.
Compilación de un creador de hechos
Para compilar las instancias de hechos, implemente la interfaz IFactCreator y sus métodos, CreateFacts y GetFactTypes. Después de compilar el ensamblado .NET (archivo DLL) para su primer creador de hechos, puede seleccionar el ensamblado de la funcionalidad de prueba del conjunto de reglas en Microsoft Rules Composer. Para obtener más información, consulte Conjuntos de reglas de prueba.
En el siguiente ejemplo se muestra una implementación del creador de hechos de ejemplo:
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;
}
}
Compilación de un recuperador de hechos
Un recuperador de hechos es un objeto de .NET que implementa métodos estándar y normalmente los usa para proporcionar hechos a largo plazo y cambiar lentamente al motor de reglas antes de que el motor ejecute el conjunto de reglas. El motor almacena estos datos en caché y los utiliza en varios ciclos de ejecución. El recuperador de hechos envía el hecho la primera vez y lo actualiza en memoria solo cuando es necesario. En lugar de enviar un hecho cada vez que invoque el motor de reglas, compile un recuperador de hechos que envíe el hecho la primera vez y actualice el hecho en memoria solo cuando sea necesario.
Para proporcionar instancias de hechos al motor de reglas, implemente la interfaz IFactRetriever y el método UpdateFacts. A continuación, puede configurar la versión del conjunto de reglas para usar esta implementación para incluir hechos en tiempo de ejecución. A continuación, la versión del conjunto de reglas llama al método UpdateFacts en cada ciclo de ejecución.
Opcionalmente, puede implementar la interfaz IFactRemover en un componente del recuperador de hechos. A continuación, el motor de reglas puede llamar al método denominado UpdateFactsAfterExecution desde la interfaz IFactRemover cuando se elimina el conjunto de reglas. De este modo, puede realizar cualquier trabajo posterior a la ejecución, como confirmar cualquier cambio de base de datos o retirar cualquier instancia de objeto de la memoria de trabajo del motor de reglas.
Puede diseñar el recuperador de hechos con la lógica específica de la aplicación necesaria para realizar las siguientes tareas:
Conectarse a los orígenes de datos necesarios.
Afirmar los datos como hechos a largo plazo en el motor.
Especificar la lógica para actualizar o declarar nuevas instancias de hechos a largo plazo en el motor.
El motor usa los valores afirmados inicialmente y almacenados en caché en los ciclos de ejecución posteriores hasta que se actualicen esos valores.
La implementación del recuperador de hechos devuelve un objeto análogo a un token que el recuperador puede usar con el objeto factsHandleIn para determinar si se deben actualizar los hechos existentes o declarar nuevos hechos. Cuando una versión del conjunto de reglas llama al recuperador de hechos por primera vez, el objeto factsHandleIn siempre se establece en NULL, pero toma el valor del objeto devuelto después de que el recuperador de hechos complete la ejecución.
En el siguiente código de ejemplo se muestra cómo declarar hechos de .NET y XML mediante una implementación del recuperador de hechos:
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 las siguientes funcionalidades, escriba su propia implementación de código:
Determinar cuándo actualizar los hechos a largo plazo.
Realizar un seguimiento de la instancia del motor de reglas que use los hechos a largo plazo.
Especificar un recuperador de hechos para un conjunto de reglas
Para configurar el recuperador de hechos para la versión del conjunto de reglas, puede establecer la propiedad Fact Retriever en Microsoft Rules Composer, o escribir su propio código como se muestra en el siguiente ejemplo, que usa una clase denominada "MyFactRetriever" en el ensamblado 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;
Nota:
Si usa un nombre de ensamblado genérico simple, como "MyAssembly", como primer parámetro para el constructor RuleEngineComponentConfiguration, el motor de reglas busca el ensamblado en la carpeta de la aplicación.