OutArgument<T> Classe

Definição

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
OutArgument<T>
Atributos

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