OutArgument<T> Clase

Definición

Espacio de nombres:

System.Activities

Ensamblado:

System.Activities.dll

Terminal de enlace que representa el flujo de datos de una actividad.

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

Tipo de datos del OutArgument<T>.

Herencia

Object

Argument

OutArgument

OutArgument<T>

Atributos

TypeConverterAttribute ContentPropertyAttribute

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear un OutArgument<T>. Este ejemplo procede del ejemplo formateador.

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

Comentarios

Se usa un OutArgument<T> para fluir los datos de una actividad. Si la actividad es la actividad raíz de un flujo de trabajo, también se usa para fluir los datos del flujo de trabajo al host de flujo de trabajo. En este ejemplo, se usa una actividad de Divide personalizada que tiene dos argumentos de entrada y un argumento de salida como actividad raíz de un flujo de trabajo. La aplicación host pasa dos valores al flujo de trabajo y, a continuación, recupera el resultado de la división una vez completado el flujo de trabajo.

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

La actividad Divide usa argumentos para recibir los valores de entrada y proporcionar los valores de resultado calculados. El RemainderOutArgument<T> se usa para pasar el resto de la división y el argumento de salida Result proporcionado por Activity<TResult> actividades derivadas se usa para pasar el cociente.

Nota

Si la actividad personalizada se deriva del CodeActivity<TResult> genérico con un Int32 como argumento de tipo genérico, al invocar la actividad con el método WorkflowInvoker Invoke, devuelve un valor Int32. Además, el método CodeActivity<TResult>.Execute devolverá un valor Int32 en lugar de void y no es necesario establecer un valor devuelto.

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

Constructores

OutArgument<T>()	Inicialice una nueva instancia de la clase OutArgument<T> con valores predeterminados.
OutArgument<T>(Activity<Location<T>>)	Inicializa una nueva instancia de la clase OutArgument<T> mediante el Activity<TResult>especificado.
OutArgument<T>(DelegateArgument)	Inicializa una nueva instancia de la clase OutArgument<T> mediante el DelegateArgumentespecificado.
OutArgument<T>(Expression<Func<ActivityContext,T>>)	Inicializa una nueva instancia de la clase OutArgument<T> mediante la expresión especificada.
OutArgument<T>(Variable)	Inicializa una nueva instancia de la clase OutArgument<T> mediante el Variableespecificado.

Campos

ResultValue

Representa el valor constante de "Result", que corresponde al nombre de la propiedad Result de tipo OutArgument en la clase base de expresión ActivityWithResult. (Heredado de Argument)

Propiedades

ArgumentType	Obtiene el tipo de datos de los datos enlazados a este Argument. (Heredado de Argument)
Direction	Obtiene un ArgumentDirection que especifica si el Argument representa el flujo de datos en una actividad, fuera de una actividad o tanto dentro como fuera de una actividad. (Heredado de Argument)
EvaluationOrder	Obtiene o establece un valor de base cero que especifica el orden en el que se evalúa el argumento. (Heredado de Argument)
Expression	Obtiene un Activity<TResult> que representa el valor de este OutArgument<T>.

Métodos

Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
FromDelegateArgument(DelegateArgument)	Inicializa y devuelve un nuevo OutArgument<T> construido con el DelegateArgumentespecificado.
FromExpression(Activity<Location<T>>)	Inicializa y devuelve un nuevo OutArgument<T> construido con el Activity<TResult>especificado.
FromVariable(Variable)	Inicializa y devuelve un nuevo OutArgument<T> construido con el Variableespecificado.
Get(ActivityContext)	Obtiene el valor del OutArgument<T> mediante el contexto de actividad especificado.
Get<T>(ActivityContext)	Obtiene el valor del argumento utilizando el tipo y el contexto de actividad especificados. (Heredado de Argument)
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLocation(ActivityContext)	Obtiene la ubicación del valor de la OutArgument<T>.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
Set(ActivityContext, Object)	Establece el valor del argumento mediante el contexto de actividad especificado. (Heredado de Argument)
Set(ActivityContext, T)	Establece el valor del OutArgument<T> mediante el contexto de actividad especificado.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Operadores

Implicit(Activity<Location<T>> to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido con el Activity<TResult>especificado.
Implicit(DelegateArgument to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido con el DelegateArgumentespecificado.
Implicit(Variable to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido con el Variableespecificado.