OutArgument<T> Klasse

Definition

Namespace:

System.Activities

Assembly:

System.Activities.dll

Ein Bindungsterminal, das den Datenfluss aus einer Aktivität darstellt.

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

T

Der Datentyp des OutArgument<T>.

Vererbung

Object

Argument

OutArgument

OutArgument<T>

Attribute

TypeConverterAttribute ContentPropertyAttribute

Beispiele

Im folgenden Codebeispiel wird das Erstellen eines OutArgument<T>veranschaulicht. 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

Ein 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 ein 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 Result Ausgabeargument, das von Activity<TResult> abgeleiteten Aktivitäten bereitgestellt wird, wird verwendet, um den Quotienten zu übergeben.

Anmerkung

Wenn Ihre benutzerdefinierte Aktivität von der generischen CodeActivity<TResult> mit einem Int32 als generisches Typargument abgeleitet wird, wenn Sie die Aktivität mit der WorkflowInvoker Invoke-Methode aufrufen, wird ein Int32 Wert zurückgegeben. Darüber hinaus gibt die CodeActivity<TResult>.Execute-Methode einen Int32 Wert anstelle von void zurück, und Sie müssen keinen Rückgabewert festlegen.

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

Konstruktoren

OutArgument<T>()	Initialisieren Sie eine neue Instanz der OutArgument<T> Klasse mithilfe von Standardwerten.
OutArgument<T>(Activity<Location<T>>)	Initialisiert eine neue Instanz der OutArgument<T> Klasse mithilfe der angegebenen Activity<TResult>.
OutArgument<T>(DelegateArgument)	Initialisiert eine neue Instanz der OutArgument<T> Klasse mithilfe der angegebenen DelegateArgument.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Initialisiert eine neue Instanz der OutArgument<T> Klasse mithilfe des angegebenen Ausdrucks.
OutArgument<T>(Variable)	Initialisiert eine neue Instanz der OutArgument<T> Klasse mithilfe der angegebenen Variable.

Felder

ResultValue

Stellt den Konstantenwert von "Result" dar, der dem Namen der Result Eigenschaft vom Typ OutArgument in der Ausdrucksbasisklasse ActivityWithResultentspricht. (Geerbt von Argument)

Eigenschaften

ArgumentType	Ruft den Datentyp für die an diese Argumentgebundenen Daten ab. (Geerbt von Argument)
Direction	Ruft einen ArgumentDirection ab, der angibt, ob die Argument den Datenfluss in eine Aktivität, aus einer Aktivität oder in und aus einer Aktivität darstellt. (Geerbt von Argument)
EvaluationOrder	Dient zum Abrufen oder Festlegen eines nullbasierten Werts, der die Reihenfolge angibt, in der das Argument ausgewertet wird. (Geerbt von Argument)
Expression	Ruft einen Activity<TResult> ab, der den Wert dieses OutArgument<T>darstellt.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
FromDelegateArgument(DelegateArgument)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen DelegateArgumenterstellt wurde.
FromExpression(Activity<Location<T>>)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen Activity<TResult>erstellt wurde.
FromVariable(Variable)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen Variableerstellt wurde.
Get(ActivityContext)	Ruft den Wert der OutArgument<T> mithilfe des angegebenen Aktivitätskontexts ab.
Get<T>(ActivityContext)	Ruft den Wert des Arguments mithilfe des angegebenen Typs und Aktivitätskontexts ab. (Geerbt von Argument)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLocation(ActivityContext)	Ruft die Position des Werts für die OutArgument<T>ab.
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
Set(ActivityContext, Object)	Legt den Wert des Arguments mithilfe des angegebenen Aktivitätskontexts fest. (Geerbt von Argument)
Set(ActivityContext, T)	Legt den Wert des OutArgument<T> mithilfe des angegebenen Aktivitätskontexts fest.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Operatoren

Implicit(Activity<Location<T>> to OutArgument<T>)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen Activity<TResult>erstellt wurde.
Implicit(DelegateArgument to OutArgument<T>)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen DelegateArgumenterstellt wurde.
Implicit(Variable to OutArgument<T>)	Initialisiert und gibt einen neuen OutArgument<T> zurück, der mit dem angegebenen Variableerstellt wurde.