Variáveis e argumentos

2025-06-19

No Windows Workflow Foundation (WF), as variáveis representam o armazenamento de dados e argumentos representam o fluxo de dados dentro e fora 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 é associado usando uma expressão que retorna um valor.

Variáveis

Variáveis são locais de armazenamento para 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);

Opcionalmente, uma expressão de valor padrão pode 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 VariableModifiers de somente 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 de atividades usam argumentos para definir a maneira como os dados fluem para dentro e para fora de uma atividade. Cada argumento tem uma direção especificada: In, Outou InOut.

O tempo de execução do fluxo de trabalho faz as seguintes garantias sobre o momento 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 argumentos de entrada e entrada/saída são calculados. Por exemplo, independentemente de quando Get for chamado, o valor retornado é aquele calculado pelo runtime antes de sua invocação de Execute.
Quando Set é chamado, o runtime define o valor imediatamente.
Opcionalmente, os argumentos podem ter seu EvaluationOrder especificado. 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 esse 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 as 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 a ser exibida para o 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.  
}

Observação

As atividades que retornam um único valor podem derivar de Activity<TResult>, NativeActivity<TResult>ou CodeActivity<TResult>. Essas atividades têm OutArgument<T> bem definido chamado Result 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 o valor da var2 variável. Em seguida, há outra Assign atividade que atribui o valor da variável var2 à variável var3. Por fim, 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 associações para os argumentos da atividade. InArgument<string> é usado para Value porque o valor está fluindo para a atividade Assign<T> através de seu argumento Value. Já OutArgument<string> é usado para To porque o valor está fluindo para fora do argumento To e entrando na variável. A segunda atividade de Assign realiza a mesma coisa com mais sintaxe compacta mas equivalente que usa conversões implícitas. 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 de Code-Based

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 associados pelo autor do fluxo de trabalho a outras variáveis ou argumentos no fluxo de trabalho que representam para onde os dados fluem de ou para. Para obter ou definir o valor de uma variável ou argumento em uma atividade, um contexto de atividade deve ser usado que represente o ambiente de execução atual da atividade. Isso é passado para o método de Execute de atividade em runtime de fluxo de trabalho. Neste exemplo, uma atividade personalizada Add é definida que tem dois In argumentos. Para acessar o valor dos argumentos, o Get método é usado e o contexto passado pelo runtime 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 Criar fluxos de trabalho, atividades e expressões usando código imperativo e argumentos necessários e grupos de sobrecarga.

Compartilhar via