OutArgument<T> Clase

Definición

generic <typename T>
public ref class OutArgument sealed : System::Activities::OutArgument

[System.ComponentModel.TypeConverter(typeof(System.Activities.XamlIntegration.OutArgumentConverter))]
[System.Windows.Markup.ContentProperty("Expression")]
public sealed class OutArgument<T> : System.Activities.OutArgument

[<System.ComponentModel.TypeConverter(typeof(System.Activities.XamlIntegration.OutArgumentConverter))>]
[<System.Windows.Markup.ContentProperty("Expression")>]
type OutArgument<'T> = class
    inherit OutArgument

Public NotInheritable Class OutArgument(Of T)
Inherits OutArgument

Parámetros de tipo

Herencia

Object

Argument

OutArgument

OutArgument<T>

Atributos

TypeConverterAttribute ContentPropertyAttribute

Ejemplos

En la siguiente muestra de código se presenta la creación de OutArgument<T>. Este ejemplo se ha extraído de la muestra Formatter.

Sequence workflow = new Sequence
{
    Variables = { mealExpense, result },
    Activities =
        {
            new Assign<Expense>
            {
               Value = new InArgument<Expense>( (e) => new Meal { Amount = 50, Location = "Redmond", Vendor = "KFC" }),
               To = new OutArgument<Expense>(mealExpense)
            },
            new WriteLine
            {
                Text = new InArgument<string>("Hello")
            },
            approveExpense,
            new ReceiveReply
            {
                Request = approveExpense,
                Content = ReceiveContent.Create(new OutArgument<bool>(result))
            },

            new If
            {
               Condition = new InArgument<bool> (result),
               Then =
                    new WriteLine
                    {
                        Text = new InArgument<string>("Expense Approved")
                    },
               Else =
                    new WriteLine
                    {
                        Text = new InArgument<string>("Expense Cannot be Approved")
                    },
            },
        }
};

Comentarios

El OutArgument<T> se utiliza para canalizar el flujo de datos de salida de una actividad. Si la actividad es la actividad raíz de un flujo de trabajo, también se utiliza para el flujo de datos de salida del flujo de trabajo al host del flujo de trabajo. En este ejemplo, se utiliza como la actividad raíz de un flujo de trabajo una actividad Divide personalizada que tiene dos argumentos de entrada y un argumento de salida. La aplicación host pasa dos valores al flujo de trabajo y, a continuación, recupera el resultado de la división cuando se completa el flujo de trabajo.

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(new Divide(), arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

La actividad Divide utiliza los argumentos para recibir los valores de entrada y proporcionar los valores calculados de resultado. RemainderOutArgument<T> se usa para pasar el resto de la división y el Result argumento de salida proporcionado por Activity<TResult> las actividades derivadas se usa para pasar el cociente.

public sealed class Divide : CodeActivity
{
    [RequiredArgument]
    public InArgument<int> Dividend { get; set; }

    [RequiredArgument]
    public InArgument<int> Divisor { get; set; }

    public OutArgument<int> Remainder { get; set; }
    public OutArgument<int> Result { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Result.Set(context, quotient);
        Remainder.Set(context, remainder);
    }
}

Constructores

Campos

Propiedades

Métodos

Operadores

Se aplica a