OutArgument<T> Classe

Définition

Terminal de liaison qui représente le flux de données hors d’une activité.

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

T

Type de données de l'objet OutArgument<T>.

Héritage
OutArgument<T>
Attributs

Exemples

L'exemple de code suivant montre comment créer un OutArgument<T>. Il est extrait de l'exemple du 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

Un objet OutArgument<T> est utilisé pour entraîner la circulation des données hors d'une activité. 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. 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. 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é.

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. Le RemainderOutArgument<T> est utilisé pour passer le reste de la division, et l’argument Result de sortie fourni par Activity<TResult> les activités dérivées est utilisé pour transmettre le quotient.

Remarque

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. 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.

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.

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

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du Activity<TResult> spécifié.

OutArgument<T>(DelegateArgument)

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du DelegateArgument spécifié.

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

Initialise une nouvelle instance de la classe OutArgument<T> avec l'expression spécifiée.

OutArgument<T>(Variable)

Initialise une nouvelle instance de la classe OutArgument<T> à l'aide du Variable spécifié.

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.

(Hérité de Argument)

Propriétés

ArgumentType

Obtient le type de données pour les données liées à l'objet 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é.

(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é.

(Hérité de Argument)
Expression

Obtient un objet Activity<TResult> qui représente la valeur de l'objet OutArgument<T>.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

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

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la DelegateArgument spécifiée.

FromExpression(Activity<Location<T>>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Activity<TResult> spécifiée.

FromVariable(Variable)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Variable spécifiée.

Get(ActivityContext)

Obtient la valeur de OutArgument<T> à l'aide du contexte d'activité spécifié.

Get<T>(ActivityContext)

Obtient la valeur de l'argument à l'aide du type et du contexte d'activité spécifiés.

(Hérité de Argument)
GetHashCode()

Fait office de fonction de hachage par défaut.

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

Obtient l'emplacement de la valeur de OutArgument<T>.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

Définit la valeur de l’argument à l’aide du contexte d’activité spécifié.

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

Définit la valeur de l'objet OutArgument<T> à l'aide du contexte d'activité spécifié.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(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.

Implicit(DelegateArgument to OutArgument<T>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la DelegateArgument spécifiée.

Implicit(Variable to OutArgument<T>)

Initialise et retourne un nouvel OutArgument<T> construit à l'aide de la Variable spécifiée.

S’applique à