OutArgument<T> Classe

Définition

Terminal de liaison qui représente le flux de données hors d’une activité.A binding terminal that represents the flow of data out of an activity.

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
type OutArgument<'T> = class
    inherit OutArgument
Public NotInheritable Class OutArgument(Of T)
Inherits OutArgument

Paramètres de type

T

Type de données de l'objet OutArgument<T>.The data type of the OutArgument<T>.

Héritage
OutArgument<T>
Attributs

Exemples

L'exemple de code suivant montre comment créer un OutArgument<T>.The following code sample demonstrates creating an OutArgument<T>. Il est extrait de l'exemple du formateur.This example is from the Formatter sample.

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

Un objet OutArgument<T> est utilisé pour entraîner la circulation des données hors d'une activité.An OutArgument<T> is used to flow data out of an activity. Si l'activité est l'activité racine d'un flux de travail, il est également utilisé pour entraîner la circulation des données du flux de travail vers l'hôte du flux de travail.If the activity is the root activity of a workflow, then it is also used to flow data out of the workflow to the workflow host. Dans cet exemple, une activité Divide personnalisée qui a deux arguments d’entrée et un argument de sortie est utilisée comme activité racine d’un flux de travail.In this example, a custom Divide activity that has two input arguments and one output argument is used as the root activity of a workflow. L'application hôte passe deux valeurs dans le flux de travail, puis récupère le résultat de la division après que le flux de travail est achevé.The host application passes two values into the workflow and then retrieves the result of the division after the workflow completes.

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.The Divide activity uses arguments to receive the input values and to provide the computed result values. Est utilisé pour transmettre le reste de la Division, et l' Result argument de sortie fourni par Activity<TResult> les activités dérivées est utilisé pour passer le quotient. Remainder OutArgument<T>The Remainder OutArgument<T> is used to pass out the remainder of the division, and the Result output argument provided by Activity<TResult> derived activities is used to pass out the quotient.

Notes

Si votre activité personnalisée est dérivée de l’objet générique CodeActivity<TResult> avec un objet Int32 comme argument de type générique, lorsque vous appelez l’activité avec la méthode Invoke WorkflowInvoker, elle retourne une valeur Int32.If your custom activity is derived from the generic CodeActivity<TResult> with an Int32 as its generic type argument, when you invoke the activity with the WorkflowInvoker Invoke method, it returns an Int32 value. En outre, la CodeActivity<TResult>.Execute méthode retourne une Int32 valeur au lieu de void , et vous n’avez pas besoin de définir une valeur de retour.In Addition, the CodeActivity<TResult>.Execute method will return an Int32 value instead of void and you do not need to set a return value.

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

OutArgument<T>()

Initialise une nouvelle instance de la classe OutArgument<T> avec les valeurs par défaut.Initialize a new instance of the OutArgument<T> class using default values.

OutArgument<T>(Activity<Location<T>>)

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du Activity<TResult> spécifié.Initializes a new instance of the OutArgument<T> class using the specified Activity<TResult>.

OutArgument<T>(DelegateArgument)

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du DelegateArgument spécifié.Initializes a new instance of the OutArgument<T> class using the specified DelegateArgument.

OutArgument<T>(Expression<Func<ActivityContext,T>>)

Initialise une nouvelle instance de la classe OutArgument<T> avec l'expression spécifiée.Initializes a new instance of the OutArgument<T> class using the specified expression.

OutArgument<T>(Variable)

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du Variable spécifié.Initializes a new instance of the OutArgument<T> class using the specified Variable.

Champs

ResultValue

Représente la valeur constante de « Result », qui correspond au nom de la propriété Result de type OutArgument dans la classe de base ActivityWithResult de l’expression.Represents the constant value of "Result", which corresponds to the name of the Result property of type OutArgument in the expression base class ActivityWithResult.

(Hérité de Argument)

Propriétés

ArgumentType

Obtient le type de données pour les données liées à l'objet Argument.Gets the data type for the data bound to this Argument.

(Hérité de Argument)
Direction

Obtient un objet ArgumentDirection qui spécifie si l'objet Argument représente le flux de données dans une activité, hors d'une activité, ou dans et hors d'une activité.Gets an ArgumentDirection that specifies whether the Argument represents the flow of data into an activity, out of an activity, or both into and out of an activity.

(Hérité de Argument)
EvaluationOrder

Obtient ou définit une valeur de base zéro qui spécifie l’ordre dans lequel l’argument est évalué.Gets or sets a zero-based value that specifies the order in which the argument is evaluated.

(Hérité de Argument)
Expression

Obtient un objet Activity<TResult> qui représente la valeur de l'objet OutArgument<T>.Gets an Activity<TResult> that represents the value of this OutArgument<T>.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
FromDelegateArgument(DelegateArgument)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la DelegateArgument spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified DelegateArgument.

FromExpression(Activity<Location<T>>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Activity<TResult> spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified Activity<TResult>.

FromVariable(Variable)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Variable spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified Variable.

Get(ActivityContext)

Obtient la valeur de OutArgument<T> à l'aide du contexte d'activité spécifié.Gets the value of the OutArgument<T> using the specified activity context.

Get<T>(ActivityContext)

Obtient la valeur de l’argument à l’aide du type et du contexte d’activité spécifiés.Gets the value of the argument using the specified type and activity context.

(Hérité de Argument)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLocation(ActivityContext)

Obtient l'emplacement de la valeur de OutArgument<T>.Gets the location of the value for the OutArgument<T>.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Set(ActivityContext, Object)

Définit la valeur de l’argument à l’aide du contexte d’activité spécifié.Sets the value of the argument using the specified activity context.

(Hérité de Argument)
Set(ActivityContext, T)

Définit la valeur de l'objet OutArgument<T> à l'aide du contexte d'activité spécifié.Sets the value of the OutArgument<T> using the specified activity context.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Opérateurs

Implicit(Activity<Location<T>> to OutArgument<T>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Activity<TResult> spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified Activity<TResult>.

Implicit(DelegateArgument to OutArgument<T>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la DelegateArgument spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified DelegateArgument.

Implicit(Variable to OutArgument<T>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Variable spécifiée.Initializes and returns a new OutArgument<T> constructed using the specified Variable.

S’applique à