RuleAction Classe

Définition

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

Méthodes

S’applique à