Variabelen en argumenten
In Windows Workflow Foundation (WF) vertegenwoordigen variabelen de opslag van gegevens en argumenten de stroom van gegevens naar en uit een activiteit. Een activiteit heeft een set argumenten en vormen de handtekening van de activiteit. Daarnaast kan een activiteit een lijst met variabelen onderhouden waaraan een ontwikkelaar variabelen kan toevoegen of verwijderen tijdens het ontwerpen van een werkstroom. Een argument is afhankelijk van een expressie die een waarde retourneert.
Variabelen
Variabelen zijn opslaglocaties voor gegevens. Variabelen worden gedeclareerd als onderdeel van de definitie van een werkstroom. Variabelen nemen waarden op in runtime en deze waarden worden opgeslagen als onderdeel van de status van een werkstroomexemplaren. Een variabeledefinitie specificeert het type van de variabele en optioneel, de naam. De volgende code laat zien hoe u een variabele declareert, een waarde aan deze variabele toewijst met behulp van een Assign<T> activiteit en vervolgens de waarde ervan weergeeft aan de console met behulp van een WriteLine activiteit.
// 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);
Een standaardwaardeexpressie kan eventueel worden opgegeven als onderdeel van een variabeledeclaratie. Variabelen kunnen ook modifiers hebben. Als een variabele bijvoorbeeld alleen-lezen is, kan de wijziging alleen-lezen VariableModifiers worden toegepast. In het volgende voorbeeld wordt een alleen-lezenvariabele gemaakt waaraan een standaardwaarde is toegewezen.
// Define a read-only variable with a default value.
Variable<string> var = new Variable<string>
{
Default = "Hello World.",
Modifiers = VariableModifiers.ReadOnly
};
Bereik van variabele
De levensduur van een variabele tijdens runtime is gelijk aan de levensduur van de activiteit die deze declareert. Wanneer een activiteit is voltooid, worden de variabelen opgeschoond en kunnen ze niet meer worden verwezen.
Argumenten
Auteurs van activiteiten gebruiken argumenten om de manier te definiëren waarop gegevens van en naar een activiteit stromen. Elk argument heeft een opgegeven richting: In, Outof InOut.
De werkstroomruntime biedt de volgende garanties over de timing van gegevensverplaatsing naar en van activiteiten:
Wanneer een activiteit wordt uitgevoerd, worden de waarden van alle invoer- en invoer-/uitvoerargumenten berekend. Ongeacht wanneer Get wordt aangeroepen, is de geretourneerde waarde bijvoorbeeld de waarde die wordt berekend door de runtime vóór de aanroep van
Execute.Wanneer Set deze wordt aangeroepen, stelt de runtime de waarde onmiddellijk in.
Argumenten kunnen desgewenst hun EvaluationOrder opgegeven hebben. EvaluationOrder is een op nul gebaseerde waarde die de volgorde aangeeft waarin het argument wordt geëvalueerd. De evaluatievolgorde van het argument is standaard niet opgegeven en is gelijk aan de UnspecifiedEvaluationOrder waarde. Stel EvaluationOrder deze waarde in op een waarde die groter of gelijk is aan nul om een evaluatievolgorde voor dit argument op te geven. Windows Workflow Foundation evalueert argumenten met een opgegeven evaluatievolgorde in oplopende volgorde. Houd er rekening mee dat argumenten met een niet-opgegeven evaluatievolgorde worden geëvalueerd vóór de argumenten met een opgegeven evaluatievolgorde.
Een auteur van een activiteit kan een sterk getypeerd mechanisme gebruiken voor het weergeven van de argumenten. Dit wordt bereikt door eigenschappen van het type InArgument<T>, OutArgument<T>en InOutArgument<T>. Hiermee kan een auteur van een activiteit een specifiek contract tot stand brengen over de gegevens die naar en van een activiteit gaan.
De argumenten voor een activiteit definiëren
Argumenten kunnen worden gedefinieerd voor een activiteit door eigenschappen van het type InArgument<T>, OutArgument<T>en InOutArgument<T>. De volgende code laat zien hoe u de argumenten definieert voor een Prompt activiteit die een tekenreeks gebruikt om weer te geven aan de gebruiker en een tekenreeks retourneert die het antwoord van de gebruiker bevat.
public class Prompt : Activity
{
public InArgument<string> Text { get; set; }
public OutArgument<string> Response { get; set; }
// Rest of activity definition omitted.
}
Notitie
Activiteiten die één waarde retourneren, kunnen worden afgeleid van Activity<TResult>, NativeActivity<TResult>of CodeActivity<TResult>. Deze activiteiten hebben een goed gedefinieerde OutArgument<T> naam Result die de retourwaarde van de activiteit bevat.
Variabelen en argumenten gebruiken in werkstromen
In het volgende voorbeeld ziet u hoe variabelen en argumenten worden gebruikt in een werkstroom. De werkstroom is een reeks die drie variabelen declareert: var1, var2en var3. De eerste activiteit in de werkstroom is een Assign activiteit die de waarde van de variabele var1 toewijst aan de variabele var2. Dit wordt gevolgd door een WriteLine activiteit waarmee de waarde van de var2 variabele wordt afgedrukt. Hierna volgt een andere Assign activiteit die de waarde van de variabele var2 toewijst aan de variabele var3. Ten slotte is er nog een WriteLine activiteit waarmee de waarde van de var3 variabele wordt afgedrukt. De eerste Assign activiteit gebruikt InArgument<string> en OutArgument<string> objecten die expliciet de bindingen voor de argumenten van de activiteit vertegenwoordigen. InArgument<string> wordt gebruikt Value omdat de waarde via het argument naar de Assign<T> activiteit Value stroomt en OutArgument<string> wordt gebruikt To omdat de waarde uit het To argument in de variabele stroomt. De tweede Assign activiteit bereikt hetzelfde met compactere maar equivalente syntaxis die gebruikmaakt van impliciete casts. De WriteLine activiteiten maken ook gebruik van de compacte syntaxis.
// 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);
Variabelen en argumenten gebruiken in op code gebaseerde activiteiten
In de vorige voorbeelden ziet u hoe u argumenten en variabelen gebruikt in werkstromen en declaratieve activiteiten. Argumenten en variabelen worden ook gebruikt in op code gebaseerde activiteiten. Conceptueel is het gebruik vergelijkbaar. Variabelen vertegenwoordigen gegevensopslag binnen de activiteit en argumenten vertegenwoordigen de stroom van gegevens naar of van de activiteit en zijn gebonden door de auteur van de werkstroom aan andere variabelen of argumenten in de werkstroom die aangeeft waar de gegevens naar of vandaan stromen. Als u de waarde van een variabele of argument in een activiteit wilt ophalen of instellen, moet een activiteitscontext worden gebruikt die de huidige uitvoeringsomgeving van de activiteit vertegenwoordigt. Dit wordt doorgegeven aan de Execute methode van de activiteit door de werkstroomruntime. In dit voorbeeld wordt een aangepaste Add activiteit gedefinieerd met twee In argumenten. Voor toegang tot de waarde van de argumenten wordt de Get methode gebruikt en wordt de context gebruikt die is doorgegeven door de werkstroomruntime.
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);
}
}
Zie Werkstromen, activiteiten en expressies ontwerpen met imperatieve code en vereiste argumenten en overbelastingsgroepen voor meer informatie over het werken met argumenten, variabelen en expressies in code.
