Propriétés d'exécution de workflow
Par le biais du stockage local des threads (TLS), le CLR maintient un contexte d’exécution pour chaque thread. Ce contexte d’exécution gouverne des 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 qui ciblent directement le CLR, les programmes de workflow sont hiérarchiquement des arborescences de portée d'activités qui s'exécutent dans un environnement de thread agnostique. Cela implique que les mécanismes de TLS standard ne peuvent pas être utilisés directement pour déterminer quel contexte se trouve dans la portée 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 de CLR.
Les propriétés d'exécution de workflow fournissent un mécanisme permettant d'ajouter des propriétés spécifiques au contexte à 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 de propriétés d'exécution de workflow
Les propriétés d'exécution du workflow implémentent généralement l'interface IExecutionProperty, même si les propriétés axées sur la messagerie peuvent implémenter ISendMessageCallback et IReceiveMessageCallback à la place. Pour créer une propriété d'exécution de workflow, créez une classe qui implémente l'interface IExecutionProperty et qui 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, ConsoleColorProperty est créé afin de définir 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é commence une impulsion de travail, la méthode SetupWorkflowThread de la propriété est appelée, et quand l'impulsion de travail est terminée, la méthode CleanupWorkflowThread est appelée. Dans cet exemple, un workflow est créé afin d’utiliser une activité Parallel avec trois branches. Les deux premières branches utilisent l'activité ConsoleColorScope, contrairement à la troisième branche. 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 workflow 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.
Notes
Bien que cela ne soit pas visible dans la sortie précédente, chaque ligne de texte contenue dans la fenêtre de console est affichée dans la couleur indiquée.
Les propriétés d'exécution de workflow peuvent être utilisées par les auteurs d'activités personnalisées, tout en fournissant également le mécanisme nécessaire pour gérer les activités telles que les activités CorrelationScope et TransactionScope.
