Expressies (WF)

Een WF-expressie (Windows Workflow Foundation) is een activiteit die een resultaat retourneert. Alle expressieactiviteiten zijn indirect afgeleid van Activity<TResult>, die een OutArgument eigenschap bevat met Result de geretourneerde waarde van de activiteit. WF wordt geleverd met een breed scala aan expressieactiviteiten van eenvoudige activiteiten zoals VariableValue<T> en VariableReference<T>, die toegang bieden tot één werkstroomvariabele via operatoractiviteiten, tot complexe activiteiten zoals VisualBasicReference<TResult> en VisualBasicValue<TResult> die toegang bieden tot de volledige breedte van de Visual Basic-taal om het resultaat te produceren. Aanvullende expressieactiviteiten kunnen worden gemaakt door van CodeActivity<TResult> of NativeActivity<TResult>.

Expressies gebruiken

Werkstroomontwerper gebruikt VisualBasicValue<TResult> en VisualBasicReference<TResult> voor alle expressies in Visual Basic-projecten en CSharpReference<TResult> CSharpValue<TResult> voor expressies in C#-werkstroomprojecten.

Notitie

Ondersteuning voor C#-expressies in werkstroomprojecten is geïntroduceerd in .NET Framework 4.5. Zie C#-expressies voor meer informatie.

Werkstromen die door de ontwerper worden geproduceerd, worden opgeslagen in XAML, waarbij expressies tussen vierkante haken worden weergegeven, zoals in het volgende voorbeeld.

<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>

Bij het definiëren van een werkstroom in code kunnen alle expressieactiviteiten worden gebruikt. In het volgende voorbeeld ziet u het gebruik van een samenstelling van operatoractiviteiten om drie getallen toe te voegen:

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

Dezelfde werkstroom kan compacter worden uitgedrukt met behulp van C#-lambda-expressies, zoals wordt weergegeven in het volgende voorbeeld:

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

Beschikbare expressies uitbreiden met aangepaste expressieactiviteiten

Expressies in .NET Framework 4.6.1 zijn uitbreidbaar, zodat extra expressieactiviteiten kunnen worden gemaakt. In het volgende voorbeeld ziet u een activiteit die een som van drie gehele getallen retourneert.

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

Met deze nieuwe activiteit kunt u de vorige werkstroom herschrijven die drie waarden heeft toegevoegd, zoals wordt weergegeven in het volgende voorbeeld:

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

Zie Werkstromen, activiteiten en expressies maken met imperatieve code voor meer informatie over het gebruik van expressies in code.