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

Der folgende Code erstellt eine Aktion, die in Regelsätzen verwendet werden kann. Die Aktion heißt Log, und verwendet einen einzelnen Parameter, der zu einer Zeichenfolge ausgewertet werden muss. Diese Aktion gibt die Zeichenfolge an die Konsole aus.

Um diesen Code zu verwenden, fügen Sie ihn einem Klassenbibliotheksprojekt hinzu, und verweisen Sie auf die Bibliothek aus Ihrem Workflowprojekt.

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 in der Regel als beide ThenActions und ElseActions) verwendet werden können, legen einen Variablenwert für eine der Eigenschaften der Aktivität fest, rufen eine Methode der Aktivität auf oder rufen statische Methoden für Typen in referenzierten Assemblys auf.

RuleActionist der Basistyp, RuleStatementActionvon dem die RuleHaltActionRuleUpdateActionKlassen abgeleitet sind. Die Verwendung dieser Klassen lautet wie folgt:

• Eine RuleStatementAction Eigenschaft ändert oder eine Methode aufruft.

• A RuleHaltAction führt dazu, dass die RuleSet Ausführung beendet wird und die Steuerung an die aufrufende Methode zurückgegeben wird.

• Ein RuleUpdateAction explizites Hinweis darauf, dass eine Regel eine Variable aktualisiert. Dies führt dazu, dass alle betroffenen Regeln erneut ausgewertet werden.