Compartilhar via

Propriedades de execução do fluxo de trabalho

Por meio do TLS (armazenamento local de thread), o CLR mantém um contexto de execução para cada thread. Esse contexto de execução rege propriedades de thread conhecidas, como a identidade do thread, a transação de ambiente e o conjunto de permissões atual, além de propriedades de thread definidas pelo usuário, como slots nomeados.

Ao contrário dos programas direcionados diretamente ao CLR, os programas de fluxo de trabalho são árvores de atividades com escopo hierárquico que são executadas em um ambiente que não depende de threads. Isso implica que os mecanismos TLS padrão não podem ser usados diretamente para determinar qual contexto está no escopo de um determinado item de trabalho. 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.

As propriedades de execução do fluxo de trabalho fornecem um mecanismo para adicionar propriedades específicas de contexto ao ambiente de uma atividade. Isso permite que uma atividade declare quais propriedades estão no escopo de sua subárvore e também fornece ganchos para configurar e derrubar o TLS para interoperar corretamente com objetos CLR.

Criando e usando propriedades de execução de fluxo de trabalho

As propriedades de execução do fluxo de trabalho geralmente implementam a IExecutionProperty interface, embora as propriedades focadas no sistema de mensagens possam implementar ISendMessageCallback e IReceiveMessageCallback , em vez disso. Para criar uma propriedade de execução de fluxo de trabalho, crie uma classe que implemente a IExecutionProperty interface e implemente os membros SetupWorkflowThread e 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. Neste exemplo, é criado um ConsoleColorProperty que define o 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. Nesse exemplo, uma atividade de ConsoleColorScope é definida que registra ConsoleColorProperty adicionando à coleção de Properties de NativeActivityContextatual.

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. Neste exemplo, um fluxo de trabalho é criado que usa uma Parallel atividade com três branches. As duas primeiras ramificações usam a atividade ConsoleColorScope, e a terceira ramificação não. Todos os três ramificações contêm duas atividades de WriteLine e uma atividade de Delay . 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.

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 é invocado, a saída a seguir é gravada na janela do console.

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

Observação

Embora não seja mostrado na saída anterior, cada linha de texto na janela do console é exibida na cor indicada.

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 .

Consulte também