Variáveis e argumentos
No Windows Workflow Foundation (WF), as variáveis representam o armazenamento de dados e os argumentos representam o fluxo de entrada e saída de dados de uma atividade. Uma atividade tem um conjunto de argumentos e eles compõem a assinatura da atividade. Além disso, uma atividade pode manter uma lista de variáveis às quais um desenvolvedor pode adicionar ou remover variáveis durante o design de um fluxo de trabalho. Um argumento é vinculado usando uma expressão que retorna um valor.
Variáveis
As variáveis são locais de armazenamento de dados. As variáveis são declaradas como parte da definição de um fluxo de trabalho. As variáveis assumem valores em tempo de execução e esses valores são armazenados como parte do estado de uma instância de fluxo de trabalho. Uma definição de variável especifica o tipo da variável e, opcionalmente, o nome. O código a seguir mostra como declarar uma variável, atribuir um valor a ela usando uma Assign<T> atividade e, em seguida, exibir seu valor para o console usando uma WriteLine atividade.
// 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);
Uma expressão de valor padrão pode opcionalmente ser especificada como parte de uma declaração de variável. As variáveis também podem ter modificadores. Por exemplo, se uma variável for somente leitura, o modificador somente VariableModifiers leitura poderá ser aplicado. No exemplo a seguir, é criada uma variável somente leitura que tem um valor padrão atribuído.
// Define a read-only variable with a default value.
Variable<string> var = new Variable<string>
{
Default = "Hello World.",
Modifiers = VariableModifiers.ReadOnly
};
Escopo variável
O tempo de vida de uma variável em tempo de execução é igual ao tempo de vida da atividade que a declara. Quando uma atividade é concluída, suas variáveis são limpas e não podem mais ser referenciadas.
Argumentos
Os autores da atividade usam argumentos para definir a maneira como os dados entram e saem de uma atividade. Cada argumento tem uma direção especificada: In, Out, ou InOut.
O tempo de execução do fluxo de trabalho faz as seguintes garantias sobre o tempo de movimentação de dados para dentro e para fora das atividades:
Quando uma atividade começa a ser executada, os valores de todos os seus argumentos de entrada e entrada/saída são calculados. Por exemplo, independentemente de quando Get é chamado, o valor retornado é aquele calculado pelo tempo de execução antes de sua invocação de
Execute.Quando Set é chamado, o tempo de execução define o valor imediatamente.
Opcionalmente, os EvaluationOrder argumentos podem ser especificados. EvaluationOrder é um valor baseado em zero que especifica a ordem na qual o argumento é avaliado. Por padrão, a ordem de avaliação do argumento não é especificada e é igual ao UnspecifiedEvaluationOrder valor. Defina EvaluationOrder como um valor maior ou igual a zero para especificar uma ordem de avaliação para este argumento. O Windows Workflow Foundation avalia argumentos com uma ordem de avaliação especificada em ordem crescente. Observe que os argumentos com uma ordem de avaliação não especificada são avaliados antes daqueles com uma ordem de avaliação especificada.
Um autor de atividade pode usar um mecanismo fortemente tipado para expor seus argumentos. Isso é feito declarando propriedades do tipo InArgument<T>, OutArgument<T>e InOutArgument<T>. Isso permite que um autor de atividade estabeleça um contrato específico sobre os dados que entram e saem de uma atividade.
Definindo os argumentos em uma atividade
Os argumentos podem ser definidos em uma atividade especificando propriedades do tipo InArgument<T>, OutArgument<T>e InOutArgument<T>. O código a seguir mostra como definir os argumentos para uma Prompt atividade que usa uma cadeia de caracteres para exibir ao usuário e retorna uma cadeia de caracteres que contém a resposta do usuário.
public class Prompt : Activity
{
public InArgument<string> Text { get; set; }
public OutArgument<string> Response { get; set; }
// Rest of activity definition omitted.
}
Nota
As atividades que retornam um único valor podem derivar de Activity<TResult>, NativeActivity<TResult>ou CodeActivity<TResult>. Essas atividades têm um nome Result bem definido OutArgument<T> que contém o valor de retorno da atividade.
Usando variáveis e argumentos em fluxos de trabalho
O exemplo a seguir mostra como variáveis e argumentos são usados em um fluxo de trabalho. O fluxo de trabalho é uma sequência que declara três variáveis: var1, var2e var3. A primeira atividade no fluxo de trabalho é uma Assign atividade que atribui o valor da variável var1 à variável var2. Isso é seguido por uma WriteLine atividade que imprime var2 o valor da variável. Em seguida, está outra Assign atividade que atribui o valor da variável var2 à variável var3. Finalmente, há outra WriteLine atividade que imprime o valor da var3 variável. A primeira Assign atividade usa InArgument<string> e OutArgument<string> objetos que representam explicitamente as ligações para os argumentos da atividade. InArgument<string> é usado para Value porque o valor está fluindo para a atividade através de Assign<T> seu Value argumento, e OutArgument<string> é usado para To porque o valor está fluindo do To argumento para a variável. A segunda Assign atividade realiza a mesma coisa com sintaxe mais compacta, mas equivalente, que usa moldes implícitos. As WriteLine atividades também usam a sintaxe 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);
Usando variáveis e argumentos em atividades baseadas em código
Os exemplos anteriores mostram como usar argumentos e variáveis em fluxos de trabalho e atividades declarativas. Argumentos e variáveis também são usados em atividades baseadas em código. Conceitualmente o uso é muito semelhante. As variáveis representam o armazenamento de dados dentro da atividade e os argumentos representam o fluxo de dados para dentro ou para fora da atividade e são vinculados pelo autor do fluxo de trabalho a outras variáveis ou argumentos no fluxo de trabalho que representam para onde os dados fluem para ou de. Para obter ou definir o valor de uma variável ou argumento em uma atividade, deve ser usado um contexto de atividade que represente o ambiente de execução atual da atividade. Isso é passado para o Execute método da atividade pelo tempo de execução do fluxo de trabalho. Neste exemplo, é definida uma atividade personalizada Add que tem dois In argumentos. Para acessar o valor dos argumentos, o Get método é usado e o contexto que foi passado pelo tempo de execução do fluxo de trabalho é usado.
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 obter mais informações sobre como trabalhar com argumentos, variáveis e expressões no código, consulte Criação de fluxos de trabalho, atividades e expressões usando código imperativo e Argumentos necessários e grupos de sobrecarga.
