OutArgument<T> Classe

Référence

Définition

Espace de noms:: System.Activities

Assembly:: System.Activities.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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 du OutArgument<T>.

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.

Note

Si votre activité personnalisée est dérivée du CodeActivity<TResult> générique avec un Int32 comme argument de type générique, lorsque vous appelez l’activité avec la méthode WorkflowInvoker Invoke, elle retourne une valeur Int32. En outre, la méthode CodeActivity<TResult>.Execute retourne une valeur Int32 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>()	Initialisez une nouvelle instance de la classe OutArgument<T> à l’aide de valeurs par défaut.
OutArgument<T>(Activity<Location<T>>)	Initialise une nouvelle instance de la classe OutArgument<T> à l’aide de la Activity<TResult>spécifiée.
OutArgument<T>(DelegateArgument)	Initialise une nouvelle instance de la classe OutArgument<T> à l’aide de la DelegateArgumentspécifiée.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Initialise une nouvelle instance de la classe OutArgument<T> à l’aide de l’expression spécifiée.
OutArgument<T>(Variable)	Initialise une nouvelle instance de la classe OutArgument<T> à l’aide de la Variablespécifiée.

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 d’expression ActivityWithResult.

(Hérité de Argument)

Propriétés

ArgumentType	Obtient le type de données pour les données liées à cette Argument. (Hérité de Argument)
Direction	Obtient une ArgumentDirection qui spécifie si l'Argument représente le flux de données dans une activité, hors d’une activité ou à la fois 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 une Activity<TResult> qui représente la valeur de cette 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 une nouvelle OutArgument<T> construite à l’aide du DelegateArgumentspécifié.
FromExpression(Activity<Location<T>>)	Initialise et retourne une nouvelle OutArgument<T> construite à l’aide du Activity<TResult>spécifié.
FromVariable(Variable)	Initialise et retourne une nouvelle OutArgument<T> construite à l’aide du Variablespécifié.
Get(ActivityContext)	Obtient la valeur du 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()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLocation(ActivityContext)	Obtient l’emplacement de la valeur du OutArgument<T>.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (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 du 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 une nouvelle OutArgument<T> construite à l’aide du Activity<TResult>spécifié.
Implicit(DelegateArgument to OutArgument<T>)	Initialise et retourne une nouvelle OutArgument<T> construite à l’aide du DelegateArgumentspécifié.
Implicit(Variable to OutArgument<T>)	Initialise et retourne une nouvelle OutArgument<T> construite à l’aide du Variablespécifié.

S’applique à

Partager via