RuleAction Classe

Definizione

Spazio dei nomi:

System.Workflow.Activities.Rules

Assembly:

System.Workflow.Activities.dll

Rappresenta una classe astratta che definisce un'azione da eseguire se la classe Condition associata restituisce true, per ThenActions o false, per ElseActions. La classe deve essere ereditata.

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 utilizzata nei set di regole. L'azione è denominata Log e prende un solo parametro che deve restituire una stringa. Questa azione restituisce la stringa alla console.

Per utilizzare questo codice, aggiungerlo a un progetto Libreria di classi e fare riferimento alla libreria dal progetto 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

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

La classe RuleAction è il tipo base da cui derivano RuleStatementAction, RuleHaltAction, e RuleUpdateAction. Gli utilizzi di queste classi sono i seguenti:

• Una classe RuleStatementAction modifica una proprietà o chiama un metodo.

• La classe RuleHaltAction fa sì che la classe RuleSet interrompa l'esecuzione e restituisca il controllo al metodo di chiamata.

• Una classe RuleUpdateAction indica in modo esplicito che una regola sta aggiornando una variabile. Provoca la rivalutazione di qualsiasi regola modificata.

Costruttori

RuleAction()

Quando viene implementato in una classe derivata, inizializza una nuova istanza della classe RuleAction.

Metodi

Clone()	Crea una copia completa dell'oggetto corrente della classe RuleAction.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Execute(RuleExecution)	Esegue la classe RuleAction utilizzando l'istanza RuleExecution specificata.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetSideEffects(RuleValidation)	Restituisce le proprietà e i campi aggiornati da una classe RuleAction.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Validate(RuleValidation)	Verifica che l'oggetto della classe RuleAction è configurato correttamente ed è privo di errori.