Variables y argumentos
En Windows Workflow Foundation (WF), las variables representan el almacenamiento de datos y los argumentos representan el flujo de datos dentro y fuera de una actividad. Una actividad tiene un conjunto de argumentos y constituyen la firma de la actividad. Además, una actividad puede mantener una lista de variables a las que un desarrollador de software puede agregar o quitar variables durante el diseño de un flujo de trabajo. Los argumentos se enlazan mediante una expresión que devuelve un valor.
Variables
Las variables son las ubicaciones de almacenamiento para los datos. Las variables se declaran como parte de la definición de un flujo de trabajo. Las variables asumen los valores en el tiempo de ejecución y estos valores se almacenan como parte del estado de una instancia de flujo de trabajo. La definición de variable especifica el tipo de la variable y, opcionalmente, el nombre. El siguiente código muestra cómo declarar una variable, asignar un valor a él mediante una actividad Assign<T> y, a continuación, muestra su valor en la consola usando una actividad WriteLine.
// 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);
Como parte de una declaración de variable, se puede especificar de forma opcional una expresión de valor predeterminado. Las variables también pueden tener modificadores. Por ejemplo, si la variable es de solo lectura, se aplicará el modificador de la propiedad VariableModifiers. En el siguiente ejemplo, se crea una variable de solo lectura que tiene un valor predeterminado asignado.
// 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, sus variables se limpian y ya no se puede hacer referencia a ellas.
Argumentos
Los autores de actividad usan argumentos para definir la manera en que los datos fluyen hacia dentro de la actividad y fuera de ella. Cada argumento tiene una dirección especificada: In, Out o InOut.
El tiempo de ejecución del flujo de trabajo garantiza lo siguiente sobre el control de tiempo del movimiento de los datos dentro y fuera de las actividades:
Cuando una actividad empieza a ejecutarse, se calculan los valores de todos sus argumentos de entrada y de entrada/salida. Por ejemplo, independientemente de cuándo se llame a Get, el valor devuelto lo calculará el tiempo de ejecución antes de la invocación de
Execute.Cuando se llama a Set, el tiempo de ejecución establece el valor inmediatamente.
Los argumentos pueden opcionalmente tener especificado su EvaluationOrder. EvaluationOrderes un valor basado en 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 valor de UnspecifiedEvaluationOrder. Para especificar un orden de evaluación para este argumento, establezca la propiedad EvaluationOrder con un valor mayor o igual que cero. Windows Workflow Foundation evalúa argumentos con un orden de evaluación especificado en orden ascendente. Tenga en cuenta que los argumentos que no tienen orden de evaluación especificada se evalúan antes que los que tienen especificado un orden de evaluación.
El autor de una actividad puede usar un mecanismo fuertemente tipado para exponer sus argumentos. Esto se logra declarando propiedades de tipo InArgument<T>, OutArgument<T> y InOutArgument<T>. De esta forma se permite que un autor de actividad establezca un contrato concreto sobre la entrada y salida de datos de una actividad.
Definir argumentos en una actividad
Los argumentos se pueden definir en una actividad al especificar propiedades de tipo InArgument<T>, OutArgument<T> y InOutArgument<T>. El siguiente código muestra cómo definir los argumentos para una actividad Prompt que mostrará una cadena al usuario y devolverá otra con 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.
}
Nota
Las actividades que devuelven un valor único pueden derivar de Activity<TResult>, NativeActivity<TResult> o CodeActivity<TResult>. Estas actividades tienen una clase OutArgument<T> bien definida denominada Result que contiene el valor devuelto de la actividad.
Usar variables y argumentos en flujos de trabajo
El siguiente ejemplo muestra cómo se usan las variables y argumentos en un flujo de trabajo. El flujo de trabajo es una secuencia que declara tres variables: var1, var2 y var3. La primera actividad en el flujo de trabajo es una actividad Assign que asigna el valor de la variable var1 a la variable var2. A esto le sigue una actividad WriteLine que imprime el valor de la variable var2. A continuación, verá otra actividad Assign que asigna el valor de la variable var2 a la variable var3. Finalmente, hay otra actividad WriteLine que imprime el valor de la variable var3. 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 está fluyendo en la actividad Assign<T> a través de su argumento Value y OutArgument<string> se usa para To porque el valor está fluyendo del argumento To hacia la variable. La segunda actividad Assign consigue lo mismo gracias a una sintaxis más compacta, pero equivalente, que usa conversiones implícitas. Las actividades WriteLine 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);
Usar variables y argumentos en actividades basadas en código
En los ejemplos anteriores se muestra cómo usar argumentos y variables en flujos de trabajo y actividades declarativas. Las variables y argumentos también se usan en actividades basadas en código. En lo que se refiere al concepto, el uso es muy similar. Las variables representan el almacenamiento de datos dentro de la actividad, mientras que los argumentos representan el flujo de datos hacia dentro o fuera de la actividad. Ambos están enlazados a otras variables por el autor del flujo de trabajo o argumentos en el flujo de trabajo que representan el lugar hacia donde fluyen los datos, además de su procedencia. 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 Add personalizada que tiene dos argumentos In. Para tener acceso al valor de los argumentos, se usa el método Get y el contexto que pasó 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 más información sobre cómo trabajar con argumentos, variables y expresiones en el código, consulte Creación de flujos de trabajo, actividades y expresiones mediante código imperativo y Argumentos necesarios y grupos de sobrecarga.
