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 a seguir cria uma ação que pode ser usada em conjuntos de regras. A ação é nomeada Loge usa um único parâmetro, que deve ser avaliado como uma cadeia de caracteres. Essa ação gera a cadeia de caracteres para o Console.

Para usar esse código, adicione-o a um projeto da 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();
        }
    }
}

Comentários

RuleStatementAction objetos (que podem ser usados como ambos ThenActions e ElseActions) normalmente definem um valor variável em uma 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 RuleStatementAction, RuleHaltActione RuleUpdateAction as classes derivam. Os usos dessas classes são os seguintes:

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

• Causa RuleHaltAction a interrupção da execução e retorna o RuleSet controle para o método de chamada.

• Uma RuleUpdateAction indica explicitamente que uma regra está atualizando uma variável. Isso causa a reavaliação de todas as regras afetadas.