OutArgument<T> Classe

Definição

Namespace:

System.Activities

Assembly:

System.Activities.dll

Um terminal de associação que representa o fluxo de dados fora de uma atividade.

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

Parâmetros de tipo

T

O tipo de dados do OutArgument<T>.

Herança

Object

Argument

OutArgument

OutArgument<T>

Atributos

TypeConverterAttribute ContentPropertyAttribute

Exemplos

O exemplo de código a seguir demonstra a criação de um OutArgument<T>. Este exemplo é do exemplo formatador.

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

Comentários

Um OutArgument<T> é usado para fluir dados de uma atividade. Se a atividade for a atividade raiz de um fluxo de trabalho, ela também será usada para fluir dados para fora do fluxo de trabalho para o host do fluxo de trabalho. Neste exemplo, uma atividade personalizada Divide que tem dois argumentos de entrada e um argumento de saída é usada como a atividade raiz de um fluxo de trabalho. O aplicativo host passa dois valores para o fluxo de trabalho e recupera o resultado da divisão após a conclusão do fluxo de trabalho.

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"]);

A Divide atividade usa argumentos para receber os valores de entrada e para fornecer os valores de resultado calculados. O RemainderOutArgument<T> é usado para passar o restante da divisão e o Result argumento de saída fornecido por Activity<TResult> atividades derivadas é usado para passar o quociente.

Observação

Se sua atividade personalizada for derivada do genérico CodeActivity<TResult> com um Int32 como seu argumento de tipo genérico, quando você invocar a atividade com o WorkflowInvoker método Invoke, ela retornará um Int32 valor. Além disso, o CodeActivity<TResult>.Execute método retornará um Int32 valor em vez de void e você não precisará definir um valor retornado.

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

Construtores

OutArgument<T>()	Inicializar uma nova instância da classe OutArgument<T> usando valores padrão.
OutArgument<T>(Activity<Location<T>>)	Inicializa uma nova instância da classe OutArgument<T> usando o Activity<TResult> especificado.
OutArgument<T>(DelegateArgument)	Inicializa uma nova instância da classe OutArgument<T> usando o DelegateArgument especificado.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Inicializa uma nova instância da classe OutArgument<T> usando a expressão especificada.
OutArgument<T>(Variable)	Inicializa uma nova instância da classe OutArgument<T> usando o Variable especificado.

Campos

ResultValue

Representa o valor constante "Result", que corresponde ao nome da propriedade Result do tipo OutArgument na classe base da expressão ActivityWithResult. (Herdado de Argument)

Propriedades

ArgumentType	Obtém o tipo de dados associados a este Argument. (Herdado de Argument)
Direction	Obtém um ArgumentDirection que especifica se o Argument representa o fluxo de dados de entrada de uma atividade, de saída de uma atividade ou de entrada e de saída de uma atividade. (Herdado de Argument)
EvaluationOrder	Obtém ou define um valor baseado em zero que especifica a ordem em que o argumento é avaliado. (Herdado de Argument)
Expression	Obtém uma Activity<TResult> que representa o valor deste OutArgument<T>.

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
FromDelegateArgument(DelegateArgument)	Inicializa e retorna um novo OutArgument<T> construído usando o DelegateArgument especificado.
FromExpression(Activity<Location<T>>)	Inicializa e retorna um novo OutArgument<T> construído usando o Activity<TResult> especificado.
FromVariable(Variable)	Inicializa e retorna um novo OutArgument<T> construído usando o Variable especificado.
Get(ActivityContext)	Obtém o valor do OutArgument<T> usando o contexto de atividade especificado.
Get<T>(ActivityContext)	Obtém o valor do argumento usando o tipo e o contexto de atividade especificados. (Herdado de Argument)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLocation(ActivityContext)	Obtém o local do valor do OutArgument<T>.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Set(ActivityContext, Object)	Define o valor do argumento usando o contexto de atividade especificado. (Herdado de Argument)
Set(ActivityContext, T)	Define o valor do OutArgument<T> usando o contexto de atividade especificado.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Operadores

Implicit(Activity<Location<T>> to OutArgument<T>)	Inicializa e retorna um novo OutArgument<T> construído usando o Activity<TResult> especificado.
Implicit(DelegateArgument to OutArgument<T>)	Inicializa e retorna um novo OutArgument<T> construído usando o DelegateArgument especificado.
Implicit(Variable to OutArgument<T>)	Inicializa e retorna um novo OutArgument<T> construído usando o Variable especificado.