Workflow Foundation et les webservices

Dans notre série des articles de démonstration des différentes utilisations de Workflow Foundation, nous allons cette fois nous intéresser à l'utilisation de Workflow Foundation avec les Web Services ainsi que l'utilisation de Workflow Foundation en tant que Web Service.

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

Les applications d'aujourd'hui évoluent tous les jours et ces dernières années, les architectures d'applications sont souvent passées d'une architecture client-serveur ou n-tiers à une architecture SOA (Service Oriented Application).
Nous sommes aujourd'hui dans l'ère du Web Service omniprésent. Workflow Foundation est bien conscient de cette évolution et c'est pourquoi il permet d'interagir très finement avec des Web Services et est même capable d'en devenir un.

Les Web Services sont l'un des moyens de communication et d'échanges de données entre applications qui présentent bien souvent le plus d'avantages. De façon non exhaustive, un WS permet :
- d'avoir un moyen de communication multiplateformes (le remoting ne le permet pas),
- d'avoir un moyen de communication aisé (pas besoin d'ouvrir de port spécifique, permet de passer à travers les pare-feux),
- d'avoir un moyen de communication entre applications n'utilisant pas la même technologie (interopérabilité),
- d'utiliser des standards comme moyen de communication (SOAP par exemple),
- création facile, et mise à disposition (publication) rapide grâce aux outils de développements qui permettent de les déployer rapidement,
- et bien d'autres.

C'est à cause de cela que les applications d'aujourd'hui, de plus souvent en n-tiers, utilisent quasi systématiquement les Web Services, soit pour les appeler à distance, soit pour présenter une partie de ses fonctionnalités. Il était donc naturel que Workflow Foundation soit développé pour prendre en compte cela et puisse facilement utiliser le principe des Web Services.

Nous allons donc voir, au cours de cet article, comment Workflow Foundation permet de profiter pleinement, au sein d'applications distribuées, des Web Services.

1. L'interaction avec des Web Services

1.1. Consommation de Web Service

Pour cette première partie, nous allons voir le côté dit client de la chose, puisque nous serons dans le cas où c'est notre workflow qui consommera un Web Service distant.
J'avais pris un exemple simple pour l'article sur la persistance avec Workflow Foundation et j'ai donc décidé que nous prendrions un exemple sensiblement identique et simple. Le fait d'avoir un exemple trivial et sans fioriture nous permettra de nous concentrer sur l'essentiel, à savoir l'appel d'un workflow et l'utilisation de sa réponse.

Ainsi, nous allons partir d'un workflow qui sera chargé de faire cuire un aliment de notre choix (de type Food), et qui interrogera un Web Service pour obtenir le temps de cuisson en fonction du type de nourriture.

Classe Food
Sélectionnez

public class Food
{
    public string Type { get; set; }
}

1.2. Préparation du Web Service

Du côté " serveur " avec notre Web Service, nous créons simplement un projet de type ASP.Net Web Service pour y ajouter notre service ne contenant qu'une simple méthode : GetCookingTime

Notre Web Service
Sélectionnez

using System.Web.Services;

namespace developpez.com.workflow.ws
{
    [WebService(Namespace = "http://www.developpez.com/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    public class MonWebService : WebService
    {

        [WebMethod]
        public int GetCookingTime(string food)
        {
            switch(food)
            {
                case "egg":
                    return 120; // en secondes
                case "fish":
                    return 900;
                default:
                    return 300;
            }
        }
    }
}

Nous avons donc une méthode GetCookingTime prenant en paramètre une chaine correspondant au type de nourriture et qui nous renvoie le temps de cuisson en secondes. Il nous restera à le convertir en TimeSpan comme nous le verrons ensuite.

1.3. Utilisation de l'activité InvokeWebService

Maintenant que notre Web Service est prêt, il nous faut l'utiliser. La première idée pourrait être de le faire via le code, comme nous le ferions avec une application Webform ou WinForms standard; il ne suffirait en effet que de quelques lignes de code.
Malheureusement, cela ne serait pas utiliser le principe de Workflow et surtout l'avantage du designer qui permet à tout moment de déplacer les activités le long du workflow sans à avoir à modifier une ligne de code. Il nous faut donc trouver un moyen d'utiliser uniquement des activités pour faire cela.

Une fois encore, les créateurs de Workflow Foundation ont pensé à cela et nous ont concocté une activité dédiée à la consommation de Web Service : il s'agit de l'activité InvokeWebService (oui, le nom est assez évocateur pour une fois)

Créons dans la même solution, un projet de type Workflow Sequentiel via une application console. Puis, sur le designer, déposez une activité InvokeWebService.

Déposer l'activité aura pour effet d'ouvrir l'assistant d'ajout de référence Web. Cliquez alors sur local WebService pour trouver le Web Service que nous venons de créer :

Image non disponible

Puis cliquez sur votre Web Service

Image non disponible

Il ne vous reste plus qu'à nommer votre référence Web (sur la partie droite) en lui donnant le nom de votre choix.

Ensuite, dans les propriétés de votre activité (F4), choisissez la méthode de votre activité en définissant MethodName. A ce moment là, grâce au WSDL que vient de charger votre référence Web, la liste des paramètres de votre méthode, ainsi que le paramètre de retour, devrait apparaitre.

Image non disponible

Nous allons alors pour chaque paramètre (celui d'entrée FoodType, le paramètre de retour ReturnValue), créer des propriétés de dépendance. Cliquez à droite de chaque propriété pour ouvrir un assistant via lequel, vous créerez deux nouvelles propriétés Food et CookingTime (pour la valeur de retour):

Image non disponible

Cela devrait avoir rajouté du code à votre classe de workflow

 
Sélectionnez

 public static System.Workflow.ComponentModel.DependencyProperty FoodTypeProperty = DependencyProperty.Register("FoodType", typeof(System.String), 
 typeof(developpez.com.workflow.demo.MonWorkflow));

[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
[BrowsableAttribute(true)]
[CategoryAttribute("Parameters")]
public string FoodType
{
    get
    {
        return ((string)(base.GetValue(developpez.com.workflow.demo.MonWorkflow.FoodTypeProperty)));
    }
    set
    {
        base.SetValue(developpez.com.workflow.demo.MonWorkflow.FoodTypeProperty, value);
    }
}

public static DependencyProperty CookingTimeProperty = DependencyProperty.Register("CookingTime", typeof(System.Int32), 
typeof(developpez.com.workflow.demo.MonWorkflow));

[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
[BrowsableAttribute(true)]
[CategoryAttribute("Parameters")]
public Int32 CookingTime
{
    get
    {
        return ((int)(base.GetValue(developpez.com.workflow.demo.MonWorkflow.CookingTimeProperty)));
    }
    set
    {
        base.SetValue(developpez.com.workflow.demo.MonWorkflow.CookingTimeProperty, value);
    }
}

L'activité est maintenant pleinement configurée et utilisera la valeur de FoodType et assignera la valeur retournée par le Web Service à la propriété CookingTime. Voyons comment mettre en pratique cela

1.4. Mise en place du workflow

Si vous avez bien suivi les étapes, vous avez dans votre Visual Studio, une solution comprenant au moins, un projet de type Web Service, et un projet d'application console Workflow Foundation.

Et dans le fichier program.cs, vous avez le code suivant:

 
Sélectionnez

static void Main(string[] args)
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
    AutoResetEvent waitHandle = new AutoResetEvent(false);
    workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
    workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
    {
        Console.WriteLine(e.Exception.Message);
        waitHandle.Set();
    };

    WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(developpez.com.workflow.demo.MonWorkflow));
    instance.Start();

    waitHandle.WaitOne();
}
}

Code que nous allons modifier pour passer un paramètre à notre workflow. Rajoutez le code suivant pour créer une instance de la classe Food

 
Sélectionnez

    Food f = new Food { Type = "egg" };
    Dictionary<string, object> dic = new Dictionary<string, object>();
    dic.Add("food", f);

Puis modifiez la ligne de lancement du workflow

 
Sélectionnez

WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(developpez.com.workflow.demo.MonWorkflow),dic);

Ensuite, modifiez la classe de votre workflow pour y ajouter une propriété food

 
Sélectionnez

private Food _food;
public Food Food
{
    get{ return _food;}
    set { _food = value;
         FoodType = _food.Type; 
    }
}

En effet, nous avons passé notre objet à notre workflow, qui l'attribuera automatiquement à la propriété food mais pour le passer à notre Web Service, il faut que notre propriété FoodType puisse connaitre cette valeur. Le plus simple est alors de modifier son setter

Posez ensuite sur votre workflow deux CodeActivity et un Delay.

Image non disponible

Chaque CodeActivity affichera un message avec l'heure et l'état du workflow tandis que le delay représentera le temps de cuisson.

 
Sélectionnez

 private void StartTheCook(object sender, System.EventArgs e)
{
    Console.WriteLine("{0} - we start cooking {1}", DateTime.Now.ToShortTimeString(), Food.Type);
}

private void EndTheCook(object sender, System.EventArgs e)
{
    Console.WriteLine("{0} - {1} is cooked", DateTime.Now.ToShortTimeString(), Food.Type);
}

Pour finir, sur votre activité d'invocation de Web Service, abonnez-vous à l'évènement Invoked, qui se déclenche une fois la réponse du Web Service obtenue, et rajoutez-y le code qui mettra à jour l'activité de délai, en fonction du résultat obtenu :

 
Sélectionnez

 private void invokeWebServiceActivity1_Invoked(object sender, InvokeWebServiceEventArgs e)
{
    delayActivity1.TimeoutDuration = TimeSpan.FromSeconds(CookingTime);
}

Il ne nous reste plus qu'à lancer le projet et vérifier que la cuisson se passe comme convenu

Image non disponible

2. Workflow Foundation en tant que Web Service

Nous venons de voir que Workflow foundation pouvait consommer des Web Services en envoyant et en recevant des informations. Maintenant, nous allons voir qu'il est capable d'agir en tant que Web Service. Facile pourriez vous penser, il suffit de faire un Web Service lambda qui appelle une assembly contenant notre workflow.
Oui, je pense que ce serait très facilement faisable, mais niveau fiabilité, il y a sûrement mieux. Néanmoins, il arrivera peut-être un jour où vous aurez besoin de ce cas de figure. Cela ne signifie pas que vous avez fait de mauvais choix, j'indique seulement que si le seul intérêt de votre Web Service est d'utiliser un workflow, alors vous pouvez utiliser la solution qui suit.

Que penseriez-vous de l'idée d'un Workflow qui serait directement publié en tant que Web Service et sans à avoir à s'occuper de développer nous même la partie publique et toutes les WebMethods qu'il contient?
Et bien, c'est possible! Le meilleur de tout cela, c'est que c'est faisable très facilement simplement à l'aide de votre souris et de deux trois clics bien placés.

2.1. Le contrat

Comme tout "service" de communication, un contrat entre le client utilisant le service et le service lui-même est nécessaire. Ce contrat au niveau de votre workflow se fera via une interface. Nous prendrons un exemple simple en créant un workflow à qui vous passerez un objet (un Oeuf pour changer:)) et il sera chargé de le cuire avant de vous le rendre. J'interdis qui que ce soit de critiquer ce superbe exemple qui est totalement différent de celui du chapitre 1 ou encore de celui de l'article sur la persistance.
Passons donc à notre contrat. Créez un projet de type workflow séquentiel et créez à l'intérieur de celui-ci une nouvelle interface nommée ICooker.

Notre interface servant de contrat
Sélectionnez

interface ICooker
{
    Oeuf Cuire(Oeuf monOeuf); // Cuit l'oeuf 
}

Créons tout de suite notre classe Oeuf, qui doit être sérialisable puisqu'elle sera transmise au travers du protocole SOAP.

Classe Oeuf
Sélectionnez

[Serializable]
public class Oeuf
{
    public bool Cuit
    {
  	    get;
	    set;
    }
}

2.2. Préparation du workflow

La première chose à faire est de choisir dans la boite à outils d'activités de Worfklow Foundation, l'activité WebServiceInput et placez là au début de votre workflow séquentiel. Dans les propriétés de cette activité, commencez par configurer la propriété InterfaceType en allant choisir notre interface ICooker. Puis, configurez la propriété MethodName sur la méthode Cuire();

Vous pouvez remarquer la propriété IsActivating. Cette propriété, propre à l'activité WebServiceInput a un but bien précis, elle sert à démarrer un workflow lorsque l'activité WebServiceInput est appelée de l'extérieur. Cette propriété est censée être réglée sur True sur la première activité de type WebServiceInput de votre workflow. D'ailleurs, un custom validator vous le signal dans le designer grâce au petit point d'exclamation.

Vu que la méthode Cuire, prend un paramètre, Visual Studio nous a automatiquement indiqué qu'il attend un paramètre à lier à "monOeuf", le paramètre d'entrée de la méthode. Cliquez dans la fenêtre de propriété et créez un nouveau membre que vous pouvez appeler MonOeufCru.
Cela aura pour effet de générer le code suivant que vous commencez à comprendre puisqu'il s'agit d'une propriété liée à une propriété de dépendance :

 
Sélectionnez
public static DependencyProperty MonOeufCruProperty = DependencyProperty.Register("MonOeufCru", typeof(Oeuf),
                                                                                          typeof(Workflow1));

[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
    [Browsable(true)]
    [Category("Parameters")]
    public Oeuf MonOeufCru
    {
        get { return ((Oeuf)(base.GetValue(MonOeufCruProperty))); }
        set { base.SetValue(MonOeufCruProperty, value); }
    }

Tout est bien configuré et pourtant nous avons une erreur à la compilation. Que se passe-t-il? Tout simplement, l'utilisation d'une activité WebServiceInput va de pair avec une activité WebServiceOutput.
Placez donc une activité WebServiceOutput.

Cette fois-ci, la propriété souhaite que vous précisiez l'activité d'Input. Positionnez la propriété sur le nom de votre activité WebServiceInput. Puis, créez un nouveau membre nommé OeufCuit en tant que paramètre de retour. C'est ce membre qui sera retourné au travers le Web Service.

 
Sélectionnez
public static DependencyProperty MonOeufCuitProperty = DependencyProperty.Register("MonOeufCuit", typeof(Oeuf),
                                                                                           typeof(Workflow1));

[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
[Browsable(true)]
[Category("Parameters")]
public Oeuf MonOeufCuit
{
    get { return ((Oeuf)(base.GetValue(MonOeufCuitProperty))); }
    set { base.SetValue(MonOeufCuitProperty, value); }
}

A ce moment précis, nous avons placé un point d'entrée sur notre workflow et un point de sortie. Nous avons le membre qui récupèrera automatiquement l'objet passé au Web Service, ainsi que le membre retourné au client consommant le Web Service. Il reste une chose, le corps du workflow. En effet, on reçoit un Oeuf, on en retourne un autre, mais niveau cuisson, ce n'est pas encore ça.

Placez donc entre vos deux activités, une activité de type Code. Créez sur son événement Execute, une nouvelle méthode dans laquelle vous placerez le code se chargeant de cuire l'oeuf :

Méthode de cuisson
Sélectionnez

 private void Cuisson_ExecuteCode(object sender, EventArgs e)
{
    Oeuf o = MonOeufCru;
    o.Cuit = true;
    MonOeufCuit = o;
}

La méthode prend l'objet reçu, le cuit, puis l'assigne au membre qui sera retourné. Aussi simple que cela. Dites-vous simplement que le workflow pourrait être un processus complexe, entrainant énormément d'opérations métiers.

Voici à quoi ressemble le workflow final :

Image non disponible

2.3. Préparer le Web Service

"Quel Web Service?" vous demandez-vous. "Je croyais que c'était le workflow le Web Service?". C'est presque cela. Le workflow va générer une interface sous forme de Web Service qui permettra d'interagir directement avec lui. Pour se faire, cliquez à l'aide du bouton droit sur votre projet de workflow et choisissez Publier en tant que Service Web :

Image non disponible

2.4. Consommation de notre Workflow

Maintenant que tout est prêt, il ne nous reste plus qu'à appeler notre Web Service. Pour cela, créez rapidement un projet console basique, dans lequel vous ajouterez une référence à votre Web Service

Sur votre projet console, faites bouton droit > Ajouter Web Référence et faites comme le chapitre précédent. Si vous n'avez pas Web Référence, faites bouton droit, ajouter Service Référence. Dans la fenêtre qui s'ouvre, cliquez sur Avancé, puis en bas de la seconde fenêtre, sur Ajouter Référence Web. Vous devriez alors pouvoir là encore, faire comme le premier chapitre et chercher une référence vers votre Web Service autogénéré.

Une fois fait, dans la méthode Main(), rajoutez le code suivant, qui créé une instance d'Oeuf, et l'envoie au Web Service pour le récupéré cuit.

 
Sélectionnez

Oeuf egg= new Oeuf();
MonWebService.Workflow1_WebService ws = new Workflow1_WebService();

Console.WriteLine("L'oeuf est cuit : {0}",egg.Cuit);
egg = ws.Cuire(egg); // appel au WebService
Console.WriteLine("L'oeuf est cuit : {0}",egg.Cuit);

L'éxécution du projet nous le prouve :

Image non disponible

Nous venons donc de voir comment un workflow peut se voir exposé en tant que Web Service très facilement et les avantages que cela apporte. Plus besoin de créer un projet de Web Service spécifique, servant de wrapper autour de notre workflow, celui se charge lui même de générer l'interface entre le client et lui-même.

3. Conclusion

Workflow Foundation est apparu à un moment où les Web Services étaient omniprésents dans les applications distribuées. Il a su montrer qu'il s'avait s'intégrer parfaitement dans ce milieu n-tiers, soit en sachant consommer des Web Services distants, soit en se proposant soi-même en tant que Web Service facilement consommable.
Ce dernier principe permet notamment au développeur de se focaliser sur le respect des processus métiers via des workflows stricts, facilement utilisables par des applications clientes comme des clients légers ou lourds, des sites web ou encore d'autres services Web. Ce découpage permet encore mieux de découper les couches des applications en ayant la possibilité de découper les processus métiers et de le rendre utilisable à la demande.

4. Téléchargements et liens complémentaires

Pour télécharger les sources de cet article, cliquez ici

5. Remerciements

Je tiens à remercier ram-0000 pour ses corrections et conseils apportés à l'article

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2009 Louis-Guillaume Morand. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC.