Compartir vía

Realización de tareas avanzadas en conjuntos de reglas con Microsoft Rules Composer (versión preliminar)

  • Artículo

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.

En esta guía se describen las operaciones más avanzadas que puedes realizar en los conjuntos de reglas de Microsoft Rules Composer.

Requisitos previos

  • Descargue e instale el Microsoft Rules Composer.

  • El archivo XML que contiene el conjunto de reglas sobre el que quieres trabajar.

Copia de una versión del conjunto de reglas

Puedes crear una copia de una versión del conjunto de reglas existente, pero con un número de versión diferente.

  1. Abre Microsoft Rules Composer. En la ventanaExplorador del conjunto de reglas, abre el menú contextual de la versión del conjunto de reglas y selecciona Copiar.

  2. Abre el menú contextual del conjunto de reglas y selecciona Pegar versión del conjunto de reglas.

    Microsoft Rules Composer crea una versión del conjunto de reglas con los mismos elementos que la versión copiada, pero con un número diferente.

    Nota:

    Si actualizas el ensamblado de .NET que se ha usado para proporcionar datos a tu conjunto de reglas, asegúrate de actualizar las referencias de la versión del conjunto de reglas a ese ensamblado. Para obtener más información, consulta Actualizar referencias de ensamblado de .NET.

Creación de una versión vacía del conjunto de reglas

Después de agregar definiciones a una versión del conjunto de reglas, puedes crear una versión del conjunto de reglas vacía con un número diferente y guardar esa versión para que funcione más adelante.

  1. Abre Microsoft Rules Composer. En el menú contextual del conjunto de reglas, selecciona Agregar nueva versión.

    Microsoft Rules Composer crea una versión del conjunto de reglas vacía con un número diferente.

  2. Abre el menú contextual de la nueva versión del conjunto de reglas y selecciona Guardar.

Ya puedes copiar reglas de otras versiones del conjunto de reglas y pegarlas en la versión nueva.

Traspaso de tipos de datos a un conjunto de reglas

Aunque no se puede especificar directamente un tipo de valor devuelto para un conjunto de reglas, puedes pasar uno de los siguientes tipos de datos al conjunto de reglas, hacer que el conjunto de reglas cambie el valor del hecho a true o false y, después, comprobar el valor de la propiedad, elemento o columna después de que se ejecute el conjunto de reglas:

  • Un objeto .NET que tiene una propiedad con tipo Boolean.
  • Un documento XML que tiene un elemento con tipo Boolean.

Configuración de un recuperador de datos para un conjunto de reglas

Al usar un recuperador de datos con el conjunto de reglas, puedes almacenar datos que a menudo no cambian antes del primer ciclo de ejecución de la aplicación host. De este modo, puedes recuperar estos datos del almacenamiento, presentarlos una vez al motor de reglas para el almacenamiento en caché y reutilizarlos en varios ciclos de ejecución. Para obtener más información, consulta Crear creadores y recuperadores de datos.

Existen dos modos para asociar un recuperador de datos con un conjunto de reglas:

  • Seleccionar manualmente un recuperador de datos para una versión del conjunto de reglas en Microsoft Rules Composer.

  • Hacerlo mediante programación, con el objeto RuleSetExecutionConfiguration.

Nota:

Solo puedes asociar una implementación del recuperador de datos a una versión del conjunto de reglas.

Selección manual de un recuperador de datos para un conjunto de reglas

  1. Abre Microsoft Rules Composer. En el Explorador del conjunto de reglas, selecciona la versión del conjunto de reglas que quieres asociar al recuperador de datos.

  2. En la ventana Propiedades, selecciona la fila de propiedades FactRetriever y luego el botón de puntos suspensivos (…) para buscar y seleccionar un objeto del recuperador de datos existente.

    Nota:

    El botón de puntos suspensivos (...) no aparece hasta que selecciones la fila FactRetriever de la ventana Propiedades.

Llamada a un conjunto de reglas secundario desde un conjunto de reglas principal

Para esta tarea, usa uno de los métodos siguientes:

  • Llama al método Ruleset.Execute directamente desde el conjunto de reglas principal.

  • Desde el conjunto de reglas principal, llama a un método de un componente auxiliar de .NET que encapsula el método Ruleset.Execute.

    Con el segundo método, puedes agregar código de preprocesamiento y postprocesamiento al método Ruleset.Execute. Por ejemplo, puedes crear cualquier dato necesario desde el conjunto de reglas secundario en este método contenedor. Las siguientes secciones proporcionan un ejemplo para cada método.

Llama al método Ruleset.Execute directamente desde el conjunto de reglas principal.

En esta sección se proporcionan pasos generales para llamar al conjunto de reglas secundario directamente desde el conjunto de reglas principal mediante el método Ruleset.Execute. En el siguiente procedimiento se muestra los pasos para agregar el método Ruleset.Execute como acción al conjunto de reglas principal que transfiere un documento XML como un dato al conjunto de reglas secundario.

Nota:

En este escenario de ejemplo, se envía un documento XML como un dato al conjunto de reglas principal. Este documento se pasa como un dato al conjunto de reglas secundario. Pero puedes llamar a un método .NET que cree los datos para el conjunto de reglas secundario.

  1. Abre Microsoft Rules Composer. En la ventana Explorador de datos, selecciona la pestaña Clases de .NET.

  2. Abre el menú contextual de Ensamblados de .NET y selecciona Examinar.

  3. En la lista Ensamblados de .NET, selecciona Microsoft.RuleEngine y, después, Aceptar.

  4. Expande Conjunto de reglas y arrastra Execute(Object facts) o Execute(Object facts, IRuleSetTrackingInterceptor trackingInterceptor) al panel THEN.

  5. Selecciona el nodo Esquemas XML, abre el menú contextual de Esquemas y selecciona Examinar.

  6. Selecciona el esquema del documento XML que quieras transferir como dato y luego Abrir.

  7. Para pasar el documento XML que se pasa al conjunto de reglas principal como un dato al conjunto de reglas secundario, arrastra <nombre-esquema>.xsd al primer argumento del método Ruleset.Execute.

  8. Si usas el método Execute que no toma IRuleSetTrackingInterceptor como segundo argumento, omite los pasos siguientes.

  9. Selecciona la pestaña Clases de .NET y arrastra DebugTrackingInterceptor en Microsoft.RuleEngine al segundo argumento del método Ruleset.Execute.

    Nota:

    Si llevas a cabo esta acción, el cliente debe pasar una instancia de la clase DebugTrackingInterceptor como un dato al conjunto de reglas principal, lo que, a su vez, pasa la instancia como un dato al conjunto de reglas secundario. En lugar de ello, puedes arrastrar el constructor de la clase DebugTrackingInterceptor de modo que la instancia se cree de forma automática.

Modificación de la aplicación cliente que llama al conjunto de reglas principal

El cliente que invoca el conjunto de reglas principal crea una instancia de la clase Ruleset con el nombre del conjunto de reglas secundario como parámetro y lo pasa como un dato al conjunto de reglas principal junto con otros datos. En el siguiente código de ejemplo se ilustra esta acción:

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();

Si el cliente es una orquestación de BizTalk, es posible que tengas que colocar el código en una forma Expresión para crear datos y, después, pasar los datos como parámetros a la forma Reglas de llamada.

Llamada a un método contenedor de .NET desde el conjunto de reglas principal

En esta sección se detallan los pasos generales para invocar un método .NET que incluye la llamada al método Ruleset.Execute desde el conjunto de reglas principal.

Creación de la clase de utilidad .NET

  1. Crea un proyecto de biblioteca de clases .NET. Agregue una clase al proyecto.

  2. Agrega un método estático que llame al método Ruleset.Execute para invocar el conjunto de reglas cuyo nombre se pasa como parámetro, por ejemplo, como se muestra en el siguiente código de ejemplo:

    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();
}

    El cliente invoca el conjunto de reglas principal y este conjunto de reglas llama al método auxiliar que invoca el conjunto de reglas secundario, por ejemplo, como se muestra en el código de ejemplo siguiente para el 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:

    Si el método es de instancia, el cliente debe crear una instancia de la clase .NET auxiliar y pasar esa instancia como un dato al conjunto de reglas principal.

Análisis de varios objetos del mismo tipo en una regla

En muchos escenarios, la regla empresarial se escribe con respecto a un tipo y se espera que el motor analice independientemente y actúe en cada instancia del tipo que se impone en el motor. Pero en algunos escenarios, querrás que el motor analice simultáneamente varias instancias que tienen el mismo tipo. Por ejemplo, la siguiente regla de ejemplo usa varias instancias de la clase FamilyMember:

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

La regla identifica varias instancias de FamilyMember, donde una es Father y otra es Son. Si las instancias están relacionadas por apellidos, la regla agrega la instancia de Son a una colección de elementos secundarios en la instancia de Father. Si el motor analiza por separado cada instancia FamilyMember, la regla nunca se desencadena porque, en este escenario, FamilyMember solo tiene un rol, ya sea Father o Son.

Por lo tanto, en este escenario, debes indicar que el motor analiza varias instancias juntas en la regla y necesitas una manera de diferenciar la identidad de cada instancia de la regla. Puedes usar el campo Id. de instancia para proporcionar esta función. Este campo está disponible en la ventana Propiedades cuando se selecciona un dato en el Explorador de datos.

Importante

Si decides usar el campo Id. de instancia, asegúrate de cambiar su valor antes de arrastrar un dato o miembro a una regla.

Cuando se usa el campo Id. de instancia, se vuelve a generar la regla. Para aquellos argumentos de regla que usan la instancia de Son de la clase FamilyMember, cambia el valor de Id. de instancia del valor predeterminado 0 a 1. Al cambiar el valor id. de instancia de 0 y arrastrar el dato o miembro al Editor de reglas, el valor de Id. de instancia aparece en la regla que sigue a la clase, por ejemplo:

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

Ahora, supón que una instancia Father y una Son se imponen en el motor. El motor evalúa la regla con respecto a las distintas combinaciones de estas instancias. Suponiendo que las instancias Father y Son tengan el mismo apellido, la instancia Son se agregará a la instancia Father tal como se espera.

Nota:

El campo Id. de instancia solo se utiliza dentro del contexto de una evaluación de regla específica. Este campo no está unido a una instancia de objeto en la ejecución del conjunto de reglas y no está relacionado con el orden usado para asertir objetos. Cada instancia del objeto se evalúa en todos los argumentos de la regla para ese tipo.

Contenido relacionado