Variables et arguments

Article
04/07/2023

Dans Windows Workflow Foundation (WF), les variables représentent le stockage de données et les arguments représentent le flux de données à l'intérieur et à l'extérieur d'une activité. Une activité a un ensemble d'arguments et ils composent la signature de l'activité. En outre, une activité peut gérer une liste de variables dans laquelle un développeur peut ajouter ou supprimer des variables pendant la conception d'un workflow. Un argument est lié à l'aide d'une expression qui retourne une valeur.

Variables

Les variables sont des emplacements de stockage pour les données. Les variables sont déclarées dans le cadre de la définition d'un workflow. Les variables prennent des valeurs au moment de l'exécution et ces valeurs sont stockées dans le cadre de l'état d'une instance de workflow. Une définition de variable spécifie le type de la variable et éventuellement le nom. Le code suivant indique comment déclarer une variable, lui affecter une valeur à l'aide d'une activité Assign<T>, puis afficher sa valeur dans la console à l'aide d'une activité WriteLine.

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

Une expression de valeur par défaut peut être spécifiée éventuellement dans le cadre d'une déclaration de variable. Les variables peuvent également avoir des modificateurs. Par exemple, si une variable est en lecture seule, le modificateur VariableModifiers en lecture seule peut être appliqué. Dans l'exemple suivant, une variable en lecture seule à laquelle une valeur par défaut est affectée est créée.

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

Portée des variables

La durée de vie d'une variable au moment de l'exécution est égale à la durée de vie de l'activité qui la déclare. Lorsqu'une activité est terminée, ses variables sont nettoyées et ne peuvent plus être référencées.

Arguments

Les auteurs d'activités utilisent des arguments pour définir la façon dont les données passent à l'intérieur et à l'extérieur d'une activité. Chaque argument a une direction spécifiée : In, Out ou InOut.

L'exécution du workflow apporte les garanties suivantes sur le minutage des déplacements de données à l'intérieur et à l'extérieur des activités :

Lorsque l'exécution d'une activité commence, les valeurs de tous ses arguments d'entrée et d'entrée/de sortie sont calculées. Par exemple, la valeur retournée est celle calculée par l'exécution avant son appel à Get, indépendamment du moment où Execute est appelé.
Lorsque Set est appelé, l'exécution définit immédiatement la valeur.
Les arguments peuvent éventuellement avoir leur EvaluationOrder spécifié. EvaluationOrder est une valeur de base zéro qui spécifie l'ordre dans lequel l'argument est évalué. Par défaut, l'ordre d'évaluation de l'argument n'est pas spécifié et est égal à la valeur UnspecifiedEvaluationOrder. Affectez à EvaluationOrder une valeur supérieure ou égale à zéro pour spécifier un ordre d’évaluation pour cet argument. Windows Workflow Foundation évalue des arguments avec une évaluation spécifiée dans l'ordre croissant. Notez que les arguments avec un ordre d'évaluation non spécifié sont évalués avant ceux avec un ordre d'évaluation spécifié.

Un auteur d'activité peut utiliser un mécanisme fortement typé pour l'exposition de ses arguments. Pour ce faire, déclarez des propriétés de type InArgument<T>, OutArgument<T> et InOutArgument<T>. Cela permet à un auteur d'activité d'établir un contrat spécifique sur les données qui entrent dans une activité et en sortent.

Définition des arguments sur une activité

Des arguments peuvent être définis sur une activité en spécifiant des propriétés de type InArgument<T>, OutArgument<T> et InOutArgument<T>. Le code suivant indique comment définir les arguments pour une activité Prompt qui accepte une chaîne à afficher à l’intention de l’utilisateur et retourne une chaîne qui contient la réponse de l’utilisateur.

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

Notes

Les activités qui retournent une valeur unique peuvent dériver de Activity<TResult>, NativeActivity<TResult> ou CodeActivity<TResult>. Ces activités ont un OutArgument<T> précis nommé Result qui contient la valeur de retour de l'activité.

Utilisation de variables et d’arguments dans les workflows

L’exemple suivant illustre comment les variables et arguments sont utilisés dans un workflow. Le workflow est une séquence qui déclare trois variables : var1, var2 et var3. La première activité dans le workflow est une activité Assign qui affecte la valeur de la variable var1 à la variable var2. Elle est suivie par une activité WriteLine qui imprime la valeur de la variable var2. Ensuite, une autre activité Assign affecte la valeur de la variable var2 à la variable var3. Enfin, une autre activité WriteLine imprime la valeur de la variable var3. La première activité Assign utilise les objets InArgument<string> et OutArgument<string> qui représentent explicitement les liaisons pour les arguments de l’activité. InArgument<string> est utilisé pour Value, car la valeur est transférée dans l'activité Assign<T> via son argument Value, et OutArgument<string> est utilisé pour To, car la valeur est transférée de l'argument To à la variable. La deuxième activité Assign effectue la même opération avec une syntaxe plus compacte mais équivalente qui utilise des casts implicites. Les activités WriteLine utilisent également la syntaxe compacte.

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

Utilisation de variables et d’arguments dans les activités basées sur le code

Les exemples précédents indiquent comment utiliser des arguments et des variables dans les workflows et les activités déclaratives. Les arguments et variables sont également utilisés dans les activités basées sur le code. Conceptuellement, l'utilisation est très semblable. Les variables représentent le stockage de données dans l’activité, et les arguments représentent le flux de données à l’intérieur ou à l’extérieur de l’activité et sont liés par l’auteur de workflow aux autres variables ou arguments dans le workflow qui représentent l’emplacement depuis ou vers lequel les données transitent. Pour obtenir ou définir la valeur d'une variable ou d'un argument dans une activité, un contexte d'activité qui représente l'environnement d'exécution actuel de l'activité doit être utilisé. Il est transmis à la méthode Execute de l'activité par l'exécution du workflow. Dans cet exemple, une activité Add personnalisée qui a deux arguments In est définie. Pour accéder à la valeur des arguments, la méthode Get est utilisée et le contexte passé par l’exécution du workflow est utilisé.

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

Pour plus d’informations sur l’utilisation d’arguments, de variables et d’expressions dans le code, consultez Création de workflows, d'activités et d'expressions à l'aide du code impératif et Arguments obligatoires et groupes surchargés.

Partager via