RuleAction Classe

Définition

Espace de noms:

System.Workflow.Activities.Rules

Assembly:

System.Workflow.Activities.dll

Représente une classe abstraite qui définit une action à exécuter si la Condition associée a la valeur true, pour ThenActions, ou false, pour ElseActions. Cette classe doit être héritée.

public ref class RuleAction abstract

[System.Serializable]
public abstract class RuleAction

[<System.Serializable>]
type RuleAction = class

Public MustInherit Class RuleAction

Héritage

Object

RuleAction

Dérivé

System.Workflow.Activities.Rules.RuleHaltAction

System.Workflow.Activities.Rules.RuleStatementAction

System.Workflow.Activities.Rules.RuleUpdateAction

Attributs

SerializableAttribute

Exemples

Le code suivant crée une action qui peut être utilisée dans des ensembles de règles. L'action est nommée Log et utilise un paramètre unique, qui doit prendre la valeur d'une chaîne. Cette action transmet la chaîne à la console.

Pour utiliser ce code, il est nécessaire de l'ajouter à un projet Bibliothèque de classes et de référencer la bibliothèque à partir de votre projet de workflow.

using System;  
using System.CodeDom;  
using System.Collections.Generic;  
using System.Text;  
using System.Workflow.Activities.Rules;  
using System.Workflow.ComponentModel.Compiler;  

namespace LogRuleAction  
{  
    public class Log : RuleAction  
    {  
        CodeExpression message;  

        public CodeExpression Message  
        {  
            get { return message; }  
            set { message = value; }  
        }  

        public Log()  
        {  
            // constructor required for deserialization  
        }  

        public Log(CodeExpression expression)  
        {  
            // constructor required by parser  
            message = expression;  
        }  

        public override bool Validate(RuleValidation validator)  
        {  
            ValidationError error;  
            if (message == null)  
            {  
                error = new ValidationError("Message cannot be null", 123);  
                validator.Errors.Add(error);  
                return false;  
            }  
            else  
            {  
                RuleExpressionInfo result = RuleExpressionWalker.Validate(validator, message, false);  
                if ((result == null) || (result.ExpressionType != typeof(string)))  
                {  
                    error = new ValidationError("Message must return string result", 123);  
                    validator.Errors.Add(error);  
                    return false;  
                }  
            }  
            return (validator.Errors.Count == 0);  
        }  

        public override RuleAction Clone()  
        {  
            Log result = new Log();  
            result.Message = RuleExpressionWalker.Clone(message);  
            return result;  
        }  

        public override void Execute(RuleExecution context)  
        {  
            RuleExpressionResult result = RuleExpressionWalker.Evaluate(context, message);  
            if (result != null)  
                Console.WriteLine(result.Value);  
        }  

        public override ICollection<string> GetSideEffects(RuleValidation validation)  
        {  
            RuleAnalysis analysis = new RuleAnalysis(validation, true);  
            if (message != null)  
                RuleExpressionWalker.AnalyzeUsage(analysis, message, true, false, null);  
            return analysis.GetSymbols();  
        }  

        public override string ToString()  
        {  
            // what should be displayed by the parser  
            StringBuilder result = new StringBuilder("Log(");  
            RuleExpressionWalker.Decompile(result, message, null);  
            result.Append(")");  
            return result.ToString();  
        }  
    }  
}  

Remarques

Les objets RuleStatementAction (qui peuvent être utilisés comme ThenActions et ElseActions) affectent généralement à l'une des propriétés de l'activité une valeur de variable, appellent une méthode de l'activité ou des méthodes statiques sur des types des assemblys référencés.

RuleAction est le type de base à partir duquel les classes RuleStatementAction, RuleHaltAction et RuleUpdateAction dérivent. Les utilisations de ces classes sont les suivantes :

• RuleStatementAction modifie une propriété ou appelle une méthode.

• RuleHaltAction arrête l'exécution de RuleSet et retourne le contrôle à la méthode d'appel.

• RuleUpdateAction indique explicitement qu'une règle met à jour une variable. Cela provoque la réévaluation de toutes les règles affectées.

Constructeurs

RuleAction()

Lors de l'implémentation dans une classe dérivée, initialise une nouvelle instance de la classe RuleAction.

Méthodes

Clone()	Crée une copie complète du RuleAction en cours.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Execute(RuleExecution)	Exécute RuleAction à l'aide de l'instance RuleExecution spécifiée.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetSideEffects(RuleValidation)	Retourne les champs et les propriétés mis à jour par RuleAction.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
Validate(RuleValidation)	Vérifie que RuleAction est configuré correctement et n'a pas d'erreurs.