Variabler och argument

Artikel
03/05/2024

I Windows Workflow Foundation (WF) representerar variabler lagring av data och argument representerar dataflödet till och från en aktivitet. En aktivitet har en uppsättning argument och de utgör aktivitetens signatur. Dessutom kan en aktivitet underhålla en lista över variabler som en utvecklare kan lägga till eller ta bort variabler i under utformningen av ett arbetsflöde. Ett argument är bundet med ett uttryck som returnerar ett värde.

Variabler

Variabler är lagringsplatser för data. Variabler deklareras som en del av definitionen av ett arbetsflöde. Variabler använder värden vid körning och dessa värden lagras som en del av tillståndet för en arbetsflödesinstans. En variabeldefinition anger typen av variabel och eventuellt namnet. Följande kod visar hur du deklarerar en variabel, tilldelar ett värde till den med hjälp av en Assign<T> aktivitet och sedan visar dess värde för konsolen med hjälp av en WriteLine aktivitet.

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

Ett standardvärdeuttryck kan anges som en del av en variabeldeklaration. Variabler kan också ha modifierare. Om en variabel till exempel är skrivskyddad kan den skrivskyddade VariableModifiers modifieraren tillämpas. I följande exempel skapas en skrivskyddad variabel som har ett tilldelat standardvärde.

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

Variabelomfång

Livslängden för en variabel vid körning är lika med livslängden för den aktivitet som deklarerar den. När en aktivitet har slutförts rensas dess variabler och kan inte längre refereras till.

Argument

Aktivitetsförfattare använder argument för att definiera hur data flödar in i och ut ur en aktivitet. Varje argument har en angiven riktning: In, Outeller InOut.

Arbetsflödeskörningen ger följande garantier om tidpunkten för dataflytt till och från aktiviteter:

När en aktivitet börjar köras beräknas värdena för alla dess indata- och indata-/utdataargument. Oavsett när Get anropas är till exempel det värde som returneras det som beräknas av körningen före dess anrop av Execute.
När Set anropas anger körningen värdet omedelbart.
Argument kan också ha sina EvaluationOrder angivna. EvaluationOrder är ett nollbaserat värde som anger i vilken ordning argumentet utvärderas. Som standard är argumentets utvärderingsordning ospecificerad och är lika med UnspecifiedEvaluationOrder värdet. Ange EvaluationOrder ett värde som är större eller lika med noll för att ange en utvärderingsordning för det här argumentet. Windows Workflow Foundation utvärderar argument med en angiven utvärderingsordning i stigande ordning. Observera att argument med en ospecificerad utvärderingsordning utvärderas före dem med en angiven utvärderingsordning.

En aktivitetsförfattare kan använda en starkt typad mekanism för att exponera sina argument. Detta uppnås genom att deklarera egenskaper av typen InArgument<T>, OutArgument<T>och InOutArgument<T>. Detta gör att en aktivitetsförfattare kan upprätta ett specifikt kontrakt om data som går in i och ut ur en aktivitet.

Definiera argumenten för en aktivitet

Argument kan definieras för en aktivitet genom att ange egenskaper av typen InArgument<T>, OutArgument<T>och InOutArgument<T>. Följande kod visar hur du definierar argumenten för en Prompt aktivitet som tar in en sträng som ska visas för användaren och returnerar en sträng som innehåller användarens svar.

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

Kommentar

Aktiviteter som returnerar ett enda värde kan härledas från Activity<TResult>, NativeActivity<TResult>eller CodeActivity<TResult>. Dessa aktiviteter har ett väldefinierat OutArgument<T> namn Result som innehåller aktivitetens returvärde.

Använda variabler och argument i arbetsflöden

I följande exempel visas hur variabler och argument används i ett arbetsflöde. Arbetsflödet är en sekvens som deklarerar tre variabler: var1, var2och var3. Den första aktiviteten i arbetsflödet är en Assign aktivitet som tilldelar variabelvärdet var1 till variabeln var2. Detta följs av en WriteLine aktivitet som skriver ut värdet för variabeln var2 . Nästa är en annan Assign aktivitet som tilldelar värdet för variabeln var2 till variabeln var3. Slutligen finns det en annan WriteLine aktivitet som skriver ut värdet för variabeln var3 . Den första Assign aktiviteten använder InArgument<string> och OutArgument<string> objekt som uttryckligen representerar bindningarna för aktivitetens argument. InArgument<string> används för Value eftersom värdet flödar in i Assign<T> aktiviteten via dess Value argument och OutArgument<string> används för To eftersom värdet flödar ut ur To argumentet till variabeln. Den andra Assign aktiviteten åstadkommer samma sak med mer kompakt men motsvarande syntax som använder implicita casts. Aktiviteterna WriteLine använder också den kompakta syntaxen.

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

Använda variabler och argument i kodbaserade aktiviteter

I föregående exempel visas hur du använder argument och variabler i arbetsflöden och deklarativa aktiviteter. Argument och variabler används också i kodbaserade aktiviteter. Begreppsmässigt är användningen mycket lik. Variabler representerar datalagring i aktiviteten och argument representerar flödet av data till eller från aktiviteten och är bundna av arbetsflödesförfattaren till andra variabler eller argument i arbetsflödet som representerar var data flödar till eller från. För att hämta eller ange värdet för en variabel eller ett argument i en aktivitet måste en aktivitetskontext användas som representerar aktivitetens aktuella körningsmiljö. Detta skickas till Execute metoden för aktiviteten av arbetsflödeskörningen. I det här exemplet definieras en anpassad Add aktivitet som har två In argument. För att få åtkomst till värdet för argumenten Get används metoden och kontexten som skickades in av arbetsflödeskörningen används.

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

Mer information om hur du arbetar med argument, variabler och uttryck i kod finns i Redigera arbetsflöden, aktiviteter och uttryck med imperativ kod och obligatoriska argument och överbelastningsgrupper.

Dela via