OutArgument<T> Klas

Definitie

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

Type parameters

Overname

Object

Argument

OutArgument

OutArgument<T>

Kenmerken

TypeConverterAttribute ContentPropertyAttribute

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een OutArgument<T>. Dit voorbeeld is afkomstig uit het voorbeeld 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")
                    },
            },
        }
};

Opmerkingen

Een OutArgument<T> wordt gebruikt om gegevens uit een activiteit te stromen. Als de activiteit de hoofdactiviteit van een werkstroom is, wordt deze ook gebruikt om gegevens uit de werkstroom naar de werkstroomhost te stromen. In dit voorbeeld wordt een aangepaste Divide activiteit met twee invoerargumenten en één uitvoerargument gebruikt als hoofdactiviteit van een werkstroom. De hosttoepassing geeft twee waarden door aan de werkstroom en haalt vervolgens het resultaat van de deling op nadat de werkstroom is voltooid.

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

De Divide activiteit gebruikt argumenten om de invoerwaarden te ontvangen en om de berekende resultaatwaarden op te geven. Het RemainderOutArgument<T> wordt gebruikt om de rest van de verdeling door te geven en het Result uitvoerargument dat wordt geleverd door Activity<TResult> afgeleide activiteiten, wordt gebruikt om het quotiënt uit te geven.

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