OutArgument<T> Classe

Definizione

Spazio dei nomi:

System.Activities

Assembly:

System.Activities.dll

Un terminale dell'associazione che rappresenta il flusso di dati fuori da un'attività.

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

Parametri di tipo

T

Tipo di dati del OutArgument<T>.

Ereditarietà

Object

Argument

OutArgument

OutArgument<T>

Attributi

TypeConverterAttribute ContentPropertyAttribute

Esempio

Nell'esempio di codice riportato di seguito viene illustrata la creazione di un oggetto OutArgument<T>. Questo esempio è tratto dall'esempio del formattatore.

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

Commenti

Un OutArgument<T> è utilizzato per propagare dati fuori di un'attività. Se l'attività è l'attività radice di un flusso di lavoro, si utilizza anche per propagare dati fuori del flusso di lavoro al host del flusso di lavoro. In questo esempio, un'attività Divide personalizzata che dispone di due argomenti di input e un argomento di output viene utilizzata come attività radice di un flusso di lavoro. L'applicazione host passa due valori nel flusso di lavoro e recupera quindi il risultato della divisione dopo che il flusso di lavoro viene completato.

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'attività Divide utilizza argomenti per ricevere i valori di input e fornire i valori dei risultati calcolati. Viene RemainderOutArgument<T> utilizzato per passare il resto della divisione e l'argomento Result di output fornito dalle Activity<TResult> attività derivate viene usato per passare il quoziente.

Nota

Se l'attività personalizzata è derivata da un CodeActivity<TResult> generico con un Int32 come argomento tipo generico, quando si richiama l'attività con il metodo del Richiamo WorkflowInvoker, essa restituisce un valore Int32. Inoltre, il CodeActivity<TResult>.Execute metodo restituirà un Int32 valore anziché void e non è necessario impostare un valore restituito.

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

Costruttori

OutArgument<T>()	Inizializza una nuova istanza della classe OutArgument<T> utilizzando i valori predefiniti.
OutArgument<T>(Activity<Location<T>>)	Inizializza una nuova istanza della classe OutArgument<T> usando il Activity<TResult> specificato.
OutArgument<T>(DelegateArgument)	Inizializza una nuova istanza della classe OutArgument<T> usando il DelegateArgument specificato.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Inizializza una nuova istanza della classe OutArgument<T> con l'espressione specificata.
OutArgument<T>(Variable)	Inizializza una nuova istanza della classe OutArgument<T> usando il Variable specificato.

Campi

ResultValue

Rappresenta il valore costante di "Result", corrispondente al nome della proprietà Result di tipo OutArgument nella classe di base dell'espressione ActivityWithResult. (Ereditato da Argument)

Proprietà

ArgumentType	Ottiene il tipo di dati per i dati associati a questo Argument. (Ereditato da Argument)
Direction	Ottiene un ArgumentDirection che specifica se il Argument rappresenta il flusso di dati in un'attività, fuori da un'attività o dentro e fuori da un'attività. (Ereditato da Argument)
EvaluationOrder	Ottiene o imposta un valore in base zero che specifica l'ordine in cui viene valutato l'argomento. (Ereditato da Argument)
Expression	Ottiene un Activity<TResult> che rappresenta il valore di questo OutArgument<T>.

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
FromDelegateArgument(DelegateArgument)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il DelegateArgument specificato.
FromExpression(Activity<Location<T>>)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il Activity<TResult> specificato.
FromVariable(Variable)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il Variable specificato.
Get(ActivityContext)	Restituisce il valore del OutArgument<T> usando il contesto dell'attività specificato.
Get<T>(ActivityContext)	Ottiene il valore dell'argomento utilizzando il tipo specificato e il contesto dell'attività. (Ereditato da Argument)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLocation(ActivityContext)	Ottiene il percorso del valore per il OutArgument<T>.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Set(ActivityContext, Object)	Imposta il valore dell'argomento utilizzando lo specifico contesto dell'attività. (Ereditato da Argument)
Set(ActivityContext, T)	Imposta il valore del OutArgument<T> usando il contesto dell'attività specificato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Operatori

Implicit(Activity<Location<T>> to OutArgument<T>)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il Activity<TResult> specificato.
Implicit(DelegateArgument to OutArgument<T>)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il DelegateArgument specificato.
Implicit(Variable to OutArgument<T>)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il Variable specificato.