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 de 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

OutArgument<T> Se usa 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 personalizada Divide 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 Divide actividad usa argumentos para recibir los valores de entrada y para proporcionar los valores de resultado calculados. Remainder OutArgument<T> se usa para pasar el resto de la división y el Result argumento de salida proporcionado por Activity<TResult> las actividades derivadas se usa para pasar el cociente.

Note

Si la actividad personalizada se deriva del genérico CodeActivity<TResult> con un Int32 como argumento de tipo genérico, cuando se invoca la actividad con el WorkflowInvoker método Invoke, devuelve un Int32 valor. Además, el CodeActivity<TResult>.Execute método devolverá un Int32 valor 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

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

Campos

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

Propiedades

Nombre	Description
ArgumentType	Obtiene el tipo de datos de los datos enlazados a este Argumentobjeto . (Heredado de Argument)
Direction	Obtiene un ArgumentDirection objeto que especifica si 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> objeto que representa el valor de este OutArgument<T>objeto .

Métodos

Nombre	Description
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 mediante el especificado DelegateArgument.
FromExpression(Activity<Location<T>>)	Inicializa y devuelve un nuevo OutArgument<T> construido mediante el especificado Activity<TResult>.
FromVariable(Variable)	Inicializa y devuelve un nuevo OutArgument<T> construido mediante el especificado Variable.
Get(ActivityContext)	Obtiene el valor de utilizando el contexto de OutArgument<T> 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 la función hash predeterminada. (Heredado de Object)
GetLocation(ActivityContext)	Obtiene la ubicación del valor de .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 de utilizando el contexto de OutArgument<T> actividad especificado.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Operadores

Nombre	Description
Implicit(Activity<Location<T>> to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido mediante el especificado Activity<TResult>.
Implicit(DelegateArgument to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido mediante el especificado DelegateArgument.
Implicit(Variable to OutArgument<T>)	Inicializa y devuelve un nuevo OutArgument<T> construido mediante el especificado Variable.