Expressões (WF)

Uma expressão WF (Windows Workflow Foundation) é qualquer atividade que retorna um resultado. Todas as atividades de expressão derivam indiretamente de , que contém uma OutArgument propriedade nomeada Result como valor de Activity<TResult>retorno da atividade. O WF é fornecido com uma ampla gama de atividades de expressão, desde as simples, como VariableValue<T> e VariableReference<T>, que fornecem acesso a uma única variável de fluxo de trabalho por meio de atividades do operador, até atividades complexas, como VisualBasicReference<TResult> e VisualBasicValue<TResult> que oferecem acesso a toda a amplitude da linguagem Visual Basic para produzir o resultado. Atividades de expressão adicionais podem ser criadas derivando de CodeActivity<TResult> ou NativeActivity<TResult>.

Usando expressões

O designer de fluxo de trabalho usa VisualBasicValue<TResult> e VisualBasicReference<TResult> para todas as expressões em projetos Visual Basic e CSharpValue<TResult> CSharpReference<TResult> para expressões em projetos de fluxo de trabalho C#.

Nota

O suporte para expressões C# em projetos de fluxo de trabalho foi introduzido no .NET Framework 4.5. Para obter mais informações, consulte Expressões em C#.

Os fluxos de trabalho produzidos pelo designer são salvos em XAML, onde as expressões aparecem entre colchetes, como no exemplo a seguir.

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

Ao definir um fluxo de trabalho no código, todas as atividades de expressão podem ser usadas. O exemplo a seguir mostra o uso de uma composição de atividades do operador para adicionar três 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)
                }
            }
        }
    }
};

O mesmo fluxo de trabalho pode ser expresso de forma mais compacta usando expressões lambda em C#, conforme mostrado no exemplo a seguir:

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

Estendendo expressões disponíveis com atividades de expressão personalizadas

As expressões no .NET Framework 4.6.1 são extensíveis, permitindo que atividades de expressão adicionais sejam criadas. O exemplo a seguir mostra uma atividade que retorna uma soma de três valores inteiros.

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

Com essa nova atividade, você pode reescrever o fluxo de trabalho anterior que adicionou três valores, conforme mostrado no exemplo a seguir:

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 obter mais informações sobre como usar expressões no código, consulte Criação de fluxos de trabalho, atividades e expressões usando código imperativo.