Espressioni (WF)

Un'espressione di Windows Workflow Foundation (WF) è qualsiasi attività che restituisce un risultato. Tutte le attività di espressione derivano indirettamente da Activity<TResult>, che contiene una OutArgument proprietà denominata Result come valore restituito dell'attività. WF viene fornito con un'ampia gamma di attività di espressione da semplici come VariableValue<T> e VariableReference<T>, che forniscono l'accesso a una singola variabile del flusso di lavoro tramite attività dell'operatore, a attività complesse come VisualBasicReference<TResult> e VisualBasicValue<TResult> che offrono l'accesso all'intera ampiezza del linguaggio Visual Basic per produrre il risultato. È possibile creare attività di espressione aggiuntive derivando da 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 di flusso di lavoro C#.

Annotazioni

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 in XAML, dove le espressioni vengono racchiuse 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. L'esempio seguente illustra l'utilizzo 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 espressioni lambda C#, come illustrato 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 delle espressioni disponibili con attività di espressione personalizzate

Le espressioni in .NET Framework 4.6.1 sono estendibili, consentendo la creazione di attività di espressione aggiuntive. Nell'esempio seguente viene illustrata un'attività che restituisce una somma di tre valori interi.

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 illustrato 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'uso di espressioni nel codice, vedere Creazione di flussi di lavoro, attività ed espressioni tramite codice imperativo.