Expressions (WF)

Une expression Windows Workflow Foundation (WF) est toute activité qui retourne un résultat. Toutes les activités d'expression dérivent indirectement de Activity<TResult>, qui contient une propriété OutArgument nommée Result comme valeur de retour de l'activité. WF est fourni avec un vaste éventail d’activités d’expressions, simples comme VariableValue<T> et VariableReference<T>, qui permettent d’accéder à une variable de workflow unique via des activités d’opérateur, ou complexes telles que VisualBasicReference<TResult> et VisualBasicValue<TResult> 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<TResult> ou NativeActivity<TResult>.

Utilisation d'expressions

Le concepteur de workflow utilise VisualBasicValue<TResult> et VisualBasicReference<TResult> pour les expressions dans les projets Visual Basic, et CSharpValue<TResult> et CSharpReference<TResult> pour les expressions dans les projets de workflow C#.

Notes

La prise en charge des expressions C# dans les projets de workflow a été introduite dans .NET Framework 4.5. Pour plus d’informations, consultez Expressions C#.

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="http://schemas.microsoft.com/netfx/2009/xaml/activities" xmlns:x="http://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))
        }
    }
};

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

Les expressions dans .NET Framework 4.6.1 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 l’utilisation d’expressions dans le code, consultez Création de flux de travail, d’activités et d’expressions à l’aide de code impératif.