Variables et arguments

Dans Windows Workflow Foundation (WF), les variables représentent le stockage des données et des arguments représentent le flux de données dans et hors d’une activité. Une activité a un ensemble d’arguments et constitue la signature de l’activité. En outre, une activité peut gérer une liste de variables auxquelles un développeur peut ajouter ou supprimer des variables pendant la conception d’un flux de travail. 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 flux de travail. 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 montre comment déclarer une variable, lui attribuer une valeur à l’aide d’une Assign<T> activité, puis afficher sa valeur à la console à l’aide d’une WriteLine activité.

// 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 éventuellement être spécifiée 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 en lecture seule VariableModifiers peut être appliqué. Dans l’exemple suivant, une variable en lecture seule est créée avec une valeur par défaut affectée.

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

Étendue 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é se termine, ses variables sont nettoyées et ne peuvent plus être référencées.

Les arguments

Les auteurs d’activités utilisent des arguments pour définir la façon dont les données circulent vers et hors d’une activité. Chaque argument a une direction spécifiée : In, ou OutInOut.

Le runtime de flux de travail garantit le minutage du déplacement des données vers et hors des activités :

1. Lorsqu’une activité commence à s’exécuter, les valeurs de tous ses arguments d’entrée et d’entrée/sortie sont calculées. Par exemple, indépendamment du moment Get où elle est appelée, la valeur retournée est celle calculée par le runtime avant son appel de Execute.

2. Quand Set il est appelé, le runtime définit immédiatement la valeur.

3. Les arguments peuvent éventuellement avoir leur EvaluationOrder valeur spécifiée. 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 UnspecifiedEvaluationOrder valeur. Défini EvaluationOrder sur une valeur supérieure ou égale à zéro pour spécifier un ordre d’évaluation pour cet argument. Windows Workflow Foundation évalue les arguments avec un ordre d’évaluation spécifié 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 exposer 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 entrantes et sortantes d’une activité.

Définition des arguments sur une activité

Les arguments peuvent être définis sur une activité en spécifiant les propriétés de type InArgument<T>, OutArgument<T>et InOutArgument<T>. Le code suivant montre comment définir les arguments d’une Prompt activité qui prend une chaîne à afficher à 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.  
}  

Remarque

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

Utilisation de variables et d’arguments dans les flux de travail

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

// 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 Code-Based

Les exemples précédents montrent comment utiliser des arguments et des variables dans des flux de travail et des activités déclaratives. Les arguments et les variables sont également utilisés dans les activités basées sur le code. Conceptuellement, l’utilisation est très similaire. Les variables représentent le stockage des données au sein de l’activité, et les arguments représentent le flux de données vers ou hors de l’activité, et sont liés par l’auteur du flux de travail à d’autres variables ou arguments du flux de travail qui représentent l’endroit où les données circulent vers ou depuis. Pour obtenir ou définir la valeur d’une variable ou d’un argument dans une activité, un contexte d’activité doit être utilisé qui représente l’environnement d’exécution actuel de l’activité. Cela est passé dans la Execute méthode de l’activité par le runtime de flux de travail. Dans cet exemple, une activité personnalisée Add est définie avec deux In arguments. Pour accéder à la valeur des arguments, la Get méthode est utilisée et le contexte passé par le runtime de 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 flux de travail, activités et expressions à l’aided’arguments impératifs et d’arguments obligatoires et de groupes de surcharge.