RuleAction Classe

Definizione

public ref class RuleAction abstract

[System.Serializable]
public abstract class RuleAction

[<System.Serializable>]
type RuleAction = class

Public MustInherit Class RuleAction

Ereditarietà

Object

RuleAction

Derivato

System.Workflow.Activities.Rules.RuleHaltAction

System.Workflow.Activities.Rules.RuleStatementAction

System.Workflow.Activities.Rules.RuleUpdateAction

Attributi

SerializableAttribute

Esempio

Il codice seguente crea un'azione che può essere usata nei set di regole. L'azione è denominata Loge accetta un singolo parametro, che deve restituire una stringa. Questa azione restituisce la stringa nella console.

Per usare questo codice, aggiungerlo a un progetto libreria di classi e fare riferimento alla libreria dal progetto del flusso di lavoro.

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

Commenti

RuleStatementAction gli oggetti (che possono essere usati sia come ThenActions e ElseActions) in genere impostano un valore di variabile su una delle proprietà dell'attività, chiamano un metodo dell'attività o chiamano metodi statici sui tipi negli assembly a cui si fa riferimento.

RuleAction è il tipo di base da cui RuleStatementActionderivano le classi , RuleHaltActione RuleUpdateAction . Gli usi di queste classi sono i seguenti:

• Un RuleStatementAction oggetto modifica una proprietà o chiama un metodo .

• Un RuleHaltAction fa sì che l'oggetto arresti l'esecuzione RuleSet e restituisca il controllo al metodo chiamante.

• Un RuleUpdateAction valore indica in modo esplicito che una regola sta aggiornando una variabile. Ciò determina la rivalutazione delle regole interessate.