Espressioni (WF)

Un'espressione in Windows Workflow Foundation (WF) è una qualsiasi attività che restituisce un risultato. Tutte le attività di espressione derivano indirettamente da Activity<TResult>, che contiene una proprietà OutArgument che viene denominata Result quando l'attività restituisce un valore. WF viene fornito con un'ampia gamma di attività di espressione, da quelle semplici comeVariableValue<T> e VariableReference<T>, che consentono di accedere a variabili del flusso di lavoro attraverso attività dell'operatore, a quelle complesse come VisualBasicReference<TResult> e VisualBasicValue<TResult> che, per produrre il risultato, offrono l'accesso all'intera gamma di funzionalità del linguaggio Visual Basic. È possibile creare attività di espressione aggiuntive derivando dall'oggetto CodeActivity<TResult> o NativeActivity<TResult>.

Uso di espressioni

Progettazione flussi di lavoro usa VisualBasicValue<TResult> e VisualBasicReference<TResult> per tutte le espressioni nei progetti Visual Basic e CSharpValue<TResult> e CSharpReference<TResult> per le espressioni nei progetti flusso di lavoro C#

Nota

Il supporto per le espressioni C# nei progetti flusso di lavoro è stato introdotto in .NET Framework 4.5. Per altre informazioni, vedere Espressioni C#.

I flussi di lavoro prodotti dalla finestra di progettazione vengono salvati nel codice XAML, in cui le espressioni sono incluse tra parentesi quadre, come nell'esempio seguente.

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

Quando si definisce un flusso di lavoro nel codice, è possibile usare qualsiasi attività di espressione. Nell'esempio seguente viene mostrato l'uso di una composizione di attività dell'operatore per aggiungere tre numeri:

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

Lo stesso flusso di lavoro può essere espresso in modo più compatto usando le espressioni lambda di C#, come mostrato nell'esempio seguente:

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

Estensione di espressioni disponibili con attività di espressione personalizzate

Le espressioni in .NET Framework 4.6.1 possono essere estese consentendo la creazione di attività di espressione aggiuntive. Nell'esempio seguente viene mostrata un'attività che restituisce una somma di tre valori Integer.

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

Con questa nuova attività è possibile riscrivere il flusso di lavoro precedente che ha aggiunto tre valori come mostrato nell'esempio seguente:

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

Per altre informazioni sull'utilizzo di espressioni nel codice, vedere Creazione di flussi di lavoro, attività ed espressioni tramite codice imperativo.