Expressions

Cette rubrique s'applique à Windows Workflow Foundation 4.

Une expression Windows Workflow Foundation (WF) est toute activité qui retourne un résultat. Tous les activités d'expressions dérivent indirectement de Activity, qui contient une propriété OutArgument nommée Result comme valeur de retour de l'activité. WF est fourni avec une large gamme d'activités d'expressions, simples comme VariableValue et VariableReference, qui permettent d'accéder à une variable de workflow unique via des activités d'opérateur, ou complexes telles que VisualBasicReference et VisualBasicValue qui permettent d'accéder à la totalité du langage Visual Basic pour produire le résultat. Des activités d'expressions supplémentaires peuvent être créées en dérivant de CodeActivity ou NativeActivity.

Utilisation d'expressions

Le concepteur de workflow utilise VisualBasicValue et VisualBasicReference pour toutes les expressions. C'est pourquoi la syntaxe Visual Basic doit être utilisée dans les zones de texte d'expression du concepteur. Les workflows produits par le concepteur sont enregistrés en XAML, où les expressions s'affichent entre crochets, comme dans l'exemple suivant.

<Sequence xmlns="https://schemas.microsoft.com/netfx/2009/xaml/activities" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">
  <Sequence.Variables>
    <Variable x:TypeArguments="x:Int32" Default="1" Name="a" />
    <Variable x:TypeArguments="x:Int32" Default="2" Name="b" />
    <Variable x:TypeArguments="x:Int32" Default="3" Name="c" />
    <Variable x:TypeArguments="x:Int32" Default="0" Name="r" />
  </Sequence.Variables>
  <Assign>
    <Assign.To>
      <OutArgument x:TypeArguments="x:Int32">[r]</OutArgument>
    </Assign.To>
    <Assign.Value>
      <InArgument x:TypeArguments="x:Int32">[a + b + c]</InArgument>
    </Assign.Value>
  </Assign>
</Sequence>

Lors de la définition d'un workflow dans le code, toutes les activités d'expressions peuvent être utilisées. L'exemple suivant illustre l'utilisation d'une composition d'activités d'opérateur pour ajouter trois nombres.

Variable<int> a = new Variable<int>("a", 1);
Variable<int> b = new Variable<int>("b", 2);
Variable<int> c = new Variable<int>("c", 3);
Variable<int> r = new Variable<int>("r", 0);

Sequence w = new Sequence
{
    Variables = { a, b, c, r },
    Activities = 
    {
        new Assign {
            To = new OutArgument<int>(r),
            Value = new InArgument<int> {
                Expression = new Add<int, int, int> {
                    Left = new Add<int, int, int> {
                        Left = new InArgument<int>(a),
                        Right = new InArgument<int>(b)
                    },
                    Right = new InArgument<int>(c)
                }
            }
        }
    }
};

Le même workflow peut être exprimé d'une manière plus compacte en utilisant des expressions lambda C#, comme indiqué dans l'exemple suivant.

Variable<int> a = new Variable<int>("a", 1);
Variable<int> b = new Variable<int>("b", 2);
Variable<int> c = new Variable<int>("c", 3);
Variable<int> r = new Variable<int>("r", 0);

Sequence w = new Sequence
{
    Variables = { a, b, c, r },
    Activities = 
    {
        new Assign {
            To = new OutArgument<int>(r),
            Value = new InArgument<int>((ctx) => a.Get(ctx) + b.Get(ctx) + c.Get(ctx))
        }
    }
};

Le workflow peut également être exprimé à l'aide des activités d'expressions Visual Basic, comme indiqué dans l'exemple suivant.

Variable<int> a = new Variable<int>("a", 1);
Variable<int> b = new Variable<int>("b", 2);
Variable<int> c = new Variable<int>("c", 3);
Variable<int> r = new Variable<int>("r", 0);


Sequence w = new Sequence
{
    Variables = { a, b, c, r },
    Activities = 
    {
        new Assign {
            To = new OutArgument<int>(r),
            Value = new InArgument<int>(new VisualBasicValue<int>("a + b + c"))
        }
    }
};

Extension d'expressions disponibles avec les activités d'expressions personnalisées

Les expressions dans .NET Framework 4 sont extensibles, ce qui permet la création d'activités d'expressions supplémentaires. L'exemple suivant affiche une activité qui retourne une somme de trois valeurs entières.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Activities;

namespace ExpressionsDemo
{
    public sealed class AddThreeValues : CodeActivity<int>
    {
        public InArgument<int> Value1 { get; set; }
        public InArgument<int> Value2 { get; set; }
        public InArgument<int> Value3 { get; set; }

        protected override int Execute(CodeActivityContext context)
        {
            return Value1.Get(context) + 
                   Value2.Get(context) + 
                   Value3.Get(context);
        }
    }
}

Avec cette nouvelle activité, vous pouvez réécrire le workflow précédent qui a ajouté trois valeurs comme indiqué dans l'exemple suivant.

Variable<int> a = new Variable<int>("a", 1);
Variable<int> b = new Variable<int>("b", 2);
Variable<int> c = new Variable<int>("c", 3);
Variable<int> r = new Variable<int>("r", 0);


Sequence w = new Sequence
{
    Variables = { a, b, c, r },
    Activities = 
    {
        new Assign {
            To = new OutArgument<int>(r),
            Value = new InArgument<int> {
                Expression = new AddThreeValues() {
                    Value1 = new InArgument<int>(a),
                    Value2 = new InArgument<int>(b),
                    Value3 = new InArgument<int>(c)
                }
            }
        }
    }
};

Pour plus d'informations sur le sujet suivant l'utilisation d'expressions dans le code, consultez Création de workflows à l'aide du code impératif.