Variables y argumentos

En Windows Workflow Foundation (WF), las variables representan el almacenamiento de datos y argumentos que representan el flujo de datos dentro y fuera de una actividad. Una actividad tiene un conjunto de argumentos, y estos forman la firma de la actividad. Además, una actividad puede mantener una lista de variables a las que un desarrollador puede agregar o quitar variables durante el diseño de un flujo de trabajo. Un argumento se enlaza mediante una expresión que devuelve un valor.

variables

Las variables son ubicaciones de almacenamiento para los datos. Las variables se declaran como parte de la definición de un flujo de trabajo. Las variables toman valores en tiempo de ejecución y estos valores se almacenan como parte del estado de una instancia de flujo de trabajo. Una definición de variable especifica el tipo de la variable y, opcionalmente, el nombre. En el código siguiente se muestra cómo declarar una variable, asignarle un valor mediante una Assign<T> actividad y, a continuación, mostrar su valor en la consola mediante una WriteLine actividad.

// Define a variable named "str" of type string.  
Variable<string> var = new Variable<string>  
{  
    Name = "str"  
};  
  
// Declare the variable within a Sequence, assign  
// a value to it, and then display it.  
Activity wf = new Sequence()  
{  
    Variables = { var },  
    Activities =  
    {  
        new Assign<string>  
        {  
            To = var,  
            Value = "Hello World."  
        },  
        new WriteLine  
        {  
            Text = var  
        }  
    }  
};  
  
WorkflowInvoker.Invoke(wf);  

Opcionalmente, se puede especificar una expresión de valor predeterminada como parte de una declaración de variable. Las variables también pueden tener modificadores. Por ejemplo, si una variable es de solo lectura, se puede aplicar el modificador de solo lectura VariableModifiers . En el ejemplo siguiente, se crea una variable de solo lectura que tiene asignado un valor predeterminado.

// Define a read-only variable with a default value.  
Variable<string> var = new Variable<string>  
{  
    Default = "Hello World.",  
    Modifiers = VariableModifiers.ReadOnly  
};  

Ámbito de variable

La duración de una variable en tiempo de ejecución es igual a la duración de la actividad que la declara. Cuando se completa una actividad, se limpian sus variables y ya no se puede hacer referencia a ellas.

Argumentos

Los autores de actividades usan argumentos para definir la forma en que fluyen los datos hacia y hacia fuera de una actividad. Cada argumento tiene una dirección especificada: In, Outo InOut.

El tiempo de ejecución del flujo de trabajo garantiza las siguientes garantías sobre el tiempo de movimiento de datos dentro y fuera de las actividades:

1. Cuando una actividad comienza a ejecutarse, se calculan los valores de todos sus argumentos de entrada y entrada/salida. Por ejemplo, independientemente de cuándo se llame a Get, el valor devuelto es el calculado por el tiempo de ejecución antes de invocar Execute.

2. Cuando se llama a Set, el tiempo de ejecución establece el valor inmediatamente.

3. Opcionalmente, los argumentos pueden tener su EvaluationOrder especificado. EvaluationOrder es un valor de base cero que especifica el orden en el que se evalúa el argumento. De forma predeterminada, el orden de evaluación del argumento no está especificado y es igual al UnspecifiedEvaluationOrder valor . Establezca EvaluationOrder en un valor mayor o igual a cero para especificar un orden de evaluación para este argumento. Windows Workflow Foundation evalúa los argumentos con un orden de evaluación especificado en orden ascendente. Tenga en cuenta que los argumentos con un orden de evaluación no especificado se evalúan antes de los que tienen un orden de evaluación especificado.

El autor de una actividad puede usar un mecanismo fuertemente tipado para exponer sus argumentos. Esto se logra mediante la declaración de propiedades de tipo InArgument<T>, OutArgument<T>y InOutArgument<T>. Esto permite a un autor de actividad establecer un contrato específico sobre los datos que entran y salen de una actividad.

Definir los argumentos en una actividad

Los argumentos se pueden definir en una actividad especificando propiedades de tipo InArgument<T>, OutArgument<T>y InOutArgument<T>. El código siguiente muestra cómo definir los argumentos de una Prompt actividad que toma una cadena para mostrar al usuario y devuelve una cadena que contiene la respuesta del usuario.

public class Prompt : Activity  
{  
    public InArgument<string> Text { get; set; }  
    public OutArgument<string> Response { get; set; }  
    // Rest of activity definition omitted.  
}  

Uso de variables y argumentos en flujos de trabajo

En el ejemplo siguiente se muestra cómo se usan variables y argumentos en un flujo de trabajo. El flujo de trabajo es una secuencia que declara tres variables: var1, var2y var3. La primera actividad del flujo de trabajo es una Assign actividad que asigna el valor de variable var1 a la variable var2. Esto va seguido de una WriteLine actividad que imprime el valor de la var2 variable. A continuación, se muestra otra Assign actividad que asigna el valor de variable var2 a la variable var3. Por último, hay otra WriteLine actividad que imprime el valor de la var3 variable. La primera actividad Assign usa InArgument<string> y los objetos OutArgument<string> que explícitamente representan los enlaces para los argumentos de la actividad. InArgument<string> se usa para Value porque el valor fluye hacia la Assign<T> actividad a través de su Value argumento y OutArgument<string> se usa para To porque el valor fluye fuera del To argumento en la variable. La segunda actividad Assign consigue lo mismo gracias a una sintaxis más compacta, pero equivalente, que usa conversiones implícitas. Las WriteLine actividades también usan la sintaxis compacta.

// Declare three variables; the first one is given an initial value.  
Variable<string> var1 = new Variable<string>()  
{  
    Default = "one"  
};  
Variable<string> var2 = new Variable<string>();  
Variable<string> var3 = new Variable<string>();  
  
// Define the workflow  
Activity wf = new Sequence  
{  
    Variables = { var1, var2, var3 },  
    Activities =
    {  
        new Assign<string>()  
        {  
            Value = new InArgument<string>(var1),  
            To = new OutArgument<string>(var2)  
        },  
        new WriteLine() { Text = var2 },  
        new Assign<string>()  
        {  
            Value = var2,  
            To = var3  
        },  
        new WriteLine() { Text = var3 }  
    }  
};  
  
WorkflowInvoker.Invoke(wf);  

Uso de variables y argumentos en actividades de Code-Based

En los ejemplos anteriores se muestra cómo usar argumentos y variables en flujos de trabajo y actividades declarativas. Los argumentos y variables también se usan en actividades basadas en código. Conceptualmente, el uso es muy similar. Las variables representan el almacenamiento de datos dentro de la actividad y los argumentos representan el flujo de datos dentro o fuera de la actividad, y están enlazados por el autor del flujo de trabajo a otras variables o argumentos del flujo de trabajo que representan dónde fluyen los datos hacia o desde. Para obtener o establecer el valor de una variable o argumento en una actividad, se debe usar un contexto de actividad que represente el entorno de ejecución actual de la actividad. Será el tiempo de ejecución del flujo de trabajo el que lo pase hacia el método Execute de la actividad. En este ejemplo, se define una actividad personalizada Add que tiene dos In argumentos. Para acceder al valor de los argumentos, se utiliza el método Get junto con el contexto proporcionado por el tiempo de ejecución del flujo de trabajo.

public sealed class Add : CodeActivity<int>  
{  
    [RequiredArgument]  
    public InArgument<int> Operand1 { get; set; }  
  
    [RequiredArgument]  
    public InArgument<int> Operand2 { get; set; }  
  
    protected override int Execute(CodeActivityContext context)  
    {  
        return Operand1.Get(context) + Operand2.Get(context);  
    }  
}  

Para obtener más información sobre cómo trabajar con argumentos, variables y expresiones en el código, vea Creación de flujos de trabajo, actividades y expresiones mediante código imperativo y argumentos obligatorios y grupos de sobrecarga.