Variablen und Argumente

In Windows Workflow Foundation (WF) stellen Variablen die Speicherung von Daten und Argumenten dar, die den Datenfluss in und aus einer Aktivität darstellen. Eine Aktivität hat eine Reihe von Argumenten und bilden die Signatur der Aktivität. Darüber hinaus kann eine Aktivität eine Liste von Variablen verwalten, der ein Entwickler Während des Entwurfs eines Workflows Variablen hinzufügen oder entfernen kann. Ein Argument wird mithilfe eines Ausdrucks gebunden, der einen Wert zurückgibt.

Variablen

Variablen sind Speicherorte für Daten. Variablen werden als Teil der Definition eines Workflows deklariert. Variablen übernehmen Werte zur Laufzeit, und diese Werte werden als Teil des Zustands einer Workflowinstanz gespeichert. Eine Variabledefinition gibt den Typ der Variablen und optional den Namen an. Im folgenden Code wird gezeigt, wie eine Variable deklariert, ihm mithilfe einer Aktivität ein Assign<T> Wert zugewiesen und anschließend der Konsole mithilfe einer WriteLine Aktivität ein Wert angezeigt wird.

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

Ein Standardwertausdruck kann optional als Teil einer Variablendeklaration angegeben werden. Variablen können auch Modifizierer haben. Wenn beispielsweise eine Variable schreibgeschützt ist, kann der schreibgeschützte VariableModifiers Modifikator angewendet werden. Im folgenden Beispiel wird eine schreibgeschützte Variable erstellt, der ein Standardwert zugewiesen ist.

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

Variablenumfang

Die Lebensdauer einer Variablen zur Laufzeit entspricht der Lebensdauer der Aktivität, die sie deklariert. Wenn eine Aktivität abgeschlossen ist, werden die Variablen bereinigt und können nicht mehr referenziert werden.

Argumente

Aktivitätsautoren verwenden Argumente, um die Art und Weise zu definieren, wie Daten in und aus einer Aktivität fließen. Jedes Argument weist eine angegebene Richtung auf: In, , Out, oder InOut.

Die Workflowlaufzeit gewährleistet folgende Aktionen hinsichtlich der zeitlichen Steuerung der Datenverschiebung in und aus Aktivitäten:

1. Wenn eine Aktivität mit der Ausführung beginnt, werden die Werte aller Eingabe- und Eingabe-/Ausgabeargumente berechnet. Unabhängig davon, wann Get aufgerufen wird, ist der zurückgegebene Wert derjenige, der von der Laufzeit bereits vor dem Aufruf von Execute berechnet wurde.

2. Beim Set Aufrufen legt die Laufzeit den Wert sofort fest.

3. Für Argumente kann optional EvaluationOrder angegeben werden. EvaluationOrder ist ein nullbasierter Wert, der die Reihenfolge angibt, in der das Argument ausgewertet wird. Standardmäßig ist die Auswertungsreihenfolge des Arguments nicht angegeben und gleich dem UnspecifiedEvaluationOrder Wert. Legen Sie EvaluationOrder einen Wert fest, der größer oder gleich Null ist, um eine Auswertungsreihenfolge für dieses Argument anzugeben. Windows Workflow Foundation wertet Argumente mit einer angegebenen Auswertungsreihenfolge in aufsteigender Reihenfolge aus. Beachten Sie, dass Argumente mit einer nicht angegebenen Auswertungsreihenfolge vor denen mit einer angegebenen Auswertungsreihenfolge ausgewertet werden.

Ein Aktivitätsautor kann einen stark typisierten Mechanismus zur Bereitstellung seiner Argumente verwenden. Dazu werden Eigenschaften von Typ InArgument<T>, OutArgument<T> und InOutArgument<T> deklariert. Auf diese Weise kann ein Aktivitätsautor einen bestimmten Vertrag über die Daten festlegen, die in eine Aktivität eingehen und aus ihr herausgehen.

Definieren der Argumente für eine Aktivität

Argumente können für eine Aktivität definiert werden, indem Eigenschaften vom Typ InArgument<T>, OutArgument<T> und InOutArgument<T> angegeben werden. Der folgende Code zeigt, wie die Argumente für eine Prompt Aktivität definiert werden, die eine Zeichenfolge entgegennimmt, um sie dem Benutzer anzuzeigen, und eine Zeichenfolge zurückgibt, die die Antwort des Benutzers enthält.

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

Hinweis

Aktivitäten, die einen einzelnen Wert zurückgeben, können von Activity<TResult>, NativeActivity<TResult> oder CodeActivity<TResult> abgeleitet werden. Diese Aktivitäten verfügen über ein klar definiertes OutArgument<T>-Objekt mit dem Namen Result, das den Rückgabewert der Aktivität enthält.

Verwenden von Variablen und Argumenten in Workflows

Das folgende Beispiel zeigt, wie Variablen und Argumente in einem Workflow verwendet werden. Der Workflow ist eine Sequenz, die drei Variablen deklariert: var1, , var2und var3. Die erste Aktivität im Workflow ist eine Assign Aktivität, die den Wert der Variablen var1 der Variablen var2 zuweist. Dies folgt einer WriteLine Aktivität, die den Wert der var2 Variablen druckt. Als Nächstes folgt eine weitere Aktivität Assign, die den Wert der Variablen var2 der Variablen var3 zuweist. Schließlich gibt es eine weitere WriteLine Aktivität, die den Wert der var3 Variablen druckt. Die erste Assign Aktivität verwendet InArgument<string> und OutArgument<string> Objekte, die explizit die Bindungen für die Argumente der Aktivität darstellen. InArgument<string> wird für Value verwendet, weil der Wert über sein Assign<T>-Argument in die Value-Aktivität fließt, und OutArgument<string> wird für To verwendet, weil der Wert aus dem To-Argument in die Variable fließt. Die zweite Assign-Aktivität erreicht dasselbe Ziel mit einer kompakteren Syntax, die ansonsten äquivalent ist und implizite Umwandlungen verwendet. Die WriteLine Aktivitäten verwenden auch die kompakte Syntax.

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

Verwenden von Variablen und Argumenten in Code-Based Aktivitäten

In den vorherigen Beispielen wird gezeigt, wie Argumente und Variablen in Workflows und deklarativen Aktivitäten verwendet werden. Argumente und Variablen werden auch in codebasierten Aktivitäten verwendet. Konzeptionell ist die Verwendung sehr ähnlich. Variablen stellen die Datenspeicherung innerhalb der Aktivität dar, und Argumente stellen den Datenfluss in oder aus der Aktivität dar und sind vom Workflowautor an andere Variablen oder Argumente im Workflow gebunden, die den Datenfluss in oder aus dem Workflow darstellen. Um den Wert einer Variablen oder eines Arguments in einer Aktivität abzurufen oder festzulegen, muss ein Aktivitätskontext verwendet werden, der die aktuelle Ausführungsumgebung der Aktivität darstellt. Dies wird von der Workflow-Runtime an die Execute Methode der Aktivität übergeben. In diesem Beispiel wird eine benutzerdefinierte Add Aktivität mit zwei In Argumenten definiert. Um auf den Wert der Argumente zuzugreifen, wird die Get Methode verwendet, und der Kontext, der von der Workflowlaufzeit übergeben wurde, wird verwendet.

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

Weitere Informationen zum Arbeiten mit Argumenten, Variablen und Ausdrücken im Code finden Sie unter Erstellen von Workflows, Aktivitäten und Ausdrücken mit imperativem Code und erforderlichen Argumenten und Überladungsgruppen.