OutArgument<T> Classe

Definizione

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

Parametri di tipo

Ereditarietà

Object

Argument

OutArgument

OutArgument<T>

Attributi

TypeConverterAttribute ContentPropertyAttribute

Esempio

Nell'esempio di codice seguente viene illustrata la creazione di un OutArgument<T>. Questo esempio proviene dall'esempio formattatore.

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

Commenti

Un OutArgument<T> viene usato per il flusso di dati da un'attività. Se l'attività è l'attività radice di un flusso di lavoro, viene usata anche per propagare i dati dal flusso di lavoro all'host del flusso di lavoro. In questo esempio, un'attività di Divide personalizzata con due argomenti di input e un argomento di output viene usato come attività radice di un flusso di lavoro. L'applicazione host passa due valori nel flusso di lavoro e quindi recupera il risultato della divisione al termine del flusso di lavoro.

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

L'attività Divide usa argomenti per ricevere i valori di input e per fornire i valori dei risultati calcolati. Il RemainderOutArgument<T> viene usato per passare il resto della divisione e l'argomento di output Result fornito da Activity<TResult> attività derivate viene usato per passare il quoziente.

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

Costruttori

Campi

Proprietà

Metodi

Operatori

Si applica a