Partager via

Propriétés d’exécution du flux de travail

Par le biais du stockage local de threads (TLS), le CLR gère un contexte d’exécution pour chaque thread. Ce contexte d’exécution régit les propriétés de thread connues telles que l’identité de thread, la transaction ambiante et le jeu d’autorisations actuel en plus des propriétés de thread définies par l’utilisateur, comme les emplacements nommés.

Contrairement aux programmes ciblant directement le CLR, les programmes de flux de travail sont des arborescences hiérarchiquement délimitées d’activités qui s’exécutent dans un environnement indépendant du thread. Cela implique que les mécanismes TLS standard ne peuvent pas être utilisés directement pour déterminer quel contexte est dans l’étendue d’un élément de travail donné. Par exemple, deux branches parallèles d’exécution peuvent utiliser des transactions différentes, mais le planificateur peut entrelacer leur exécution sur le même thread CLR.

Les propriétés d’exécution de flux de travail fournissent un mécanisme permettant d’ajouter des propriétés spécifiques au contexte dans l’environnement d’une activité. Ainsi, une activité peut déclarer les propriétés incluses dans la portée pour la sous-arborescence associée, tout en fournissant des connexions pour la configuration et la destruction de TLS afin d’interagir correctement avec les objets CLR.

Création et utilisation des propriétés d’exécution de flux de travail

Les propriétés d’exécution du flux de travail implémentent généralement l’interface IExecutionProperty, bien que les propriétés axées sur la messagerie puissent implémenter ISendMessageCallback et IReceiveMessageCallback à la place. Pour créer une propriété d’exécution de flux de travail, créez une classe qui implémente l’interface IExecutionProperty et implémente les membres SetupWorkflowThread et CleanupWorkflowThread. Ces membres fournissent à la propriété d'exécution la possibilité de configurer et détruire correctement le stockage local des threads lors de chaque impulsion de travail de l'activité qui contient la propriété, y compris ses activités enfants. Dans cet exemple, un ConsoleColorProperty est créé pour définir le 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;  
    }  
}

Les auteurs d'activité peuvent utiliser cette propriété en l'inscrivant dans la substitution d'exécution de l'activité. Dans cet exemple, une activité ConsoleColorScope est définie afin d'inscrire ConsoleColorProperty en l'ajoutant à la collection Properties du contexte NativeActivityContext actuel.

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

Lorsque le corps de l’activité démarre une impulsion de travail, la méthode SetupWorkflowThread de la propriété est appelée, et lorsque l’impulsion de travail est terminée, la méthode CleanupWorkflowThread est appelée. Dans cet exemple, un flux de travail est créé qui utilise une Parallel activité avec trois branches. Les deux premières branches utilisent l’activité ConsoleColorScope et la troisième branche ne le fait pas. Les trois branches contiennent deux activités WriteLine et une activité Delay. Lorsque l’activité Parallel est exécutée, les activités contenues dans les branches sont exécutées de façon entrelacée, et lors de l’exécution de chaque activité enfant, la couleur de console correcte est appliquée par 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);

Lorsque le flux de travail est appelé, la sortie suivante est écrite dans la fenêtre de console.

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

Remarque

Bien qu’elle ne soit pas affichée dans la sortie précédente, chaque ligne de texte de la fenêtre de console s’affiche dans la couleur indiquée.

Les propriétés d’exécution de flux de travail peuvent être utilisées par les auteurs d’activités personnalisées, et elles fournissent également le mécanisme de gestion des poignées pour des activités telles que les activités CorrelationScope et TransactionScope.

Voir aussi

  • Last updated on