Espressioni

Le informazioni contenute in questo argomento sono valide per Windows Workflow Foundation 4.

Un'espressione Windows Workflow Foundation (WF) è una qualsiasi attività che restituisce un risultato. Tutte le attività di espressione derivano indirettamente dall'oggetto Activity che contiene una proprietà OutArgument denominata Result come valore restituito dell'attività. WF viene fornito con un'ampia gamma di attività di espressione, alcune semplici come VariableValue e VariableReference che forniscono l'accesso alla singola variabile del flusso di lavoro tramite le attività dell'operatore, altre complesse come VisualBasicReference e VisualBasicValue che offrono l'accesso a tutto il linguaggio Visual Basic per produrre il risultato. È possibile creare attività di espressione aggiuntive derivando dall'oggetto CodeActivity o NativeActivity.

Utilizzo delle espressioni

Progettazione flussi di lavoro utilizza gli oggetti VisualBasicValue e VisualBasicReference per tutte le espressioni. Per questo motivo, la sintassi di Visual Basic deve essere utilizzata nelle caselle di testo dell'espressione della finestra di progettazione. 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="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>

Quando si definisce un flusso di lavoro nel codice, è possibile utilizzare qualsiasi attività di espressione. Nell'esempio seguente viene mostrato 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 utilizzando 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))
        }
    }
};

Il flusso di lavoro può essere espresso anche utilizzando le espressioni di attività di Visual Basic, 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>(new VisualBasicValue<int>("a + b + c"))
        }
    }
};

Estensione di espressioni disponibili con attività di espressione personalizzate

Le espressioni in .NET Framework 4 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 ulteriori informazioni su utilizzo di espressioni nel codice, vedere Creazione di flussi di lavoro tramite codice imperativo.