Propiedades de ejecución de flujo de trabajo

A través del almacenamiento local de subprocesos (TLS), CLR mantiene un contexto de ejecución para cada subproceso. Este contexto de ejecución rige las propiedades conocidas del subproceso, como la identidad del subproceso, la transacción ambiente y el conjunto de permisos actual, además de las propiedades de subproceso definidas por el usuario, como las ranuras con nombre.

A diferencia de los programas que tienen por objetivo directo el CLR, los programas de flujo de trabajo son árboles con ámbito jerárquico de actividades que se ejecutan en un entorno independiente del subproceso. Esto implica que los mecanismos TLS estándar no se pueden usar directamente para determinar qué contexto está en el ámbito de un elemento de trabajo determinado. Por ejemplo, dos ramas paralelas de ejecución pueden usar transacciones diferentes, pero el programador podría intercalar su ejecución en el mismo subproceso CLR.

Las propiedades de ejecución del flujo de trabajo proporcionan un mecanismo para agregar propiedades específicas del contexto al entorno de una actividad. Esto permite que una actividad declare qué propiedades están en el ámbito de su subárbol y también proporciona enlaces para configurar y anular TLS para interoperar correctamente con objetos CLR.

Creación y uso de propiedades de ejecución de flujo de trabajo

Las propiedades de ejecución de flujo de trabajo suelen implementar la interfaz IExecutionProperty, aunque las propiedades centradas en mensajería pueden implementar ISendMessageCallback y IReceiveMessageCallback en su lugar. Para crear una propiedad de ejecución de flujo de trabajo, cree una clase que implemente la IExecutionProperty interfaz e implemente los miembros SetupWorkflowThread y CleanupWorkflowThread. Estos miembros le dan a la propiedad de ejecución la oportunidad de configurar y anular el almacenamiento local de subprocesos durante cada pulso de trabajo de la actividad que contiene la propiedad, incluidas las actividades secundarias. En este ejemplo, se crea un ConsoleColorProperty que establece el Console.ForegroundColor.

class ConsoleColorProperty : IExecutionProperty  
{  
    public const string Name = "ConsoleColorProperty";  
  
    ConsoleColor original;  
    ConsoleColor color;  
  
    public ConsoleColorProperty(ConsoleColor color)  
    {  
        this.color = color;  
    }  
  
    void IExecutionProperty.SetupWorkflowThread()  
    {  
        original = Console.ForegroundColor;  
        Console.ForegroundColor = color;  
    }  
  
    void IExecutionProperty.CleanupWorkflowThread()  
    {  
        Console.ForegroundColor = original;  
    }  
}  

Los autores de actividad pueden usar esta propiedad registrándola en el reemplazo de ejecución de la actividad. En este ejemplo, se define una actividad ConsoleColorScope que registra el ConsoleColorProperty al agregarlo a la colección Properties del NativeActivityContext actual.

public sealed class ConsoleColorScope : NativeActivity  
{  
    public ConsoleColorScope()  
        : base()  
    {  
    }  
  
    public ConsoleColor Color { get; set; }  
    public Activity Body { get; set; }  
  
    protected override void Execute(NativeActivityContext context)  
    {  
        context.Properties.Add(ConsoleColorProperty.Name, new ConsoleColorProperty(this.Color));  
  
        if (this.Body != null)  
        {  
            context.ScheduleActivity(this.Body);  
        }  
    }  
}  

Cuando el cuerpo de la actividad comienza un pulso de trabajo, se llama al método SetupWorkflowThread de la propiedad y cuando el pulso de trabajo ha finalizado, se llama a CleanupWorkflowThread. En este ejemplo, se crea un flujo de trabajo que usa una Parallel actividad con tres ramas. Las dos primeras ramificaciones usan la actividad ConsoleColorScope, y la tercera no. Las tres ramas contienen dos WriteLine actividades y una Delay actividad. Cuando la actividad Parallel se ejecuta, las actividades contenidas en las bifurcaciones se ejecutan de modo intercalado, aunque cuando cada actividad secundaria se ejecuta, ConsoleColorProperty aplica el color de la consola correcto.

Activity wf = new Parallel  
{  
    Branches =
    {  
        new ConsoleColorScope  
        {  
            Color = ConsoleColor.Blue,  
            Body = new Sequence  
            {  
                Activities =
                {  
                    new WriteLine  
                    {  
                        Text = "Start blue text."  
                    },  
                    new Delay  
                    {  
                        Duration = TimeSpan.FromSeconds(1)  
                    },  
                    new WriteLine  
                    {  
                        Text = "End blue text."  
                    }  
                }  
            }  
        },  
        new ConsoleColorScope  
        {  
            Color = ConsoleColor.Red,  
            Body = new Sequence  
            {  
                Activities =
                {  
                    new WriteLine  
                    {  
                        Text = "Start red text."  
                    },  
                    new Delay  
                    {  
                        Duration = TimeSpan.FromSeconds(1)  
                    },  
                    new WriteLine  
                    {  
                        Text = "End red text."  
                    }  
                }  
            }  
        },  
        new Sequence  
        {  
            Activities =
            {  
                new WriteLine  
                {  
                    Text = "Start default text."  
                },  
                new Delay  
                {  
                    Duration = TimeSpan.FromSeconds(1)  
                },  
                new WriteLine  
                {  
                    Text = "End default text."  
                }  
            }  
        }  
    }  
};  
  
WorkflowInvoker.Invoke(wf);  

Cuando se invoca el flujo de trabajo, la salida siguiente se escribe en la ventana de la consola.

Start blue text.  
Start red text.  
Start default text.  
End blue text.  
End red text.  
End default text.  

Los autores de actividad personalizados pueden usar las propiedades de ejecución del flujo de trabajo y también proporcionan el mecanismo para controlar la administración de las actividades como CorrelationScope y TransactionScope.

Consulte también

• IExecutionProperty
• IPropertyRegistrationCallback
• RegistrationContext