Effectuer des tâches avancées sur des ensembles de règles avec l’Éditeur de règles Microsoft (préversion)

S’applique à : Azure Logic Apps (Standard)

Ce guide décrit des opérations plus avancées que vous pouvez effectuer sur des ensembles de règles dans l’Éditeur de règles Microsoft.

Prérequis

• Avoir téléchargé et installé l’Éditeur de règles Microsoft.

• Le Fichier XML qui contient l’ensemble de règles sur lequel vous souhaitez travailler.

Copier une version d’ensemble de règles

Vous pouvez créer une copie d’une version d’ensemble de règles existantes, mais avec un autre numéro de version.

1. Ouvrez l’Éditeur de règles Microsoft. Dans la fenêtre de l’Explorateur RuleSet, ouvrez le menu contextuel de l’ensemble de règles, puis sélectionnez Copier.

2. Ouvrez le menu contextuel de l’ensemble de règles, puis sélectionnez Coller la version RuleSet.

   L’Éditeur de règles Microsoft crée une nouvelle version d’ensemble de règles avec les mêmes éléments que la version copiée, mais avec un nombre différent.

   Remarque

   Si vous mettez à jour l’assembly .NET utilisé pour fournir des faits à votre ensemble de règles, veillez à mettre à jour les références de votre ensemble de règles à cet assembly. Pour plus d’informations, consultez Mettre à jour les références d’assembly .NET.

Créer une version d’un ensemble de règles vide

Après avoir ajouté des règles à une version d’ensemble de règles, vous pouvez créer une nouvelle version d’ensemble de règles vide avec un nombre différent et enregistrer cette version pour que vous puissiez travailler dessus ultérieurement.

1. Ouvrez l’Éditeur de règles Microsoft. Dans le menu contextuel de l’ensemble de règles, sélectionnez Ajouter une nouvelle version.

   L’Éditeur de règles Microsoft crée une nouvelle version d’ensemble de règles vide avec un nombre différent.

2. Ouvrez le nouveau menu contextuel de l’ensemble de règles, puis sélectionnez Enregistrer.

Vous pouvez maintenant copier des règles provenant d'autres versions d’ensemble de règles et les coller dans la nouvelle version.

Envoyer des types de faits à un ensemble de règles

Bien que vous ne puissiez pas spécifier directement un type de retour pour un ensemble de règles, vous pouvez envoyer l’un des types de faits suivants à l’ensemble de règles, faire en sorte que l’ensemble de règles modifie la valeur du fait en true ou false, puis vérifier la valeur de la propriété ou de l’élément/colonne après l’exécution de l’ensemble de règles :

• Un objet .NET qui a une propriété avec le type Boolean
• Un document XML qui a un élément avec le type Boolean

Configurer un extracteur de faits pour un ensemble de règles

Lorsque vous utilisez un extracteur de faits avec votre ensemble de règles, vous pouvez stocker les faits qui ne changent pas souvent, et ce avant le premier cycle d’exécution de votre application hôte. De cette façon, vous pouvez récupérer ces faits à partir du stockage, les présenter une fois au moteur de règles pour la mise en cache et les réutiliser sur plusieurs cycles d’exécution. Pour plus d’informations, consultez Créer des créateurs et des extracteurs de faits.

Vous avez le choix entre deux méthodes pour associer un extracteur de faits à un ensemble de règles :

• Sélectionnez manuellement un extracteur de faits pour une version d’ensemble de règles dans l’Éditeur de règles Microsoft.

• Effectuez cette opération par programme à l’aide de l’objet RuleSetExecutionConfiguration.

Sélectionner manuellement un extracteur de faits pour un ensemble de règles

1. Ouvrez l’Éditeur de règles Microsoft. Dans l’Explorateur RuleSet, sélectionnez la version de l’ensemble de règles que vous souhaitez associer à l’extracteur de faits.

2. Dans la fenêtre Propriétés, sélectionnez la ligne de propriété FactRetriever, puis sélectionnez le bouton de points de suspension (…) pour rechercher et sélectionner un objet d’extracteur de faits existant.

   Remarque

   Le bouton points de suspension (...) n'apparaît que lorsque vous sélectionnez la ligne FactRetriever dans la fenêtre Propriétés.

Appeler un ensemble de règles enfant à partir d’un ensemble de règles parent

Pour cette tâche, utilisez l'une des méthodes suivantes :

• Appelez la méthode Ruleset.Execute directement à partir de l’ensemble de règles parent.

• À partir d’un ensemble de règles parent, appelez une méthode d'un composant .NET d'assistance qui enveloppe la méthode Ruleset.Execute.

  Avec la deuxième méthode, vous pouvez ajouter du code de prétraitement et de post-traitement à la méthode Ruleset.Execute. Par exemple, vous pouvez créer les faits requis à partir de l’ensemble de règles enfant de cette méthode de wrapper. Les sections suivantes fournissent un exemple pour chaque méthode.

Appelez la méthode Ruleset.Execute directement à partir de l’ensemble de règles parent

Cette section fournit une procédure générale pour appeler l’ensemble de règles enfant directement à partir de l’Ensemble de règles parent à l’aide de la méthode Ruleset.Execute. La procédure suivante montre les étapes pour ajouter la méthode Ruleset.Execute en tant qu'action à l’ensemble de règles parent qui envoie un document XML en tant que fait à l’ensemble de règles enfant.

1. Ouvrez l’Éditeur de règles Microsoft. Dans la fenêtre de l'Explorateur de faits, sélectionnez l'onglet .NET Classes.

2. Ouvrez le menu contextuel pour assemblys .NET, puis sélectionnez Parcourir.

3. Depuis la liste Assemblys .NET, sélectionnez Microsoft.RuleEngine, puis sélectionnez OK.

4. Développez Ensemble de règles, puis faites glisser Execute(Object facts) ou Execute(Object facts, IRuleSetTrackingInterceptor trackingInterceptor) vers le volet THEN.

5. Sélectionnez les nœuds schémas XML, ouvrez le menu contextuel de Schémas, puis sélectionnez Parcourir.

6. Sélectionnez le schéma du document XML à envoyer en tant que fait, puis sélectionnez Ouvrir.

7. Pour passer le document XML envoyé à l’ensemble de règles parent en tant que fait à l’ensemble de règles enfant, faites glisser <schema-name>.xsd sur le premier argument de la méthode Ruleset.Execute.

8. Si vous utilisez la méthode Execute qui ne prend pas IRuleSetTrackingInterceptor comme deuxième argument, ignorez les étapes suivantes.

9. Sélectionnez l’onglet .NET Classes, puis faites glisser DebugTrackingInterceptor dans Microsoft.RuleEngine vers le deuxième argument de la méthode Ruleset.Execute.

   Remarque

   Si vous effectuez cette action, le client doit envoyer une instance de la classe DebugTrackingInterceptor en tant que fait à l’ensemble de règles parent, qui ensuite l'envoie en tant que fait à l’ensemble de règles enfant. Vous pouvez à la place faire glisser le constructeur de la classe DebugTrackingInterceptor pour que l'instance soit automatiquement créée pour vous.

Modifier l’application cliente qui appelle l’ensemble de règles parent

Le client qui appelle l’ensemble de règles parent crée une instance de la classe Ensemble de règles avec le nom de l’ensemble de règles enfant en tant que paramètre et l'envoie en tant que fait à l’ensemble de règles parent accompagné d'autres faits. L'exemple de code suivant illustre cette action :

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 le client est une orchestration BizTalk, il peut s'avérer nécessaire de placer le code sous la forme Expression pour créer des faits, puis d'envoyer les faits en tant que paramètres à la forme Appeler règles.

Appel d'une méthode de wrapper .NET à partir de l’ensemble de règles parent

Cette section présente la procédure générale d'appel d'une méthode .NET qui enveloppe l'appel à la méthode Ruleset.Execute à partir de l’ensemble de règles parent.

Créer la classe d'utilitaire .NET

1. Créez un projet de bibliothèque de classes .NET. Ajoutez une classe au projet.

2. Ajoutez une méthode statique appelant la méthode Ruleset.Execute pour appeler l’ensemble de règles dont le nom est envoyé en tant que paramètre, comme montré dans l'exemple de code suivant :

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

   Le client appelle l’ensemble de règles parent et l’ensemble de règles parent appelle la méthode d’assistance qui appelle l’ensemble de règles enfant, comme montré dans l’exemple de code suivant pour le client :

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

   Remarque

   Si vous utilisez une méthode d'instance, le client doit créer une instance de la classe d'assistance .NET et envoyer cette instance en tant que fait à l’ensemble de règles parent.

Analyser plusieurs objets du même type dans une règle

Dans de nombreux scénarios, vous rédigez une règle métier sur un type et attendez que le moteur analyse et agisse séparément sur chaque instance du type qui est déclaré dans le moteur. Toutefois, dans certains scénarios, vous souhaitez que le moteur analyse simultanément plusieurs instances qui ont le même type. Par exemple, l’exemple de règle suivant utilise plusieurs instances de la classe FamilyMember :

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

La règle identifie plusieurs instances FamilyMember où l’une d’elles est un Père et une autre un Fils. Si les instances sont liées par le nom de famille, la règle ajoute l'instance Fils à une collection d’enfants sur l'instance Père. Si le moteur analyse séparément chaque instance FamilyMember, la règle ne se déclenche jamais, car dans ce scénario, FamilyMember dispose d'un seul rôle, soit Père, soit Fils.

De ce fait, dans ce scénario, vous devez indiquer que le moteur analyse plusieurs instances ensemble dans la règle. En outre, vous devez définir un moyen de différencier l'identité de chaque instance dans la règle. Vous pouvez utiliser le champ ID de l'instance pour fournir cette fonctionnalité. Ce champ est disponible dans la fenêtre Propriétés lors de la sélection d'un fait dans l'Explorateur de faits.

Lorsque vous utilisez le champ ID de l’instance, la règle est reconstruite. Pour ces arguments de règle qui utilisent l’instance Fils de la classe FamilyMember, remplacez la valeur d’ID de l’instance par défaut de 0 à 1. Lorsque vous modifiez la valeur d’ID de l’instance de 0 et que vous faites glisser le fait ou le membre dans l’Éditeur de règle, la valeur d’ID de l’instance apparaît dans la règle suivant la classe, par exemple :

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

Supposons, à présent, qu'une instance Père et qu'une instance Fils soient déclarées dans le moteur. Le moteur évalue la règle par rapport aux diverses combinaisons de ces instances. En supposant que les instances Père et Fils disposent du même nom de famille, l'instance Fils est ajoutée à l'instance Père comme attendu.

Contenu connexe

• Créer des règles avec l’Éditeur de règles Microsoft
• Créer un projet de moteur de règles Azure Logic Apps