OutArgument<T> Classe

Riferimento

Definizione

Spazio dei nomi:: System.Activities

Assembly:: System.Activities.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Terminale di associazione che rappresenta il flusso di dati 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 seguente viene illustrata la creazione di un OutArgument<T>. Questo esempio proviene dall'esempio 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> viene usato per il flusso di dati da un'attività. Se l'attività è l'attività radice di un flusso di lavoro, viene usata anche per propagare i dati dal flusso di lavoro all'host del flusso di lavoro. In questo esempio, un'attività di Divide personalizzata con due argomenti di input e un argomento di output viene usato come attività radice di un flusso di lavoro. L'applicazione host passa due valori nel flusso di lavoro e quindi recupera il risultato della divisione al termine del flusso di lavoro.

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

Nota

Se l'attività personalizzata deriva dalla CodeActivity<TResult> generica con un Int32 come argomento di tipo generico, quando si richiama l'attività con il metodo WorkflowInvoker Invoke, restituisce un valore Int32. Inoltre, il metodo CodeActivity<TResult>.Execute restituirà un valore Int32 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>()	Inizializzare una nuova istanza della classe OutArgument<T> utilizzando i valori predefiniti.
OutArgument<T>(Activity<Location<T>>)	Inizializza una nuova istanza della classe OutArgument<T> utilizzando il Activity<TResult>specificato.
OutArgument<T>(DelegateArgument)	Inizializza una nuova istanza della classe OutArgument<T> utilizzando il DelegateArgumentspecificato.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Inizializza una nuova istanza della classe OutArgument<T> utilizzando l'espressione specificata.
OutArgument<T>(Variable)	Inizializza una nuova istanza della classe OutArgument<T> utilizzando il Variablespecificato.

Campi

ResultValue

Rappresenta il valore costante di "Result", che corrisponde al nome della proprietà Result di tipo OutArgument nella classe 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 l'Argument rappresenta il flusso di dati in un'attività, da un'attività o sia all'interno che all'esterno di 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 DelegateArgumentspecificato.
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 Variablespecificato.
Get(ActivityContext)	Ottiene il valore del OutArgument<T> utilizzando il contesto dell'attività specificato.
Get<T>(ActivityContext)	Ottiene il valore dell'argomento utilizzando il tipo e il contesto dell'attività specificati. (Ereditato da Argument)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLocation(ActivityContext)	Ottiene la posizione del valore per il OutArgument<T>.
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
Set(ActivityContext, Object)	Imposta il valore dell'argomento utilizzando il contesto dell'attività specificato. (Ereditato da Argument)
Set(ActivityContext, T)	Imposta il valore del OutArgument<T> utilizzando 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 DelegateArgumentspecificato.
Implicit(Variable to OutArgument<T>)	Inizializza e restituisce un nuovo OutArgument<T> costruito utilizzando il Variablespecificato.

Si applica a

Condividi tramite