OutArgument<T> Klasse

Definition

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

Typparameter

Vererbung

Object

Argument

OutArgument

OutArgument<T>

Attribute

TypeConverterAttribute ContentPropertyAttribute

Beispiele

Das folgende Codebeispiel veranschaulicht das Erstellen eines OutArgument<T>. Dieses Beispiel stammt aus dem Formatterbeispiel.

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

Hinweise

Eine OutArgument<T> wird verwendet, um Daten aus einer Aktivität zu fließen. Wenn die Aktivität die Stammaktivität eines Workflows ist, wird sie auch verwendet, um Daten aus dem Workflow an den Workflowhost zu übertragen. In diesem Beispiel wird eine benutzerdefinierte Divide Aktivität mit zwei Eingabeargumenten und einem Ausgabeargument als Stammaktivität eines Workflows verwendet. Die Hostanwendung übergibt zwei Werte an den Workflow und ruft das Ergebnis der Division nach Abschluss des Workflows ab.

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

Die Divide Aktivität verwendet Argumente, um die Eingabewerte zu empfangen und die berechneten Ergebniswerte bereitzustellen. Die RemainderOutArgument<T> Wird verwendet, um den Rest der Division zu übergeben, und das Ausgabeargument, das Result von Activity<TResult> abgeleiteten Aktivitäten bereitgestellt wird, wird verwendet, um den Quotient zu übergeben.

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