OutArgument<T> Osztály

Definíció

Névtér:

System.Activities

Szerelvény:

System.Activities.dll

Egy kötési terminál, amely egy tevékenységből történő adatáramlást jelöli.

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

Típusparaméterek

T

OutArgument<T>A .

Öröklődés

Object

Argument

OutArgument

OutArgument<T>

Attribútumok

TypeConverterAttribute ContentPropertyAttribute

Példák

Az alábbi kódminta egy OutArgument<T>. Ez a példa a Formatter-mintából származik.

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

Megjegyzések

Az an OutArgument<T> használatával adatokat lehet kihozni egy tevékenységből. Ha a tevékenység egy munkafolyamat gyökértevékenysége, akkor a munkafolyamatból a munkafolyamat-gazdagépre is áramlik az adatok. Ebben a példában egy egyéni Divide tevékenység, amely két bemeneti argumentumot és egy kimeneti argumentumot használ a munkafolyamat gyökértevékenységeként. A gazdaalkalmazás két értéket ad át a munkafolyamatnak, majd lekéri az osztás eredményét a munkafolyamat befejezése után.

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

A Divide tevékenység argumentumokkal fogadja a bemeneti értékeket, és megadja a kiszámított eredményértékeket. Az RemainderOutArgument<T> osztás fennmaradó részét adja ki, a Result származtatott tevékenységek által Activity<TResult> biztosított kimeneti argumentum pedig a hányados átadására szolgál.

Note

Ha az egyéni tevékenység egy általános típusú argumentummal CodeActivity<TResult> származik a generikusbólInt32, a tevékenység meghívásakor az WorkflowInvoker Invoke metódussal egy értéket ad visszaInt32. Emellett a metódus egy CodeActivity<TResult>.Execute értéket ad vissza Int32 ahelyett void , hogy értéket ad vissza, és nem kell megadnia a visszatérési értéket.

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

Konstruktorok

Name	Description
OutArgument<T>()	Inicializálja az osztály új példányát alapértelmezett OutArgument<T> értékekkel.
OutArgument<T>(Activity<Location<T>>)	Inicializálja az osztály új példányát a OutArgument<T> megadott Activity<TResult>használatával.
OutArgument<T>(DelegateArgument)	Inicializálja az osztály új példányát a OutArgument<T> megadott DelegateArgumenthasználatával.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Inicializálja az osztály új példányát OutArgument<T> a megadott kifejezéssel.
OutArgument<T>(Variable)	Inicializálja az osztály új példányát a OutArgument<T> megadott Variablehasználatával.

Mezők

Name	Description
ResultValue	Az "Eredmény" állandó értékét jelöli, amely a kifejezés alaposztályában Resultszereplő típustulajdonság OutArgument nevének ActivityWithResult felel meg. (Öröklődés forrása Argument)

Tulajdonságok

Name	Description
ArgumentType	Lekéri az ehhez Argumentkapcsolódó adatok adattípusát. (Öröklődés forrása Argument)
Direction	Olyan lekérdezést ArgumentDirection kap, amely meghatározza, hogy az Argument adatáramlás egy tevékenységbe, egy tevékenységből, vagy egy tevékenységbe vagy egy tevékenységből való adatáramlást jelöli-e. (Öröklődés forrása Argument)
EvaluationOrder	Lekéri vagy beállít egy nulla alapú értéket, amely meghatározza az argumentum kiértékelésének sorrendjét. (Öröklődés forrása Argument)
Expression	A egy olyan értéket Activity<TResult> kap, amely ennek OutArgument<T>az értéknek az értékét jelöli.

Metódusok

Name	Description
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
FromDelegateArgument(DelegateArgument)	Inicializál és visszaad egy új OutArgument<T> , a megadott DelegateArgumenthasználatával létrehozott elemet.
FromExpression(Activity<Location<T>>)	Inicializál és visszaad egy új OutArgument<T> , a megadott Activity<TResult>használatával létrehozott elemet.
FromVariable(Variable)	Inicializál és visszaad egy új OutArgument<T> , a megadott Variablehasználatával létrehozott elemet.
Get(ActivityContext)	Lekéri a OutArgument<T> megadott tevékenységkörnyezetet használó értékeket.
Get<T>(ActivityContext)	Lekéri az argumentum értékét a megadott típus és tevékenységkörnyezet használatával. (Öröklődés forrása Argument)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLocation(ActivityContext)	Lekéri az érték helyét a OutArgument<T>.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Set(ActivityContext, Object)	Az argumentum értékét a megadott tevékenységkörnyezettel állítja be. (Öröklődés forrása Argument)
Set(ActivityContext, T)	Beállítja a OutArgument<T> megadott tevékenységkörnyezetet használó értékeket.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Operátorok

Name	Description
Implicit(Activity<Location<T>> to OutArgument<T>)	Inicializál és visszaad egy új OutArgument<T> , a megadott Activity<TResult>használatával létrehozott elemet.
Implicit(DelegateArgument to OutArgument<T>)	Inicializál és visszaad egy új OutArgument<T> , a megadott DelegateArgumenthasználatával létrehozott elemet.
Implicit(Variable to OutArgument<T>)	Inicializál és visszaad egy új OutArgument<T> , a megadott Variablehasználatával létrehozott elemet.