Compartilhar via

RuleAction Classe

  • Referência

Definição

Namespace:
System.Workflow.Activities.Rules
Assembly:
System.Workflow.Activities.dll

Representa uma classe abstrata que define uma ação a ser executada se a Condition associada é avaliada como true para ThenActions ou como false para ElseActions. Essa classe deve ser herdada.

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
Atributos
SerializableAttribute

Exemplos

O código a seguir cria uma ação que pode ser usada em conjuntos de regras. A ação é nomeada Log e 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 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();  
        }  
    }  
}

Comentários

RuleStatementAction os objetos (que podem ser usados como ThenActions e ElseActions ) normalmente definem um valor de 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 RuleStatementAction do qual RuleHaltAction RuleUpdateAction derivam classes. Os usos dessas classes são os seguintes:

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

  • Um RuleHaltAction faz com que o RuleSet pare de executar e retorne o controle para o método de chamada.

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

Construtores

RuleAction()

Quando implementado em uma classe derivada, inicializa uma nova instância da classe RuleAction.

Métodos

Clone()

Cria uma cópia em profundidade do RuleAction atual.
Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
Execute(RuleExecution)

Executa o RuleAction usando a instância de RuleExecution especificada.
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetSideEffects(RuleValidation)

Retorna os campos e propriedades atualizadas por um RuleAction.
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
Validate(RuleValidation)

Verifica se o RuleAction está configurado corretamente e não tem erros.

Aplica-se a