Expresiones (WF)

Una expresión de Windows Workflow Foundation (WF) es cualquier actividad que devuelva un resultado. Todas las actividades de expresión derivan indirectamente de Activity<TResult>, que contiene una OutArgument propiedad denominada Result como valor devuelto de la actividad. WF se distribuye con una amplia gama de actividades de expresión, desde las simples como VariableValue<T> y VariableReference<T>, que proporcionan acceso a una única variable de flujo de trabajo a través de actividades de operador, hasta actividades complejas como VisualBasicReference<TResult> y VisualBasicValue<TResult> que ofrecen acceso a toda la amplitud del lenguaje de Visual Basic para generar el resultado. Se pueden crear actividades de expresión adicionales derivando de CodeActivity<TResult> o NativeActivity<TResult>.

Uso de expresiones

El diseñador de flujos de trabajo usa VisualBasicValue<TResult> y VisualBasicReference<TResult> para todas las expresiones de los proyectos de Visual Basic y CSharpValue<TResult>CSharpReference<TResult> para expresiones en proyectos de flujo de trabajo de C#.

Nota:

La compatibilidad con expresiones de C# en proyectos de flujo de trabajo se introdujo en .NET Framework 4.5. Para obtener más información, vea Expresiones de C#.

Los flujos de trabajo generados por el diseñador se guardan en XAML, donde las expresiones aparecen entre corchetes, como en el ejemplo siguiente.

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

Al definir un flujo de trabajo en el código, se pueden usar todas las actividades de expresión. En el ejemplo siguiente se muestra el uso de una composición de actividades de operador para agregar tres números:

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

El mismo flujo de trabajo se puede expresar de forma más compacta mediante expresiones lambda de C#, como se muestra en el ejemplo siguiente:

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

Extender las expresiones disponibles con actividades de expresión personalizadas

Las expresiones de .NET Framework 4.6.1 son extensibles, lo que permite crear actividades de expresión adicionales. En el ejemplo siguiente se muestra una actividad que devuelve una suma de tres valores enteros.

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 esta nueva actividad, puede volver a escribir el flujo de trabajo anterior que agregó tres valores, como se muestra en el ejemplo siguiente:

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

Para obtener más información sobre el uso de expresiones en el código, vea Creación de flujos de trabajo, actividades y expresiones mediante código imperativo.