OutArgument<T> Classe

Définition

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

Paramètres de type

Héritage

Object

Argument

OutArgument

OutArgument<T>

Attributs

TypeConverterAttribute ContentPropertyAttribute

Exemples

L’exemple de code suivant illustre la création d’un OutArgument<T>. Cet exemple provient de l’exemple Formateur.

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

Remarques

Une OutArgument<T> est utilisée pour extraire les données d’une activité. Si l’activité est l’activité racine d’un flux de travail, elle est également utilisée pour transmettre des données hors du flux de travail à l’hôte de flux de travail. Dans cet exemple, une activité de Divide personnalisée qui a deux arguments d’entrée et un argument de sortie est utilisé comme activité racine d’un flux de travail. L’application hôte transmet deux valeurs au flux de travail, puis récupère le résultat de la division une fois le flux de travail terminé.

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’activité Divide utilise des arguments pour recevoir les valeurs d’entrée et fournir les valeurs de résultat calculées. La RemainderOutArgument<T> est utilisée pour transmettre le reste de la division, et l’argument de sortie Result fourni par Activity<TResult> activités dérivées est utilisé pour transmettre le quotient.

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

Constructeurs

Champs

Propriétés

Méthodes

Opérateurs

S’applique à