OutArgument<T> Classe

Referência

Definição

Namespace:: System.Activities

Assembly:: System.Activities.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Um terminal de associação que representa o fluxo de dados 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 de 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 do fluxo de trabalho para o host de fluxo de trabalho. Neste exemplo, uma atividade de Divide personalizada 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, em seguida, 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 atividade Divide usa argumentos para receber os valores de entrada e fornecer os valores de resultado computados. O RemainderOutArgument<T> é usado para distribuir o restante da divisão e o argumento de saída Result fornecido por Activity<TResult> atividades derivadas é usado para distribuir o quociente.

Nota

Se sua atividade personalizada for derivada do CodeActivity<TResult> genérico com um Int32 como seu argumento de tipo genérico, quando você invoca a atividade com o método invoke WorkflowInvoker, ela retorna um valor Int32. Além disso, o método CodeActivity<TResult>.Execute retornará um valor Int32 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>()	Inicialize 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 DelegateArgumentespecificado.
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 Variableespecificado.

Campos

ResultValue

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

(Herdado de Argument)

Propriedades

ArgumentType	Obtém o tipo de dados para os dados associados a esse Argument. (Herdado de Argument)
Direction	Obtém um ArgumentDirection que especifica se o Argument representa o fluxo de dados em uma atividade, fora de uma atividade ou dentro e fora de uma atividade. (Herdado de Argument)
EvaluationOrder	Obtém ou define um valor baseado em zero que especifica a ordem na qual o argumento é avaliado. (Herdado de Argument)
Expression	Obtém um 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 DelegateArgumentespecificado.
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 Variableespecificado.
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 para o OutArgument<T>.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (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 DelegateArgumentespecificado.
Implicit(Variable to OutArgument<T>)	Inicializa e retorna um novo OutArgument<T> construído usando o Variableespecificado.

Aplica-se a

Partilhar via