RuleAction Classe

Definição

public ref class RuleAction abstract

[System.Serializable]
public abstract class RuleAction

[<System.Serializable>]
type RuleAction = class

Public MustInherit Class RuleAction

Herança

Object

RuleAction

Derivado

System.Workflow.Activities.Rules.RuleHaltAction

System.Workflow.Activities.Rules.RuleStatementAction

System.Workflow.Activities.Rules.RuleUpdateAction

Atributos

SerializableAttribute

Exemplos

O código seguinte cria uma ação que pode ser usada em conjuntos de regras. A ação chama-se Log, e toma um único parâmetro, que deve avaliar para uma cadeia. Esta ação envia a cadeia para a Consola.

Para usar este código, adicione-o a um projeto de Biblioteca de Classes e faça referência à biblioteca do seu projeto de fluxo de trabalho.

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

Observações

RuleStatementAction Objetos (que podem ser usados tanto ThenActions como ) ElseActionsnormalmente definem um valor variável numa das propriedades da atividade, chamam um método da atividade, ou chamam métodos estáticos em tipos em assemblies referenciados.

RuleAction é o tipo base do qual RuleStatementActionderivam , RuleHaltAction, e RuleUpdateAction as classes. As utilizações destas classes são as seguintes:

• A RuleStatementAction modifica uma propriedade ou chama um método.

• A RuleHaltAction faz com que o RuleSet pare de executar e devolve o controlo ao método que chama.

• A RuleUpdateAction indica explicitamente que uma regra está a atualizar uma variável. Isto leva à reavaliação de quaisquer regras afetadas.