Propriedades de execução de fluxo de trabalhoWorkflow Execution Properties

Com o armazenamento local (TLS) de segmento, CLR mantém um contexto de execução para cada segmento.Through thread local storage (TLS), the CLR maintains an execution context for each thread. Este contexto de execução determina propriedades de segmento conhecidos como a identidade da thread, a transação ambiente, e o conjunto de permissões atual além de propriedades definidos pelo usuário do segmento como slots nomeados.This execution context governs well-known thread properties such as the thread identity, the ambient transaction, and the current permission set in addition to user-defined thread properties like named slots.

Ao contrário dos programas que direcionam diretamente CLR, os programas de fluxo de trabalho são árvores hierarquicamente o escopo de atividades que executam em um ambiente com desconhecido.Unlike programs directly targeting the CLR, workflow programs are hierarchically scoped trees of activities that execute in a thread-agnostic environment. Isso significa que os mecanismos padrão de TLS diretamente não podem ser usados para determinar qual contexto está no escopo de um item de trabalho determinado.This implies that the standard TLS mechanisms cannot directly be used to determine what context is in scope for a given work item. Por exemplo, duas ramificações paralelos de execução podem usar transações diferentes, porém o agendador pode intercalar sua execução no mesmo segmento de CLR.For example, two parallel branches of execution might use different transactions, yet the scheduler might interleave their execution on the same CLR thread.

As propriedades de execução de fluxo de trabalho fornecem um mecanismo para adicionar propriedades específicas de contexto para o ambiente de uma atividade.Workflow execution properties provide a mechanism to add context specific properties to an activity’s environment. Isso permite que uma atividade declare propriedades que estejam no escopo para sua subárvore e também fornece ganchos para configurar e rasgar para baixo TLS para interoperar corretamente com objetos CLR.This allows an activity to declare which properties are in scope for its sub-tree and also provides hooks for setting up and tearing down TLS to properly interoperate with CLR objects.

Criando e usando propriedades de execução de fluxo de trabalhoCreating and Using Workflow Execution Properties

As propriedades de execução de fluxo de trabalho geralmente implementam a interface de IExecutionProperty , embora as propriedades centradas sobre a mensagem podem implementar ISendMessageCallback e IReceiveMessageCallback em vez disso.Workflow execution properties usually implement the IExecutionProperty interface, though properties focused on messaging may implement ISendMessageCallback and IReceiveMessageCallback instead. Para criar uma propriedade de execução de fluxo de trabalho, crie uma classe que implementa a interface de IExecutionProperty e implementar os membros SetupWorkflowThread e CleanupWorkflowThread.To create a workflow execution property, create a class that implements the IExecutionProperty interface and implement the members SetupWorkflowThread and CleanupWorkflowThread. Esses membros fornecem a propriedade de execução com uma oportunidade para configurar e rasgar corretamente para baixo o armazenamento local de segmentos durante cada pulso de trabalho de atividade que contém a propriedade, incluindo todas as atividades filhos.These members provide the execution property with an opportunity to properly set up and tear down the thread local storage during each pulse of work of the activity that contains the property, including any child activities. Nesse exemplo, ConsoleColorProperty é criado que define Console.ForegroundColor.In this example, a ConsoleColorProperty is created that sets the 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;  
    }  
}  

Os autores de atividade podem usar essa propriedade para à atividade executam substituição.Activity authors can use this property by registering it in the activity’s execute override. Nesse exemplo, uma atividade de ConsoleColorScope é definida que registra ConsoleColorProperty adicionando à coleção de Properties de NativeActivityContextatual.In this example, a ConsoleColorScope activity is defined that registers the ConsoleColorProperty by adding it to the Properties collection of the current NativeActivityContext.

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

Quando o corpo da atividade inicia um pulso de trabalho, o método de SetupWorkflowThread da propriedade é chamado, e quando o pulso de trabalho estiver concluída, CleanupWorkflowThread é chamado.When the activity’s body starts a pulse of work, the SetupWorkflowThread method of the property is called, and when the pulse of work is complete, the CleanupWorkflowThread is called. Nesse exemplo, um fluxo de trabalho é criado que usa uma atividade de Parallel com três ramificações.In this example, a workflow is created that uses a Parallel activity with three branches. Os primeiros dois ramificações usam a atividade de ConsoleColorScope e o terceiro ramificação não.The first two branches use the ConsoleColorScope activity and the third branch does not. Todos os três ramificações contêm duas atividades de WriteLine e uma atividade de Delay .All three branches contain two WriteLine activities and a Delay activity. Quando a atividade de Parallel executa, as atividades que estão contidas nas ramificações executam em uma maneira intercalada, mas como cada atividade filho executa a cor correta do console são aplicadas por ConsoleColorProperty.When the Parallel activity executes, the activities that are contained in the branches execute in an interleaved manner, but as each child activity executes the correct console color is applied by the ConsoleColorProperty.

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

Quando o fluxo de trabalho é chamado, a saída a seguir são gravadas para a janela do console.When the workflow is invoked, the following output is written to the console window.

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

Observação

Embora não são mostradas na saída anteriores, cada linha de texto na janela de console é exibida na cor indicada.Although it is not shown in the previous output, each line of text in the console window is displayed in the indicated color.

As propriedades de execução de fluxo de trabalho podem ser usadas por autores personalizados de atividade, e também fornecem um mecanismo para o gerenciamento de forma para atividades como as atividades de CorrelationScope e de TransactionScope .Workflow execution properties can be used by custom activity authors, and they also provide the mechanism for handle management for activities such as the CorrelationScope and TransactionScope activities.

Confira tambémSee also