Création de workflows à l'aide du code impératif

Cette rubrique s'applique à Windows Workflow Foundation 4.

Une définition de workflow est une arborescence d'objets d'activité configurés. Cette arborescence d'activités peut être définie de nombreuses façons, notamment en modifiant manuellement des données XAML ou en utilisant le Workflow Designer pour produire des données XAML. L'utilisation de XAML n'est toutefois pas impérative. Les définitions de workflow peuvent également être créées par programmation. Cette rubrique fournit une vue d'ensemble de la création de définitions de workflow à l'aide de code.

Création de définitions de workflow

Une définition de workflow peut être créée en instanciant une instance d'un type d'activité et configurant les propriétés de l'objet d'activité. Pour les activités qui ne contiennent pas d'activités enfants, cette opération peut être effectuée à l'aide de quelques lignes de code.

Activity wf = new WriteLine
{
    Text = "Hello World."
};

WorkflowInvoker.Invoke(wf);

Remarque :
Les exemples de cette rubrique utilisent WorkflowInvoker pour exécuter les exemples de workflows. Pour plus d'informations sur le sujet suivant sur l'appel des workflows, le passage des arguments et les différents choix d'hébergement disponibles, consultez Utilisation de WorkflowInvoker et WorkflowApplication.

Dans cet exemple, un workflow qui consiste en une activité WriteLine unique est créé. L'argument Text de l'activité WriteLine est défini et le workflow est appelé. Si une activité contient des activités enfants, la méthode de construction est semblable. L'exemple suivant utilise une activité Sequence qui contient deux activités WriteLine.

Activity wf = new Sequence
{
    Activities =
    {
        new WriteLine
        {
            Text = "Hello"
        },
        new WriteLine
        {
            Text = "World."
        }
    }
};

WorkflowInvoker.Invoke(wf);

Utilisation d'initialiseurs d'objets

Les exemples de cette rubrique utilisent la syntaxe d'initialisation d'objet. La syntaxe d'initialisation d'objet peut être une méthode utile pour créer des définitions de workflow dans le code, car elle fournit une vue hiérarchique des activités dans le workflow et affiche la relation entre les activités. Il n'est pas impératif d'utiliser la syntaxe d'initialisation d'objet lorsque vous créez des workflows par programmation. L'exemple suivant est d'un point de vue fonctionnel équivalent à l'exemple précédent :

WriteLine hello = new WriteLine();
hello.Text = "Hello";

WriteLine world = new WriteLine();
world.Text = "World";

Sequence wf = new Sequence();
wf.Activities.Add(hello);
wf.Activities.Add(world);

WorkflowInvoker.Invoke(wf);

Pour plus d'informations sur le sujet suivant les initialiseurs d'objets, consultez Comment : initialiser des objets sans appeler de constructeur (Guide de programmation C#) et Comment : déclarer un objet à l'aide d'un initialiseur d'objet.

Utilisation de variables, de valeurs littérales et d'expressions

Lorsque vous créez une définition de workflow à l'aide de code, tenez compte de ce que le code exécute dans le cadre de la création de la définition de workflow et de ce qu'il exécute dans le cadre de l'exécution d'une instance de ce workflow. Par exemple, le workflow suivant est conçu pour générer un nombre aléatoire et l'écrire dans la console.

Variable<int> n = new Variable<int>
{
    Name = "n"
};

Activity wf = new Sequence
{
    Variables = { n },
    Activities =
    {
        new Assign<int>
        {
            To = n,
            Value = new Random().Next(1, 101)
        },
        new WriteLine
        {
            Text = new InArgument<string>((env) => "The number is " + n.Get(env))
        }
    }
};

Lorsque ce code de définition de workflow est exécuté, l'appel à Random.Next est passé et le résultat est stocké dans la définition de workflow comme valeur littérale. De nombreuses instances de ce workflow peuvent être appelées et toutes afficheraient le même nombre. Pour que la génération du nombre aléatoire ait lieu pendant l'exécution du workflow, une expression qui est évaluée à chaque exécution du workflow doit être utilisée.

new Assign<int>
{
    To = n,
    Value = new VisualBasicValue<int>("New Random().Next(1, 101)")
}

Une VisualBasicValue représente une expression dans la syntaxe Visual Basic qui peut être utilisée comme r-value dans une expression et est évaluée à chaque exécution de l'activité conteneur. Le résultat de l'expression est affecté à la variable de workflow n et ces résultats sont utilisés par l'activité suivante dans le workflow. Pour accéder à la valeur de la variable de workflow n au moment de l'exécution, le ActivityContext est requis. Elle est accessible à l'aide de l'expression lambda suivante.

new WriteLine
{
    Text = new InArgument<string>((env) => "The number is " + n.Get(env))
}

Les expressions lambda ne sont pas sérialisables au format XAML. Pour rendre cette expression compatible avec XAML, utilisez ExpressionServices et Convert, comme illustré dans l'exemple suivant.

new WriteLine
{
    //Text = new InArgument<string>((env) => "The number is " + n.Get(env))
    Text = ExpressionServices.Convert((env) => "The number is " + n.Get(env))
}

Un VisualBasicValue pourrait également être utilisé.

new WriteLine
{
    //Text = new InArgument<string>((env) => "The number is " + n.Get(env))
    //Text = ExpressionServices.Convert((env) => "The number is " + n.Get(env))
    Text = new VisualBasicValue<string>("\"The number is \" + n.ToString()")
}

Pour plus d'informations sur le sujet suivant les expressions, consultez Expressions.

Arguments et activités dynamiques

Une définition de workflow est créée dans le code en assemblant des activités dans une arborescence d'activité et en configurant l'ensemble des propriétés et arguments. Les arguments existants peuvent être liés, mais les nouveaux arguments ne peuvent pas être ajoutés aux activités. Cela inclut les arguments de workflow passés à l'activité racine. Dans le code impératif, les arguments de workflow sont spécifiés comme propriétés sur un nouveau type CLR et, en XAML, ils sont déclarés à l'aide de x:Class et x:Member. Étant donné qu'il n'existe aucun nouveau type CLR créé lorsqu'une définition de workflow est créée comme une arborescence d'objets en mémoire, les arguments ne peuvent pas être ajoutés. Toutefois, les arguments peuvent être ajoutés à une DynamicActivity. Dans cet exemple, un DynamicActivity qui accepte deux arguments entiers, les additionne et retourne le résultat est créé. Une DynamicActivityProperty est créée pour chaque argument et le résultat de l'opération est affecté à l'argument Result de DynamicActivity.

InArgument<int> Operand1 = new InArgument<int>();
InArgument<int> Operand2 = new InArgument<int>();

DynamicActivity<int> wf = new DynamicActivity<int>
{
    Properties =
    {
        new DynamicActivityProperty
        {
            Name = "Operand1",
            Type = typeof(InArgument<int>),
            Value = Operand1
        },
        new DynamicActivityProperty
        {
            Name = "Operand2",
            Type = typeof(InArgument<int>),
            Value = Operand2
        }
    },

    Implementation = () => new Sequence
    {
        Activities = 
        {
            new Assign<int>
            {
                To = new ArgumentReference<int> { ArgumentName = "Result" },
                Value = new InArgument<int>((env) => Operand1.Get(env) + Operand2.Get(env))
            }
        }
    }
};

Dictionary<string, object> wfParams = new Dictionary<string, object>
{
    { "Operand1", 25 },
    { "Operand2", 15 }
};

int result = WorkflowInvoker.Invoke(wf, wfParams);
Console.WriteLine(result);

Pour plus d'informations sur le sujet suivant les activités dynamiques, consultez Création d'une activité en cours d'exécution avec DynamicActivity.