RuleAction Klasse

Definition

public ref class RuleAction abstract

[System.Serializable]
public abstract class RuleAction

[<System.Serializable>]
type RuleAction = class

Public MustInherit Class RuleAction

Vererbung

Object

RuleAction

Abgeleitet

System.Workflow.Activities.Rules.RuleHaltAction

System.Workflow.Activities.Rules.RuleStatementAction

System.Workflow.Activities.Rules.RuleUpdateAction

Attribute

SerializableAttribute

Beispiele

Mit dem folgenden Code wird eine Aktion erstellt, die in Regelsätzen verwendet werden kann. Die Aktion wird Log genannt und verwendet einen einzelnen Parameter, der eine Zeichenfolge ergeben muss. Diese Aktion gibt die Zeichenfolge in der Konsole aus.

Verwenden Sie diesen Code, fügen Sie ihn einem Klassenbibliotheksprojekt hinzu, und verweisen Sie in Ihrem Workflowprojekt auf die Bibliothek.

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

Hinweise

RuleStatementAction-Objekte (die als ThenActions und auch als ElseActions verwendet werden können) legen in der Regel einen Variablenwert für eine Eigenschaft der Aktivität fest, rufen eine Methode der Aktivität auf oder rufen eine statische Methode der Typen in Assemblys auf, auf die verwiesen wird.

RuleAction ist der Basistyp, von dem die Klassen RuleStatementAction, RuleHaltAction und RuleUpdateAction abgeleitet werden. Diese Klassen werden folgendermaßen verwendet:

• RuleStatementAction ändert eine Eigenschaft oder ruft eine Methode auf.

• RuleHaltAction beendet das Ausführen von RuleSet und übergibt die Steuerung wieder an die aufrufende Methode.

• RuleUpdateAction gibt explizit an, dass eine Regel eine Variable aktualisiert. Dadurch werden betroffene Regeln erneut ausgewertet.

Konstruktoren

Methoden

Gilt für: