Création d'activités personnalisées avec Workflow Foundation

Ouvrez Visual Studio et assurez-vous d'avoir installé les extensions pour Workflow Foundation, surtout si vous utilisez Visual Studio 2005. Créez un nouveau projet d'activité: Fichier > Nouveau > Projet > Workflow Activity Library. Renommez l'activité de base par le nom de l'activité personnalisée que vous utiliserez au long de cet article. Je vous propose pour commencer d'utiliser un simple « MonActivite ». Vous obtenez alors le code suivant :

public partial class MonActivite: SequenceActivity
{
    public MonActivite()
    {
        InitializeComponent();
    }
}

Vous remarquerez que votre activité hérite de SequenceActivity. Cela signifie que vous créez une activité séquentielle qui exécutera des activités enfants les unes après les autres. En effet, SequenceActivity hérite de CompositeActivity qui hérite lui-même d'Activity. Une activité composite est justement une activité qui peut contenir des enfants comme une BranchActivity* par exemple. (* activité déjà existante au sein de WF)

Bien sûr, libre à vous de n'hériter que de la classe Activity si votre activité n'en a pas besoin. Dans notre cas, notre activité ne fera qu'envoyer un mail et nous pouvons donc n'hériter que de Activity.

Nous allons maintenant rajouter deux propriétés Comment et StatusID, le second se basant sur une énumération correspondant aux statuts en base. L'énumération sert à la validation des ID, mais surtout à une sélection facilitée grâce à l'attribut Description de chaque valeur.

public enum WorkflowStatus
{
    [Description("Workflow is not started")]
    Unstarted = 0,
    [Description("Workflow is started")]
    Started = 1,
    [Description("Workflow is waiting for an operation")]
    Waiting = 2,
    [Description("Workflow finished normally")]
    Finished = 3,
    [Description("Workflow has been aborted")]
    Aborted = 4
}

Ainsi, nous allons enregistrer deux propriétés de dépendances CommentProperty et StatusProperty qui seront utilisées par nos propriétés.

public static DependencyProperty CommentProperty = DependencyProperty.Register("Comment", typeof(string), typeof(MonActivite));
public static DependencyProperty StatusIDProperty = DependencyProperty.Register("StatusID", typeof(WorkflowStatus), typeof(MonActivite));

[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string Comment
{
    get
    {
        return ((string)(base.GetValue(MonActivite.CommentProperty)));
    }
    set
    {
        base.SetValue(MonActivite.CommentProperty, value);
    }
}

[Browsable(true)]
[Category("Developpez")]
[Description("The status to log")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public WorkflowStatus StatusID
{
    get
    {
        return ((WorkflowStatus)(base.GetValue(MonActivite.StatusIDProperty)));
    }
    set
    {
        base.SetValue(MonActivite.StatusIDProperty, value);
    }
}

Nous allons maintenant définir notre code métier, à savoir le code d'envoi de mail. Ce code peut être une méthode interne à l'activité.

Voici notre méthode toute simple : on envoie un mail à l'administrateur du workflow pour lui signifier l'état courant du workflow ainsi qu'un commentaire.

private void SendMail()
{
    MailMessage mail = new MailMessage("workflow@dvp.com", "admin@dvp.com")
                       {
                           Subject =
                               String.Format("WORKFLOW - {0}",
                                             Enum.GetName(typeof (WorkflowStatus), StatusID)),
                                             Body = this.Comment
                                           
                       };
    SmtpClient smtp = new SmtpClient("smtp.free.fr");
    smtp.Send(mail);
}

Il nous reste maintenant à appeler cette méthode. Bien entendu, cela ne se fait pas n'importe comment ni surtout, à n'importe quel moment.

Une activité a un cycle de vie particulier, elle est instanciée à un certain moment, ses méthodes sont appelées soit à l'initialisation de l'instance du workflow, soit lors de son exécution. Voici les différentes étapes du cycle de vie :
- OnActivityExecutionContextLoad ;
- Initialize ;
- Execute ;
- Uninitialize ;
- OnActivityExecutionContextUnload ;
- Dispose.

Généralement, deux étapes conviennent à l'injection du code métier. L'étape Initilize qui se déclenche dès que l'on crée une instance du workflow

WorkflowInstance instance = runtime.CreateWorkflow(typeof(Workflow1));

Et l'étape Execute, qui se déclenche lorsque le workflow « passe » par cette activité et l'exécute.

Dans notre cas, c'est l'étape Execute qui nous intéresse, car le but de notre activité est d'envoyer un mail à un moment spécifique de notre workflow séquentiel, là où nous aurons placé notre activité personnalisée.
Pour utiliser cette méthode, nous allons simplement la surcharger et laisser le workflow l'appeler. Nous allons ensuite pouvoir librement insérer l'appel à notre méthode SendMail et préciser que l'activité a fini son travail. Le fait de retourner le statut Closed précise au moteur de workflow qu'il peut passer à l'activité suivante.
Voici le code produit :

protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
    // on envoie le mail
    SendMail();

    return ActivityExecutionStatus.Closed; // puisque notre activité a fini tout son traitement

}

Maintenant que notre activité est prête, nous allons l'utiliser. Pour cela, créez un nouveau projet de type Workflow séquentiel dans une autre solution. Ouvrez le Workflow en mode designer et ouvrez le panneau latéral de boite à outils contenant les activités disponibles. Cliquez à l'aide du bouton droit sur le panneau des activités et choisissez le menu Choisir les éléments.

Votre activité n'est probablement pas présente dans la liste. Cliquez alors sur Parcourir et allez chercher la dll qui a été générée par votre projet. Une fois sélectionnée, l'(ou les) activité(s) devrai(en)t apparaitre et être cochée(s). Cliquez encore une fois sur OK pour voir se fermer la fenêtre et apparaitre le nom de votre activité.

Nous venons de voir comment notre activité peut apparaitre dans la boite à outils. Pour rendre cela un peu plus professionnel, et surtout pouvoir distinguer les activités par leur icône, comme vous le faites habituellement pour les contrôles, il nous suffit d'ajouter un attribut ToolboxBitmap

[ToolboxBitmap(typeof(MonActivite), "MyActivity.ico")]
public partial class MonActivite : Activity
{
    ...

MyActivity.ico est une image qui devra être placée dans la solution et mise en ressource intégrée. Pour ce faire, cliquez sur l'image dans l'arborescence puis, dans la fenêtre des propriétés, choisissez Ressource Intégrée pour la propriété Action de compilation.

Et c'est tout pour l'icône.

Lorsque l'on développe, que ce soit un composant réutilisable comme une activité, un custom contrôle ou simplement une ligne de code, il ne faut pas penser à comment nous pourrons l'utiliser, mais également comment un autre développeur pourra l'utiliser. Oui, il y aura toujours quelqu'un pour reprendre votre code et cette personne se demandera à chaque fois « à quoi sert cela ? ». C'est donc le rôle du premier développeur de faire en sorte que les développeurs suivants puissent comprendre et utiliser son code ou ses composants. Dans le cas d'une activité personnelle, il convient alors de documenter son code, mais également d'ajouter des petites aides visuelles comme les tooltips.

Pour ajouter un tooltip, dit aussi une infobulle, dans le fichier de votre activité perso, créez une nouvelle classe héritant d'ActivityDesigner

public class MyActivityDesigner : ActivityDesigner
{
   ...
}

Créez ensuite une méthode du nom de votre choix, dans laquelle vous appellerez la méthode héritée ShowInfoTip. Dans mon exemple, le texte est défini dynamiquement et je me sers de la description éventuellement saisie par le développeur dans les propriétés de l'activité pour ajouter un peu plus d'informations.

private void ToolTip()
{
    const string title = "Developpez - Status Activity";
    string text = "Change the status of the demand when activity is fired";
    if (!string.IsNullOrEmpty(Activity.Description))
        text += "\r\n\r\n" + Activity.Description;
    ShowInfoTip(title, text);
}

Pour finir, dans la classe créez, surchargez les trois méthodes OnMouseEnter, OnMouseHover et OnMouseMove, et appelez votre méthode :

protected override void OnMouseEnter(System.Windows.Forms.MouseEventArgs e)
{
    ToolTip();
}
protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
{
    ToolTip();
}
protected override void OnMouseHover(System.Windows.Forms.MouseEventArgs e)
{
    ToolTip();
}

Ajoutez également un attribut sur la classe de votre activité pour qu'il charge votre designer nouvellement créé :

[Designer(typeof(MyActivityDesigner),typeof(IDesigner))]
 public partial class MyActivity: SequenceActivity

Dorénavant, lorsque votre souris passera au-dessus de l'activité, une bulle d'information s'affichera

La dernière chose à améliorer est la reconnaissance visuelle de notre activité sur le designer de Workflow. En effet, reconnaitre notre activité par son icône n'est pas le moyen le plus rapide pour notre cerveau. Mémoriellement, notre cerveau est plus rapide à associer des formes et surtout des couleurs à une information, que ne le fait une description textuelle. C'est pourquoi nous allons changer l'apparence visuelle de notre activité.
Nous allons changer les couleurs de notre activité, à la fois le fond, le conteur et la couleur de la police utilisée.

Pour cela, créez une classe interne et scellée héritant de ActivityDesignerTheme

internal sealed class MyActivityDesignerTheme : ActivityDesignerTheme
{
    ...
}

Puis définissez le constructeur :

public MyActivityDesignerTheme(WorkflowTheme theme): base(theme)
{
    ...
}

Dans lequel, vous n'avez qu'à redéfinir les propriétés d'affichage qui seront utilisées pour dessiner votre activité :

public MyActivityDesignerTheme(WorkflowTheme theme): base(theme)
{
    BackColorEnd = Color.Pink;
    BackColorStart = Color.GreenYellow;
    BackgroundStyle = LinearGradientMode.ForwardDiagonal;
    ForeColor = Color.Black;
}

Enfin, puisque nous venons créer un thème pour designer, nous devrons dire à notre Designer créé juste avant de charger ce thème. Pour cela, ajoutez l'attribut ActivityDesignerThemeAttribute sur votre classe MyActivityDesigner :

[ActivityDesignerThemeAttribute(typeof(MyActivityDesignerTheme))]
public class MyActivityDesigner : ActivityDesigner
{
    ...
}

Il nous reste plus qu'à admirer le résultat, certes peu joli dans mon cas, mais totalement personnalisable comme le montre l'exemple donné :

Dans le cas où votre activité est une activité qui peut en contenir d'autres (vous héritez donc non plus de la classe Activity, mais de la classe SequentialActivity), vous souhaitez peut-être pouvoir contrôler le type d'activité qui sera autorisé à être inséré dans votre activité.

Afin de faire cela, il faut procéder en deux temps.

En premier lieu, il faut modifier notre activité afin qu'elle hérite de SequentialActivity.
Ensuite nous allons redéfinir la méthode void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity) afin de vérifier le type de l'activité ajoutée.

protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
{
    if( !(addedActivity is MychildActivity) )
        throw new ArgumentException("addedActivity");
    base.OnActivityChangeAdd(executionContext, addedActivity);
}

Mais laisser cela dans cet état pose problème. En effet rien ne vous empêche de drag/droper une activité du mauvais type, le résultat sera une exception, ce qui, disons-le, n'est pas super pratique.
Afin de combler cette lacune nous allons modifier la classe designer associée à notre activité afin qu'elle hérite de la classe SequentialActivityDesigner.

L'étape suivante est de trouver un moyen pour que le drag/drop ne soit autorisé que si l'activité en cours de drap/drop est du bon type. Heureusement le framework .NET est bien conçu :)

public class MyActivityDesigner : SequentialActivityDesigner
{
    public override bool CanInsertActivities(HitTestInfo insertLocation, 
    System.Collections.ObjectModel.ReadOnlyCollection<System.Workflow.ComponentModel.Activity> activitiesToInsert)
    {
        foreach (System.Workflow.ComponentModel.Activity activity in activitiesToInsert)
        {
            if (!(activity is MyActivity))
                return false;
        }

        return base.CanInsertActivities(insertLocation, activitiesToInsert);
    }
}

La méthode CanInsertActivties du designer est appelée à chaque fois qu'une ou plusieurs activités sont insérées grâce au designer.

La première, et à vrai dire la seule chose à faire dans notre exemple, c'est de créer une classe qui hérite de SequentialWorkflowActivity

[Designer(typeof(MySequentialWorkflowActivityDesigner), typeof(IRootDesigner)), ToolboxItem(false)]
public class MySequentialWorkflowActivity : SequentialWorkflowActivity
{
}

Nous avons notre activité root de perte. Dans cet exemple simple, nous nous contentons de redéfinir le designer associé à l'activité. Il va sans dire que vous pouvez enrichir cette activité, notamment en personnalisant son comportement lors de l'exécution.

Afin de personnaliser la façon dont notre activité root va être affichée nous allons redéfinir le designer associé en créant une classe qui hérite de SequentialWorkflowRootDesigner
Cet héritage va nous permettre d'accéder à certaines propriétés marquées « protected » et surtout de modifier le comportement d'autres.

public class RefreshSequentialWorkflowActivityDesigner : SequentialWorkflowRootDesigner
{
    
    protected override void Initialize(System.Workflow.ComponentModel.Activity activity)
    {
        base.Initialize(activity);

        this.Header.Text = "Mon super designer de workflow !";
    }

    public override System.Collections.ObjectModel.ReadOnlyCollection<DesignerView> Views
    {
        get
        {
            return new System.Collections.ObjectModel.ReadOnlyCollection<DesignerView>(new DesignerView[] { base.Views[0] });
        }
    }
}

La partie intéressante de ce code se situe dans la redéfinition de la propriété Views.
En effet dans notre cas nous empêchons l'affichage des deux autres vues créées par défaut, mais rien ne vous empêche de définir votre propre vue et de l'ajouter ici.

L'autre petite « customisation » vient du changement du titre affiché dans le designer.