Expresiones

Este tema es aplicable a Windows Workflow Foundation 4.

Una expresión Windows Workflow Foundation (WF) es cualquier actividad que devuelve un resultado. Todas las actividades de expresión derivan indirectamente de Activity, que contiene una propiedad OutArgument denominada Result como el valor devuelto de la actividad. WF se distribuye con una gama amplia de actividades de expresión, ya sean simples como VariableValue y VariableReference, que proporcionan el acceso a la variable de flujo de trabajo a través de las actividades de operador; o complejas como VisualBasicReference y VisualBasicValue, que ofrecen acceso al amplio lenguaje de Visual Basic para generar el resultado. Las actividades de expresión adicionales se pueden crear al derivar de CodeActivity o NativeActivity.

Usar expresiones

El diseñador del flujo de trabajo usa VisualBasicValue y VisualBasicReference para todas las expresiones. Esta es la razón por la que la sintaxis de Visual Basic debe usarse en los cuadros de texto de expresión del diseñador. Los flujos de trabajo generados por el diseñador se guardan en XAML, donde las expresiones se adjuntan en corchetes, como en el siguiente ejemplo.

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

Al definir un flujo de trabajo en el código, se puede usar cualquier actividad de expresión. En el siguiente ejemplo se muestra el uso de una composición de actividades de operador para sumar 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 sólida usando expresiones lambda de C#, tal y como se muestra en el siguiente ejemplo.

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

El flujo de trabajo también se puede expresar usando actividades de expresión de Visual Basic, tal y como se muestra en el siguiente ejemplo.

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

Extender las expresiones disponibles con actividades de expresión personalizadas

Las expresiones en .NET Framework 4 son extensibles, lo que permite que se creen actividades de expresión adicionales. En el siguiente ejemplo 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 sumó tres valores, tal y como se muestra en el siguiente ejemplo.

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 usar expresiones en el código, vea Crear flujos de trabajo mediante código imperativo.