Dans ce premier article, nous allons donner quelques règles simples de passage d’un modèle UML de niveau conception détaillée à du code C#.

Ces diagrammes sont le résultat de la modélisation de l'étude de cas décrite ci-après. La phase initiale de modélisation a été totalement occultée pour laisser place à la génération de code en C#. C'est pourquoi vous êtes directement confronté aux différents diagrammes UML résultant de la phase d'analyse et de modélisation. 

 Description de l'étude de Cas

Dans le cadre de l’amélioration qu’elle veut apporter à son système d’information, une entreprise souhaite modéliser, dans un premier temps, le processus de formation de ses employés afin que quelques-unes de leurs tâches soient informatisées.

1.       Le processus de formation est initialisé lorsque le responsable formation reçoit une demande de formation de la part d’un employé.
 Cette demande est instruite par le responsable qui la qualifie et transmet son accord ou son désaccord à l’intéressé.

2.       En cas d’accord, le responsable recherche dans le catalogue des formations agréées un stage qui correspond à la demande. Il informe l’employé du contenu de la formation et lui propose une liste des prochaines sessions. Lorsque l’employé a fait son choix, le responsable formation inscrit le participant à la session auprès de l’organisme de formation concerné.

3.       En cas d’empêchement, l’employé doit informer le responsable de formation au plus tôt pour annuler l’inscription ou la demande.

4.       À la fin de sa formation, l’employé doit remettre au responsable formation une appréciation sur le stage qu’il a effectué, ainsi qu’un document justifiant de sa présence.

5.       Le responsable formation contrôle par la suite la facture que l’organisme de formation lui a envoyée avant de la transmettre au comptable achats.

Nota : les exemples sont inspirés du livre : UML par la pratique, P. Roques, Eyrolles, 2001.

1.       Règles générales

Les diagrammes UML que nous utiliserons sont :

a) Les diagrammes de classes, qui permettent de décrire le squelette du code, à savoir toutes les déclarations.

En première approche :

• La classe UML devient une classe C#

• les attributs UML deviennent des variables d’instances C#

• les opérations UML deviennent des méthodes C#.

On notera que les rôles navigables produisent des variables d’instances, tout comme les attributs, mais avec un type utilisateur au lieu d’un type simple. Le constructeur par défaut est implicite.

Prenons un exemple simple pour illustrer les règles précédentes :

Figure 1. Squelette du code C# de la classe Livre

b) Les diagrammes d’interaction (séquence ou collaboration), qui permettent d’écrire le corps des méthodes, en particulier la séquence d’appels de méthodes sur les  objets qui collaborent.

L’exemple suivant illustre la correspondance entre la numérotation des messages dans un diagramme de collaboration et le code correspondant :

Figure 2. Corps de la méthode enregistrerEmprunteur

A partir de ces règles simples, nous allons maintenant donner quelques exemples concrets plus réalistes.

2.       Production du squelette de code C# à partir des diagrammes de classes UML

Prenons maintenant la figure 3, et concentrons-nous sur la classe DemandeDeFormation.

Figure 3.  La classe DemandeDeFormation et ses relations

Les règles précédentes suffisent pour produire le squelette de la classe en C#. La seule difficulté tient à ce qu’il ne faut pas oublier la directive d’importation pour les relations avec les classes qui appartiennent à d’autres packages, ainsi que pour les classes de base C#.

Le code C# correspondant est montré sur la figure 4.

On remarquera les directives d’importation ainsi que les quatre dernières méthodes qui permettent l’accès en lecture (get) et en écriture (set) aux attributs, pour respecter le principe d’encapsulation. C# nous permet de coder les accesseurs de manière élégante à l'aide de propriétés (Property). L'exemple suivant reste proche du diagramme et n'utilise pas les propriétés C#. A l'avenir, l'ensemble des outils de génération de code (Rational Rose, Visio, Objecteering, ..) permettront de mapper un attribut en lecture/écriture en propriété C#. 

Figure  Squelette de code C# de la classe )

 Avec des propriétés C#, vous aurions eu :

public int propDateValidite
  {
    get { return DateValidite; } //this is property get for propDateValidite
    set { DateValidite=value; }  //this is property set for propDateValidite
  } 

Intéressons-nous à présent à la figure 5 en nous concentrant sur classe Formation.

Figure 5.  La classe Formation avec ses relations

Quelques difficultés supplémentaires apparaissent, par rapport à l’exemple précédent :

• la relation de généralisation avec ElementCatalogue,

• les multiplicités « 1..* » avec Theme et « 0..* {ordered} » avec Session.

Les règles précédentes ne suffisent plus. Nous avons vu un exemple de transformation d’une association navigable de multiplicité « 1 » (ou « 0..1 »), mais comment traduire les associations navigables de multiplicité « * » ?

Le principe est relativement simple : une multiplicité « * » va se traduire par un attribut de type collection de références d’objets au lieu d’une simple référence sur un objet.

La difficulté consiste à choisir la bonne collection parmi les très nombreuses classes de base que propose C#. Bien qu’il soit possible de créer des tableaux d’objets en C#, ce n’est pas forcément la bonne solution. En la matière, on préfère plutôt recourir à des collections, parmi lesquelles les plus utilisées en C# sont ArrayList et HashTable. Utilisez ArrayList si vous devez respecter un ordre et récupérer les objets à partir d’un indice entier ; utilisez HashMap ou SortedList si vous souhaitez récupérer les objets à partir d’une clé arbitraire.

Voici quelques exemples des solutions à retenir pour effectuer un choix pertinent :

Figure  Traductions possibles des associations en C#

Pour la classe Formation, nous allons utiliser :

• une ArrayList pour l’association ordonnée avec la classe Session,

• une HashTable pour l’association avec la classe Theme, plutôt qu’un simple tableau : nous nous servirons du nom de thème comme qualificatif.

Toutes ces explications nous conduisent au code suivant pour la classe Formation.

Figure  Squelette de code C# de la classe Formation

Les outils de génération de code

Visual Studio .NET propose dans sa version Architect la possibilité de créer ses diagrammes directement  dans l'outil avec MS Visio. Un partenariat existe entre Microsoft et Rational concernant l'intégration de Rose dans VS.NET, ça ne saurait tarder !

Conclusion

La génération de code à partir des différents diagramme est une opération délicate qu'il faut maîtriser. Ainsi, en fonction du langage cible utilisé (Java ou C#), le mapping entre les différents types et les spécificités de chaque langages (propriétés en C#, Date, ...) auront un impact plus ou moins grand. Les outils doivent prendre en charge cette opération de génération de code en prenant soin de proposer différentes alternatives (ArrayList ou HashTable) à l'utilisateur. 

Auteur : Pascal Roques