Variabili e argomenti

In Windows Workflow Foundation (WF), le variabili rappresentano l'archiviazione dei dati e degli argomenti rappresentano il flusso di dati all'interno e all'esterno di un'attività. Un'attività ha un insieme di argomenti che costituiscono la firma dell'attività. Inoltre, un'attività può mantenere un elenco di variabili a cui uno sviluppatore può aggiungere o rimuovere variabili durante la progettazione di un flusso di lavoro. Un argomento viene associato usando un'espressione che restituisce un valore.

Variabili

Le variabili sono posizioni di archiviazione per i dati. Le variabili vengono dichiarate come parte della definizione di un flusso di lavoro. Le variabili accettano valori in fase di esecuzione e questi valori vengono archiviati come parte dello stato di un'istanza del flusso di lavoro. Una definizione di variabile specifica il tipo della variabile e, facoltativamente, il nome. Nel codice seguente viene illustrato come dichiarare una variabile, assegnare un valore usando un'attività Assign<T> e quindi visualizzarne il valore nella console usando un'attività 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);

Un'espressione di valore predefinita può essere specificata facoltativamente come parte di una dichiarazione di variabile. Le variabili possono anche avere modificatori. Ad esempio, se una variabile è di sola lettura, è possibile applicare il modificatore di sola VariableModifiers lettura. Nell'esempio seguente viene creata una variabile di sola lettura con un valore predefinito assegnato.

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

Definizione dell'ambito della variabile

La durata di una variabile in fase di esecuzione è uguale alla durata dell'attività che la dichiara. Al termine di un'attività, le relative variabili vengono eliminate e non possono più essere referenziate.

Argomenti

Gli autori di attività usano argomenti per definire il modo in cui i dati vengono trasmessi da e verso un'attività. Ogni argomento ha una direzione specificata: In, Outo InOut.

Il runtime del flusso di lavoro garantisce le garanzie seguenti sulla tempistica dello spostamento dei dati all'interno e all'esterno delle attività:

1. Quando un'attività inizia l'esecuzione, vengono calcolati i valori di tutti gli argomenti di input e input/output. Ad esempio, indipendentemente da quando Get viene chiamato, il valore restituito è quello calcolato dal runtime prima della chiamata di Execute.

2. Quando Set viene chiamato, il runtime imposta immediatamente il valore.

3. Facoltativamente, gli argomenti possono specificare EvaluationOrder . EvaluationOrder è un valore in base zero che specifica l'ordine in cui viene valutato l'argomento. Per impostazione predefinita, l'ordine di valutazione dell'argomento non è specificato ed è uguale al UnspecifiedEvaluationOrder valore . Impostare EvaluationOrder su un valore maggiore o uguale a zero per specificare un ordine di valutazione per questo argomento. Windows Workflow Foundation valuta gli argomenti con un ordine di valutazione specificato in ordine crescente. Si noti che gli argomenti con un ordine di valutazione non specificato vengono valutati prima di quelli con un ordine di valutazione specificato.

Un autore di attività può usare un meccanismo fortemente tipizzato per esporre i propri argomenti. Questa operazione viene eseguita dichiarando le proprietà di tipo InArgument<T>, OutArgument<T>e InOutArgument<T>. Ciò consente a un autore di attività di stabilire un contratto specifico sui dati in entrata e in uscita da un'attività.

Definizione degli argomenti in un'attività

Gli argomenti possono essere definiti in un'attività specificando proprietà di tipo InArgument<T>, OutArgument<T>e InOutArgument<T>. Il codice seguente illustra come definire gli argomenti per un'attività Prompt che accetta una stringa da visualizzare all'utente e restituisce una stringa contenente la risposta dell'utente.

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

Annotazioni

Le attività che restituiscono un singolo valore possono derivare da Activity<TResult>, NativeActivity<TResult>o CodeActivity<TResult>. Queste attività hanno un `OutArgument<T>` ben definito chiamato `Result` che contiene il valore restituito dell'attività.

Uso di variabili e argomenti nei flussi di lavoro

Nell'esempio seguente viene illustrato come vengono usate variabili e argomenti in un flusso di lavoro. Il flusso di lavoro è una sequenza che dichiara tre variabili: var1, var2e var3. La prima attività nel flusso di lavoro è un'attività Assign che assegna il valore della variabile var1 alla variabile var2. Questo è seguito da un'attività WriteLine che stampa il valore della var2 variabile. Successivamente è un'altra Assign attività che assegna il valore della variabile var2 alla variabile var3. Infine è presente un'altra WriteLine attività che stampa il valore della var3 variabile. La prima Assign attività utilizza oggetti InArgument<string> e OutArgument<string> che rappresentano in modo esplicito le associazioni per gli argomenti dell'attività. InArgument<string> viene usato al Value perché il valore sta fluendo nell'attività attraverso il suo argomento Assign<T>, e Value viene usato al OutArgument<string> perché il valore sta fluendo fuori dall'argomento To nella variabile. La seconda Assign attività esegue la stessa operazione con una sintassi più compatta ma equivalente che usa cast impliciti. Le WriteLine attività usano anche la sintassi compatta.

// 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 di variabili e argomenti nelle attività di Code-Based

Negli esempi precedenti viene illustrato come usare argomenti e variabili nei flussi di lavoro e nelle attività dichiarative. Gli argomenti e le variabili vengono usati anche nelle attività basate su codice. Concettualmente, l'utilizzo è molto simile. Le variabili rappresentano l'archiviazione dei dati all'interno dell'attività e gli argomenti rappresentano il flusso di dati all'interno o all'esterno dell'attività e sono associati dall'autore del flusso di lavoro ad altre variabili o argomenti nel flusso di lavoro che rappresentano la posizione in cui i dati passano da o verso. Per ottenere o impostare il valore di una variabile o di un argomento in un'attività, è necessario usare un contesto di attività che rappresenta l'ambiente di esecuzione corrente dell'attività. Viene passato al Execute metodo dell'attività dal runtime del flusso di lavoro. In questo esempio viene definita un'attività personalizzata Add con due In argomenti. Per accedere al valore degli argomenti, viene usato il Get metodo e viene usato il contesto passato dal runtime del flusso di lavoro.

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);
    }
}

Per altre informazioni sull'uso di argomenti, variabili ed espressioni nel codice, vedere Creazione di flussi di lavoro, attività ed espressioni tramite codice imperativo e argomenti obbligatori e gruppi di overload.