RuleAction Clase

Definición

Espacio de nombres:

System.Workflow.Activities.Rules

Ensamblado:

System.Workflow.Activities.dll

Representa una clase abstracta que define una acción que será ejecutada si el Condition asociado se evalúa como true, para ThenActions, o false, para ElseActions. Se debe heredar esta clase.

public ref class RuleAction abstract

[System.Serializable]
public abstract class RuleAction

[<System.Serializable>]
type RuleAction = class

Public MustInherit Class RuleAction

Herencia

Object

RuleAction

Derivado

System.Workflow.Activities.Rules.RuleHaltAction

System.Workflow.Activities.Rules.RuleStatementAction

System.Workflow.Activities.Rules.RuleUpdateAction

Atributos

SerializableAttribute

Ejemplos

El código siguiente crea una acción que se puede utilizar en conjuntos de reglas. La acción se denomina Log y toma un parámetro único, que se debe evaluar como una cadena. Esta acción envía la cadena a la consola.

Para utilizar este código, agréguelo a un proyecto de biblioteca de clases y luego haga referencia a la biblioteca desde su proyecto de flujo de trabajo.

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

Comentarios

Los objetos RuleStatementAction (que pueden usarse como ThenActions y ElseActions) normalmente establecen un valor variable en una de las propiedades de la actividad, llaman a un método de la actividad, o llaman a métodos estáticos en tipos de ensamblados a los que se ha hecho referencia.

RuleAction es el tipo base del que se derivan las clases RuleStatementAction, RuleHaltAction, y RuleUpdateAction. Estas clases se utilizan de la siguiente manera:

• Un RuleStatementAction modifica una propiedad o llama a un método.

• Un RuleHaltAction detiene la ejecución de RuleSet y devuelve el control al método de llamada.

• Un RuleUpdateAction indica explícitamente que una regla está actualizando una variable. Esto hace que se evalúen de nuevo las reglas afectadas.

Constructores

RuleAction()

Cuando se implementa en una clase derivada, inicializa una instancia nueva de la clase RuleAction.

Métodos

Clone()	Crea una copia en profundidad del RuleAction en curso.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Execute(RuleExecution)	Ejecuta RuleAction mediante la instancia RuleExecution especificada.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetSideEffects(RuleValidation)	Devuelve los campos y propiedades actualizados por RuleAction.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
Validate(RuleValidation)	Comprueba que el RuleAction está correctamente configurado y que no tiene errores.