Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

OutArgument<T> (Clase)

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

Espacio de nombres:  System.Activities
Ensamblado:  System.Activities (en System.Activities.dll)

[ContentPropertyAttribute("Expression")]
[TypeConverterAttribute(typeof(OutArgumentConverter))]
public sealed class OutArgument<T> : OutArgument

Parámetros de tipo

T

Tipo de datos de la clase OutArgument<T>.

El tipo OutArgument<T> expone los siguientes miembros.

  NombreDescripción
Método públicoOutArgument<T>()Inicializa una nueva instancia de la clase OutArgument<T> utilizando los valores predeterminados.
Método públicoOutArgument<T>(Activity<Location<T>>)Inicializa una nueva instancia de la clase OutArgument<T> con la propiedad Activity<TResult> especificada.
Método públicoOutArgument<T>(DelegateArgument)Inicializa una nueva instancia de la clase OutArgument<T> con la propiedad DelegateArgument especificada.
Método públicoOutArgument<T>(Expression<Func<ActivityContext, T>>)Inicializa una nueva instancia de la clase OutArgument<T> utilizando la expresión especificada.
Método públicoOutArgument<T>(Variable)Inicializa una nueva instancia de la clase OutArgument<T> con la propiedad Variable especificada.
Arriba

  NombreDescripción
Propiedad públicaArgumentTypeObtiene el tipo de datos para los datos enlazados a este Argument. (Se hereda de Argument).
Propiedad públicaDirectionObtiene ArgumentDirection que especifica en si Argument representa el flujo de datos en una actividad, de una actividad, o y una actividad. (Se hereda de Argument).
Propiedad públicaEvaluationOrderObtiene o establece un valor cero- basado en que especifique el orden en que se evalúa el argumento. (Se hereda de Argument).
Propiedad públicaExpressionObtiene una clase Activity<TResult> que representa el valor de esta clase OutArgument<T>.
Arriba

  NombreDescripción
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoMiembro estáticoFromDelegateArgumentInicializa y devuelve una nueva clase OutArgument<T> construida utilizando la clase DelegateArgument especificada.
Método públicoMiembro estáticoFromExpressionInicializa y devuelve una nueva clase OutArgument<T> construida usando la Activity<TResult> especificada.
Método públicoMiembro estáticoFromVariableInicializa y devuelve una nueva clase OutArgument<T> construida utilizando la Variable especificada.
Método públicoGetObtiene el valor de OutArgument<T> utilizando el contexto de actividad especificado.
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetLocationObtiene la ubicación del valor de la clase OutArgument<T>.
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoSet(ActivityContext, Object)Establece el valor del argumento utilizando el contexto especificado de la actividad. (Se hereda de Argument).
Método públicoSet(ActivityContext, T)Establece el valor del argumento OutArgument<T> utilizando el contexto de actividad especificado.
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

  NombreDescripción
Operador públicoMiembro estáticoImplicit(Activity<Location<T>> to OutArgument<T>)Inicializa y devuelve una nueva clase OutArgument<T> construida usando la Activity<TResult> especificada.
Operador públicoMiembro estáticoImplicit(DelegateArgument to OutArgument<T>)Inicializa y devuelve una nueva clase OutArgument<T> construida utilizando la clase DelegateArgument especificada.
Operador públicoMiembro estáticoImplicit(Variable to OutArgument<T>)Inicializa y devuelve una nueva clase OutArgument<T> construida usando la Variable especificada.
Arriba

El OutArgument<T> se utiliza para canalizar el flujo de datos de salida de una actividad. Si la actividad es la actividad raíz de un flujo de trabajo, también se utiliza para el flujo de datos de salida del flujo de trabajo al host del flujo de trabajo. En este ejemplo, se utiliza como la actividad raíz de un flujo de trabajo una actividad Divide personalizada que tiene dos argumentos de entrada y un argumento de salida. La aplicación host pasa dos valores al flujo de trabajo y, a continuación, recupera el resultado de la división cuando se completa 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 utiliza los argumentos para recibir los valores de entrada y proporcionar los valores calculados de resultado. El argumento OutArgument<T>Remainder se utiliza para pasar el resto de la división y el argumento de salida Result proporcionado por las actividades derivadas de Activity<TResult> se usa para pasar el cociente.

NotaNota

Si su actividad personalizada se deriva del objeto CodeActivity<TResult> genérico con un valor Int32 como su argumento de tipo genérico, al invocar la actividad con el método Invoke WorkflowInvoker, devuelve un valor Int32. Además, el método de CodeActivity<TResult>.Execute devolverá un valor de Int32 en lugar de void y no necesita 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);
    }
}


En la siguiente muestra de código se presenta la creación de OutArgument<T>. Este ejemplo se ha extraído de la muestra Formatter.


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

        }
};


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Compatible con: 4

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft