Zmienne i argumenty

Artykuł
06/08/2023

W programie Windows Workflow Foundation (WF) zmienne reprezentują przechowywanie danych i argumentów reprezentują przepływ danych do i z działania. Działanie ma zestaw argumentów i tworzą podpis działania. Ponadto działanie może obsługiwać listę zmiennych, do których deweloper może dodawać lub usuwać zmienne podczas projektowania przepływu pracy. Argument jest powiązany przy użyciu wyrażenia zwracającego wartość.

Zmienne

Zmienne to lokalizacje przechowywania danych. Zmienne są deklarowane jako część definicji przepływu pracy. Zmienne przyjmują wartości w czasie wykonywania, a te wartości są przechowywane jako część stanu wystąpienia przepływu pracy. Definicja zmiennej określa typ zmiennej i opcjonalnie nazwę. Poniższy kod pokazuje, jak zadeklarować zmienną, przypisać do niej wartość przy użyciu działania, a następnie wyświetlić jej wartość w konsoli przy użyciu Assign<T>WriteLine działania.

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

Wyrażenie wartości domyślnej można opcjonalnie określić jako część deklaracji zmiennej. Zmienne mogą również mieć modyfikatory. Jeśli na przykład zmienna jest tylko do odczytu, można zastosować modyfikator tylko do VariableModifiers odczytu. W poniższym przykładzie jest tworzona zmienna tylko do odczytu, która ma przypisaną wartość domyślną.

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

Określanie zakresu zmiennych

Okres istnienia zmiennej w czasie wykonywania jest równy okresowi istnienia działania, które je deklaruje. Po zakończeniu działania jego zmienne są czyszczone i nie mogą już być przywoływane.

Argumenty

Autorzy działań używają argumentów do definiowania sposobu, w jaki dane przepływają do i z działania. Każdy argument ma określony kierunek: In, lub Out InOut.

Środowisko uruchomieniowe przepływu pracy gwarantuje, że czas przenoszenia danych do i z działań:

Po rozpoczęciu wykonywania działania są obliczane wartości wszystkich argumentów wejściowych i wejściowych/wyjściowych. Na przykład niezależnie od tego, kiedy Get jest wywoływana, zwracana wartość jest wartością obliczaną przez środowisko uruchomieniowe przed wywołaniem Executeelementu .
Po Set wywołaniu środowisko uruchomieniowe ustawia wartość natychmiast.
Argumenty mogą opcjonalnie mieć określone EvaluationOrder . EvaluationOrder jest wartością opartą na zerach, która określa kolejność, w której argument jest obliczany. Domyślnie kolejność obliczania argumentu jest nieokreślona i jest równa UnspecifiedEvaluationOrder wartości. Ustaw EvaluationOrder wartość większą lub równą zero, aby określić kolejność oceny dla tego argumentu. Program Windows Workflow Foundation ocenia argumenty z określoną kolejnością oceny w kolejności rosnącej. Należy pamiętać, że argumenty z nieokreśloną kolejnością oceny są oceniane przed tymi, które mają określoną kolejność oceny.

Autor działania może użyć silnie typizowanego mechanizmu uwidaczniania argumentów. Jest to realizowane przez deklarowanie właściwości typu InArgument<T>, OutArgument<T>i InOutArgument<T>. Dzięki temu autor działania może ustanowić określony kontrakt dotyczący danych przechodzących do i z działania.

Definiowanie argumentów działania

Argumenty można zdefiniować w działaniu, określając właściwości typu InArgument<T>, OutArgument<T>i InOutArgument<T>. Poniższy kod pokazuje, jak zdefiniować argumenty działania Prompt , które przyjmuje ciąg do wyświetlenia użytkownikowi i zwraca ciąg zawierający odpowiedź użytkownika.

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

Uwaga

Działania zwracające pojedynczą wartość mogą pochodzić z Activity<TResult>wartości , NativeActivity<TResult>lub CodeActivity<TResult>. Te działania mają dobrze zdefiniowaną OutArgument<T> nazwę Result zawierającą wartość zwracaną działania.

Używanie zmiennych i argumentów w przepływach pracy

W poniższym przykładzie pokazano, jak zmienne i argumenty są używane w przepływie pracy. Przepływ pracy to sekwencja, która deklaruje trzy zmienne: var1, var2i var3. Pierwszym działaniem w przepływie pracy jest Assign działanie, które przypisuje wartość zmiennej var1 do zmiennej var2. Następnie następuje WriteLine działanie, które wyświetla wartość zmiennej var2 . Następnie jest kolejnym Assign działaniem, które przypisuje wartość zmiennej var2 do zmiennej var3. Na koniec istnieje inne WriteLine działanie, które wyświetla wartość zmiennej var3 . Pierwsze Assign działanie używa obiektów InArgument<string> i OutArgument<string> , które jawnie reprezentują powiązania argumentów działania. InArgument<string> parametr jest używany, Value ponieważ wartość przepływa do Assign<T> działania za pośrednictwem argumentu Value i OutArgument<string> jest używana, To ponieważ wartość przepływa z argumentu To do zmiennej. Drugie Assign działanie wykonuje to samo, co w przypadku bardziej kompaktowej, ale równoważnej składni, która używa niejawnych rzutów. Działania WriteLine używają również składni kompaktowej.

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

Używanie zmiennych i argumentów w działaniach opartych na kodzie

W poprzednich przykładach pokazano, jak używać argumentów i zmiennych w przepływach pracy i działaniach deklaratywnych. Argumenty i zmienne są również używane w działaniach opartych na kodzie. Koncepcyjnie użycie jest bardzo podobne. Zmienne reprezentują magazyn danych w ramach działania, a argumenty reprezentują przepływ danych do lub z działania i są powiązane przez autora przepływu pracy z innymi zmiennymi lub argumentami w przepływie pracy, który reprezentuje, gdzie dane przepływają do lub z. Aby uzyskać lub ustawić wartość zmiennej lub argumentu w działaniu, należy użyć kontekstu działania, który reprezentuje bieżące środowisko wykonywania działania. Jest on przekazywany do Execute metody działania przez środowisko uruchomieniowe przepływu pracy. W tym przykładzie zdefiniowano działanie niestandardowe Add , które ma dwa In argumenty. Aby uzyskać dostęp do wartości argumentów, Get używana jest metoda i używany jest kontekst przekazany przez środowisko uruchomieniowe przepływu pracy.

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

Aby uzyskać więcej informacji na temat pracy z argumentami, zmiennymi i wyrażeniami w kodzie, zobacz Tworzenie przepływów pracy, działań i wyrażeń przy użyciu kodu imperatywnego oraz wymaganych argumentów i grup przeciążeń.

Udostępnij za pośrednictwem