Variablen und Argumente

Artikel
02/27/2011

Dieses Thema gilt für Windows Workflow Foundation 4.

In Windows Workflow Foundation (WF) stellen Variablen den Speicher von Daten dar, während Argumente den Datenstrom in und aus einer Aktivität bilden. Eine Aktivität verfügt über einen Satz von Argumenten, die die Signatur der Aktivität ausmachen. Darüber hinaus kann eine Aktivität eine Liste von Variablen verwalten. Ein Entwickler kann während des Entwurfs eines Workflows Variablen zu dieser Liste hinzufügen oder daraus löschen. Ein Argument wird mit einem Ausdruck gebunden, der einen Wert zurückgibt.

Variablen

Variablen sind Speicherorte für Daten. Variablen werden als Teil der Definition eines Workflows deklariert. Variablen nehmen zur Laufzeit Werte an, die dann als Teil des Zustands einer Workflowinstanz gespeichert werden. Eine Variablendefinition gibt den Typ der Variable und optional auch ihren Namen an. Im folgenden Code wird gezeigt, wie eine Variable deklariert und ihr mit einer Assign-Aktivität ein Wert zugewiesen wird und wie der Wert mithilfe einer WriteLine-Aktivität in der Konsole 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 über Modifizierer verfügen. Wenn z. B. eine Variable schreibgeschützt ist, kann der VariableModifiers-Schreibschutmodifizierer angewendet werden. Im folgenden Beispiel wird eine schreibgeschützte Variable erstellt, die über einen Standardwert verfügt.

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

Variablengültigkeit

Die Lebensdauer einer Variable zur Laufzeit entspricht der Lebensdauer der Aktivität, von der die Variable deklariert wird. Wenn eine Aktivität abgeschlossen wird, werden ihre Variablen bereinigt, und es kann nicht mehr darauf verwiesen werden.

Argumente

Aktivitätsautoren definieren die Datenflüsse in und aus einer Aktivität mithilfe von Argumenten. Jedes Argument verfügt über eine angegebene Richtung: In, Out oder InOut.

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

Wenn die Ausführung einer Aktivität beginnt, werden die Werte aller Eingabeargumente und Eingabe-/Ausgabeargumente berechnet. Beispielsweise entspricht unabhängig davon, wann Get aufgerufen wird, der zurückgegebene Wert dem Wert, der vor dem Aufruf von Execute von der Laufzeit berechnet wurde.
Wenn Set aufgerufen wird, legt die Laufzeit den Wert sofort fest.
Für Argumente kann optional der zugehörige 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 und entspricht dem UnspecifiedEvaluationOrder-Wert. Legen Sie für EvaluationOrder einen Wert größer oder gleich 0 fest, um eine Auswertungsreihenfolge für dieses Argument anzugeben. Windows Workflow Foundation wertet Argumente in einer bestimmten Auswertungsreihenfolge in aufsteigender Richtung aus. Beachten Sie, dass Argumente mit einer nicht angegebenen Auswertungsreihenfolge vor Argumenten 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, OutArgument und InOutArgument deklariert. Auf diese Weise kann ein Aktivitätsautor einen bestimmten Vertrag für die ein- und ausgehenden Daten einer Aktivität einrichten.

Definieren der Argumente einer Aktivität

Argumente können für eine Aktivität definiert werden, indem Eigenschaften vom Typ InArgument, OutArgument und InOutArgument angegeben werden. Im folgenden Code wird gezeigt, wie die Argumente für eine Prompt-Aktivität definiert werden, die eine Zeichenfolge akzeptiert und Benutzer anzeigt 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, NativeActivity oder CodeActivity abgeleitet werden. Diese Aktivitäten verfügen über ein klar definiertes OutArgument-Objekt mit dem Namen Result, das den Rückgabewert der Aktivität enthält.

Verwenden von Variablen und Argumenten in Workflows

Im folgenden Beispiel wird gezeigt, wie Variablen und Argumente in einem Workflow verwendet werden. Der Workflow ist eine Sequenz, die drei Variablen deklariert: var1, var2 und var3. Die erste Aktivität im Workflow ist eine Assign-Aktivität, die den Wert der var2-Variable dem Wert der var1-Variable zuweist. Darauf folgt eine WriteLine-Aktivität, die den Wert der var2-Variable druckt. Als Nächstes kommt eine andere Assign-Aktivität, die dem Wert der var3-Variable den Wert der var2-Variable zuweist. Schließlich folgt eine weitere WriteLine-Aktivität, die den Wert der var3-Variable druckt. Die erste Assign-Aktivität verwendet InArgument<string>-Objekte und OutArgument<string>-Objekte, die die Bindungen für die Argumente der Aktivität explizit darstellen. InArgument<string> wird für Value verwendet, da der Wert durch das Value-Argument in die Assign-Aktivität weitergegeben wird, und OutArgument<string> wird für To verwendet, da der Wert aus dem To-Argument in die Variable übertragen wird. 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 ebenfalls 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 codebasierten 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. Vom Konzept her ist die Verwendung sehr ähnlich. Variablen stellen Datenspeicher innerhalb der Aktivität dar, und Argumente bezeichnen den Datenstrom in oder aus der Aktivität. Sie werden vom Workflowautor an andere Variablen oder Argumente im Workflow gebunden, die Ursprung und Ziel des Datenstroms darstellen. Um den Wert einer Variable 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. Er wird von der Workflowlaufzeit in die Execute-Methode der Aktivität übergeben. In diesem Beispiel wird eine benutzerdefinierte Add-Aktivität definiert, die über zwei In-Argumente verfügt. Mit der Get-Methode wird auf den Wert der Argumente zugegriffen. Es wird der Kontext verwendet, der von der Workflowlaufzeit übergeben wurde.

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 über Arbeiten mit Argumenten, Variablen und Ausdrücken in Code finden Sie unter Erstellen von Workflows mit imperativem Code und Erforderliche Argumente und Überladungsgruppen.

Share via