Académique Documents
Professionnel Documents
Culture Documents
Création D'application D'entreprise PDF
Création D'application D'entreprise PDF
Sommaire
Création d’application d’entreprise ..................................................................................................... 1
1 Introduction ..................................................................................................................................... 3
1.1 Préface & Public de ce tutorial ................................................................................................ 3
2 Une spécification pour développeur ............................................................................................... 4
2.1 Définition du mot spécification dans cet ouvrage .................................................................. 4
2.2 L’intérêt d’une spécification .................................................................................................... 4
2.3 Les outils .................................................................................................................................. 4
3 Le cycle de vie du projet .................................................................................................................. 5
3.1 Cycle de vie en V ...................................................................................................................... 5
3.2 Cycle de vie incrémental ......................................................................................................... 6
4 Etudes des besoins d’un projet ....................................................................................................... 7
4.1 Savoir écouter le client ............................................................................................................ 7
4.2 Interpréter les besoins du client ............................................................................................. 7
5 L’architecture du système ............................................................................................................... 8
5.1 Choix du type de client ............................................................................................................ 8
5.2 Les services .............................................................................................................................. 9
5.3 Modélisation de l’architecture logicielle ............................................................................... 10
5.4 Déduction de l’architecture matérielle ................................................................................. 12
6 Les choix techniques...................................................................................................................... 13
6.1 Choisir la version du Framework ........................................................................................... 13
6.2 Choisir les technologies d’accès aux données ....................................................................... 14
6.3 Choisir le langage................................................................................................................... 15
6.4 Choisir l’EDI ........................................................................................................................... 15
6.5 Choisir le stockage de données ............................................................................................. 16
7 Etablir une maquette de l’IHM ...................................................................................................... 17
8 Modélisation de la base de données............................................................................................. 18
8.1 Diagrammes ORM ................................................................................................................. 18
8.2 Générer le schéma de votre base de données ...................................................................... 19
9 Représentations objets ................................................................................................................. 21
9.1 Diagrammes de cas d’utilisation / Etudes des acteurs et scénarii ........................................ 22
9.2 Diagrammes de paquetages & Composants ......................................................................... 23
Date
2 Création d’application d’entreprise
Date
3 Création d’application d’entreprise
1 Introduction
Mettre ses idées sur papier, imposer des formalismes et des processus vous permettront de
réaliser un travail de qualité.
Ce livre d’entrainement intervient dans le cursus certifiant MCPD 2.0 et 3.5 (« Microsoft
Certified Professional Developer »), saint graal des certifications .NET au sein de Microsoft.
De par leurs expériences, Bertrand Vergnault & Laurent Assis-Arantes (Développeur .NET,
MCPD) m’aideront activement à écrire ce tutorial.
Le public de ce livre devra connaître la base du développement en .NET et avoir des notions de
Winforms, ASP .NET, Services…
Date
4 Création d’application d’entreprise
Dans cet ouvrage nous allons nous intéresser à une spécification au sens « large » du terme, ce
qui est souvent le cas lors de projets où le développeur est lui-même le chef de projets. Nous allons
voir comment il est possible, en un seul document, d’architecturer notre SI.
Le problème était que les directeurs ne souhaitaient pas dépenser de l’argent pour une
analyse qu’ils trouvaient sans intérêts. On se retrouvait avec :
Vous remarquerez que sur ces trois points, l’entreprise perd de l’argent.
Microsoft Visual Studio 2008 Team System Architect Edition, nous permettant de créer
l’architecture logicielle de notre SI.
Team Foundation Server & Windows Sharepoint Services, pour le travail collaboratif.
Microsoft Visio 2007, pour la modélisation objet.
NUnit, pour les tests unitaires.
Microsoft Office Project 2007, pour la gestion du temps.
Date
5 Création d’application d’entreprise
Cycle de vie en V
Cycle de vie incrémental
Une etape N doit attendre que l’étape N-1 soit réalisée. Chaque étape d’analyse possède une
étape de « test ».
L’analyse des besoins : Etape se faisant avec le client, généralement par un appel d’offre et
une réponse à appel d’offre.
La spécification : Ce document vous permettra de décrire l’architecture logicielle &
matérielle, les technologies utilisées, les contraintes, les délais… Ce document doit être
compréhensible par le client et par le développeur.
La conception préliminaire & détaillée : Ces etapes dépendent de l’ampleur du projet,
parfois seul un document de spécification est nécessaire. Ces étapes vont vous permettre de mettre
sur papier l’architecture en détail de votre logiciel (de la classe à la simple méthode de classe, voir
même leur façon de s’éxecuter).
La codage : réalisation du système suivant ce qui aura été spécifié dans les étapes
antérieures.
Les tests : Chacun des tests correspond à une étape d’analyse, par exemple, un test unitaire
verifiera une partie bien précise du système. Un test d’intégration verifiera si les différents sous-
systèmes sont capable de cohabiter ensemble. Pour finir, le test de validation va nous permettre de
verifier si le logiciel conçu répond bien à la specification. Si une erreur survient dans l’un des tests, il
est necessaire de remonter la modification directement à l’étape d’analyse associée.
Date
6 Création d’application d’entreprise
Par exemple on démarre un cycle de vie en V pour la version 1 de notre logiciel puis après la
phase de réalisation, on démarre un autre cycle en V pour la version 2 en parallèle à la fin de notre
premier cycle.
L’inconvénient :
Si le noyau ou le précédent incrément est mauvais, tous les autres incréments le sont aussi.
Date
7 Création d’application d’entreprise
Savoir écouter (et pas juste entendre) les besoins du client est primordial pour la réussite de
votre projet.
Il vous faut utiliser un langage de non informaticien, schématiser ce dont vous parlez, appuyez-
vous sur des schémas UML compréhensibles par tous (cf. chapitre sur l’UML).
N’oubliez pas que le client est roi mais ne sait pas tout ! Vous intervenez en tant que
« consultant » capable de délimiter le faisable de l’impossible.
Ne remettez pas en cause les conseils métier du client qui risqueraient de le froisser. Qui n’a
pas déjà eu des phrases du type « Non je ne suis pas d’accord, le menu doit être à droite car je
connais mes utilisateurs et il faut que ce soit là. ». Vous n’êtes pas là pour discuter mais réaliser et
hypothétiquement faire rentrer de l’argent.
N’oubliez pas de mettre par écrit toutes les demandes du client afin de vérifier que vous les
avez bien identifiées. N’hésitez pas à tout faire signer à chaque fois pour éviter qu’à la livraison on
vous dise que ce n’était pas ce qui avait été convenu.
L’UML n’est pas la seule façon d’interpréter les besoins. N’hésitez pas à faire vos propres
commentaires, schémas (grâce notamment à Visual studio).
Date
8 Création d’application d’entreprise
5 L’architecture du système
Les applications riches vous permettent une interaction forte avec l’IHM. Prenons l’exemple
d’Outlook, vous pouvez l’avoir en ligne ou sur votre bureau.
Version RDA
Version RIA
Les technologies utilisées pour les applications de type RIA sont l’ASP.NET avec de l’Ajax (grâce
à l’ASP .NET 3.5 par exemple, ou l’Ajax toolkit), du JavaScript (Librairie JQuery intégrée dans Visual
Studio 2010), ou tout simplement du Silverlight 2.
L’intérêt des applications de type RIA vient du fait que tous les systèmes d’exploitation
peuvent les utiliser. Peu importe le système d’exploitation ou le navigateur (Seulement Mac OS X et
Windows pour Silverlight).
Date
9 Création d’application d’entreprise
Attention de bien faire la distinction entre ce qui s’exécute côté serveur (ASP.NET) et du côté
client (Silverlight, Javascript …).
Les applications RDA (Rich Desktop Applications) vont vous permettre de s’exécuter coté client
grâce à la CLR (Common Language Runtime). L’avantage est le fait d’avoir la main sur le système
d’exploitation (systèmes de fichiers, base de registres…). Les deux technologies utilisées pour les RDA
sont les Windows forms et WPF (Windows Presentation Foundation).
Un service est un programme qui va permettre d’exposer des données à notre application afin
d’éviter que notre application soit en contact direct avec notre base de données.
Si notre service est exposé sur internet on parle alors de « web service ».
Dans l’exemple ci-dessus, il existe 3 services dont un nommé CoursService. Ce service nous
met à disposition des méthodes telles que GetCourses().
Les services vont permettre de granulariser votre applicatif. Cela implique une maintenance
plus facile et permet à une application tierce de re-consommer ces services si besoin est.
Un service peut prendre du temps à développer, cependant pour ceux qui souhaiteraient aller
au plus vite il existe un projet appelé Astoria ou Data Services qui vous générera automatiquement
votre service pour exposer vos données.
Date
10 Création d’application d’entreprise
Afin de modéliser votre architecture, Microsoft vous propose Visual Sudio Team Foundation
Architect Edition 2008.
Prenons comme exemple la création d’un site d’e-commerce (type RIA, ASP.NET/Ajax), voici
comment nous allons modéliser notre SI :
Il vous est maintenant possible d’architecturer votre applicatif grâce à la Toolbox à gauche.
Il est possible de glisser-déposer des éléments puis de les configurer (version du Framework,
nom du service, etc…).
Date
11 Création d’application d’entreprise
Date
12 Création d’application d’entreprise
Suivant les moyens consacrés au projet, vous pouvez séparer l’hébergeur de service du serveur
de base de données.
Pour la partie serveur, je vous conseille IIS avec Windows Server 2003 ou 2008 (La nouveauté
WAS vous permet d’héberger vos services très facilement) bien qu’il soit possible grâce au projet
Cassini d’héberger du .NET sur Apache.
Pour en revenir à l’exemple de site d’e-commerce, voici ce que nous aurions pu schématiser :
Cependant nous aurions pu intégrer sur le même serveur la base de données, le service et
l’hébergeur du site web.
Date
13 Création d’application d’entreprise
Le premier Framework fut le 1.0 sortie en 2002. Pour des raisons de corrections critiques, la
version 1.1 est sortie par la suite.
Ce Framework, à moins de ne pas avoir le choix, ne doit pas être utilisé. En effet de nombreux
correctifs et améliorations ont été apportés au 2.0.
Le Framework 3.5, lui, propose des technologies comme ASP.NET Ajax et LINQ (API d’accès aux
données de façon générique).
Il est aussi bon de noter qu’il existe un Compact Framework permettant de développer pour
les systèmes embarqués type Windows CE.
N’ayez crainte d’utiliser les dernières versions du Framework en pensant qu’elles ne seraient
pas stables. L’actuel Framework 3.5 vient d’hériter d’une version SP1 améliorant considérablement
celui-ci.
Le choix du Framework dépendra entièrement des besoins clients et des compétences des
développeurs mais dans un souci d’évolutivité il est conseillé de prendre la dernière version à jour.
Date
14 Création d’application d’entreprise
L’API d’accès aux données dans .NET s’appelle ADO.NET. Cette technologie va vous permettre
d’accéder aux données de façon générique.
ADO.NET :
L’utilisation d’ADO.NET avec les classes de base type DataReader (mode connecté) ou
DataSet (mode déconnecté) vous permettront de requêter votre base à l’aide du langage
SQL. Cette solution est disponible à partir du Framework 2.0.
Linq :
LinqToSql et LinqToEntities (ADO.NET Entity Framework) sont deux technologies permettant
de faire du Mapping Objet Relationnel.
C'est-à-dire qu’à partir d’une base de données nous faisons abstraction du modèle
relationnel pour faire un modèle conceptuel et travailler avec des objets.
Fini donc les requêtes SQL et autres joyeusetés.
Exemple de classe générée par Linq en glissant-déposant des tables d’une base de données
Note : Microsoft vient d’annoncer que Linq-To-Sql ne sera plus maintenu pour les nouveaux
fournisseurs de données, il est donc préférable d’utiliser LinqToEntities.
Le choix du type d’accès aux données est très lié au choix du Framework puisque Linq
n’apparait qu’à partir du 3.5.
Date
15 Création d’application d’entreprise
Utilisez le C# ou VB.NET selon les préférences du client. Evitez d’utiliser d’autres langages qui
seraient difficiles à maintenir par une autre équipe de développeurs.
Chez Microsoft, il existe une multitude de versions de Visual Studio. Nous nous intéressons à la
version 2008 qui permet de choisir le Framework lors de la création d’un projet.
Date
16 Création d’application d’entreprise
Stockage basé sur les fichiers Souvent utilisé avec de l’XML, je vous le recommande pour de
petites applications. Peut devenir contraignant s’il existe
beaucoup de données.
SQL Express C’est une base de données gratuite permettant de créer des
petits projets de base de données. Cette option peut être
considérée si vous manquez de moyens financiers. Attention
cependant, ce genre de base de données est limité à 1GO de
RAM, 4GO de données et travaille avec un seul CPU.
SQL Everywhere SQL Everywhere appelé aussi SQL Mobile est une version allégée
de SQL Server. Cette option vous permet de retrouver vos
données en local sur un mobile.
SQL Server editions Base de données de Microsoft permettant de stocker tout type
projet volumineux.
Date
17 Création d’application d’entreprise
Peu importe que vous utilisiez « paint » ou un logiciel plus évolué. L’intérêt n’est pas de
montrer vos talents de graphiste mais surtout l’ergonomie de base et l’enchainement des fenêtres.
N’hésitez surtout pas à attacher à côté un schéma simplifié montrant les interactions entre
chaque interface. C’est un travail fastidieux mais qui se révélera utile lors de la validation avec le
client.
Date
18 Création d’application d’entreprise
Pour cela il existe de nombreuses méthodes. Je vous conseille le Merise ou/et les diagrammes ORM.
Un diagramme ORM se crée à partir de Visio. Il va permettre de mettre en évidence tous les
attributs possibles pour un objet. Généralement ce genre de diagramme est très apprécié des
développeurs puisque l’on pense « objet ».
Les « …a... » représentent l’appartenance. Par exemple, une voiture contient des sièges, un
siège est contenu dans une voiture.
Date
19 Création d’application d’entreprise
Après avoir schématisé grâce à ORM vos objets, il est facile d’en déduire la base de données.
Ce schéma met en évidence une table Voiture, possédant des attributs tels que Couleur,
Numéro de série et le Modèle.
Date
20 Création d’application d’entreprise
Puis sélectionnez les tables qui devront être présente dans le schéma :
Date
21 Création d’application d’entreprise
9 Représentations objets
UML (en anglais Unified Modeling Language, « langage de modélisation unifié ») est un
langage graphique de modélisation des données. Il va nous permettre de mettre sur papier
l’architecture du SI par rapport aux besoins du client.
Vous pouvez réaliser vos schémas grâce à des outils comme Rational Rose ou Visio.
Date
22 Création d’application d’entreprise
Ce diagramme, très simple à comprendre, permet une interaction entre le client et vous.
Vous allez pouvoir montrer les différents scénarii possibles ainsi que les acteurs qui rentrent en jeux.
Dans un premier temps, il faut identifier les acteurs. Par exemple, l’utilisateur d’un logiciel :
Type de l’acteur : actif (c'est-à-dire qu’il va déclencher le scénario, sinon il est passif)
Type d'entité : personne
Rôle : utilisateur du logiciel
Sur un diagramme UML, les acteurs sont représentés par de petits bonshommes.
Les cas d’utilisation sont représentés par une ellipse. Un cas d’utilisation correspond à un scénario.
Date
23 Création d’application d’entreprise
Par exemple :
Date
24 Création d’application d’entreprise
Une couche IHM contenant des technologies type Winforms, ASP.NET, Silverlight …
Une couche Métier, souvent représentée par une assembly de type library (dll).
Une couche Service de type WCF ou Remoting.
Une couche d’accès aux données qui servira de DataContract. De type ADO.NET ou plus
particulièrement Linq (ToEntities de préference puisque Microsoft ne maintient plus ToSql).
Date
25 Création d’application d’entreprise
En effet, une grande partie des attaques se fait simplement par des entrées de
l’application qui sont mal ou pas du tout protégées. Pour cette raison il faut
adopter certains principes et nous verrons dans la partie « Implémentation de la sécurité » juste
après.
Cependant, il est intéressant de savoir si quelqu’un a tenté une attaque envers notre
application. Nous allons pour cela loguer les tentatives d’intrusion de différentes manières : par
envoi de mail, stockage en base de données ou même en XML. L’important est de détecter une
manipulation frauduleuse d’un utilisateur. On pourra alors identifier une valeur erronée d’un
identifiant dans un paramètre de l’URL, ou encore du script dans une TextBox et nous
sauvegarderons les informations concernant l’utilisateur ayant effectué cette action. Après il ne tient
qu’à vous d’envoyer un avertissement à l’utilisateur concerné.
De même si dans le cadre d’une application web (ASP.NET) l’utilisateur n’est pas enregistré, il
sera toujours bon de récupérer son adresse IP avec le code suivant et loguer sa tentative d’intrusion :
Request.ServerVariables["REMOTE_ADDR"]
Il est même parfois moins couteux pour l’entreprise de faire de la répression que de la
prévention.
Date
26 Création d’application d’entreprise
Par exemple, pour une application web, il convient de concevoir une page d’erreur
personnalisée pouvant indiquer aux utilisateurs qu’une erreur vient de se produire sur l’application
et qu’un mail a été envoyé à l’administrateur. L’utilisateur pourra donc voir que l’erreur est certes
bien apparue mais que l’équipe en charge de l’application vient d’être prévenue. De plus, l’équipe de
développement pourra alors avoir un listing des erreurs apparues dans l’application lors d’une
utilisation courante. Ils pourront ainsi régler plus rapidement les problèmes rencontrés.
Il est évident qu’il faut que ce cas se produise le moins possible afin que l’utilisateur n’ait pas
l’impression que l’application qu’il est en train d’utiliser est mal conçue ! C’est dans cette optique
que la partie à propos des différents tests à réaliser sur l’application est très importante. Elle permet
d’éviter les situations d’erreurs trop nombreuses.
Afin que ces situations soient le moins souvent rencontrées, il faut que l’équipe de
développement ait bien respectée les bonnes pratiques : utilisation de blocs Try-Catch-Finally afin
d’englober les portions de code à risque, vérifications diverses des variables pour ne pas rencontrer
d’erreurs (null, négatives, etc…).
try
{
//Portion de code à risque
//Si une exception se produit à l'exécution
//le code dans le bloc "catch" est exécuté
}
catch (NullReferenceException ne)
{
//Portion de code à exécuter si une exception se produit
//Il est possible de mettre plusieurs blocs "catch" à la
//suite les uns des autres afin de pouvoir capturer
//des exceptions différentes
}
catch(Exception e)
{
//Portion de code à exécuter dans le cas
//d'une exception basique
}
finally
{
//Portion de code s'exécutant dans tous les cas : si la
//portion de code à risque s'exécute correctement ou si
//une exception se produit cette portion s'exécutera
}
Date
27 Création d’application d’entreprise
11 Implémentation de la sécurité
Implémenter la sécurité dans les applications n’est pas chose simple,
d’autant plus que des failles apparaissent régulièrement, mais il y a des façons
simples de limiter les risques.
On les divisera ici en deux parties distinctes, les entrées utilisateurs et les entrées non utilisateurs.
- Le RequiredFieldValidator qui est un composant qui permet de vérifier si un champ n’est pas
vide.
- Le CompareValidator qui permet de comparer la valeur entrée avec une autre valeur.
- le RangeValidator qui permet de vérifier que la valeur d’entrée est située entre 2 valeurs.
- Le RegularExpressionValidator qui permet des vérifications utilisant les expressions
régulières.
- Le CustomValidator qui permet de créer votre propre logique de validation.
- Le ValidationSummary qui permet de rassembler les erreurs trouvées sur la même page web
Toutes ces validations sont importantes mais ne suffisent pas. Elles sont, dans le cadre d’une
application web, gérées par du script côté client qui peut être désactivé. Par conséquent nos
vérifications ne sont plus effectives.
Nous allons donc devoir effectuer ces validations également coté serveur en utilisant la
propriété Page.IsValid. On utilisera cette propriété après validation grâce à la fonction
Date
28 Création d’application d’entreprise
Page.Validate() qu’il ne sera pas nécessaire d’appeler si vous avez laissé la propriété CauseValidation
de votre contrôle à « true ».
Pour le Web :
- Les paramètres passés dans l’URL (QueryString)
- Les cookies
Egalement valables pour le Windows Form :
- Les fichiers lus et utilisés
Pour les paramètres dans l’URL, il faut penser à vérifier différents points :
Les cookies peuvent également être une faille importante. Certains développeurs ont tendance à
mettre beaucoup d’informations dans les cookies, sans se soucier de la faille que cela représente.
- Les cookies peuvent en effet être utilisés pour récupérer des informations sur l’utilisateur. Il
faut donc faire attention aux informations que l’on y met (pas de mot de passe en clair par
exemple).
- Ils peuvent également être utilisés pour usurper l’identité d’un utilisateur si le cookie permet
une authentification. Pour un site pouvant contenir des informations sensibles, on ne
permettra pas d’authentification automatique par cookies.
- Directement sur la machine cliente dans le répertoire contenant les cookies (arrive
régulièrement dans le cadre où vous travailleriez sur un poste qui ne vous est pas réservé et
où d’autres personnes peuvent avoir accès).
- En interceptant les cookies par « sniffing » ou par la méthode « man in the middle », les
cookies passant par requêtes HTTP, on peut les intercepter. Il faudrait pour contrer cela
utiliser un protocole chiffré (HTTPS par exemple).
Date
29 Création d’application d’entreprise
Quelles sont les différentes attaques auxquelles nous devons faire face ?
Cette attaque intervient dans le contexte où une entrée utilisateur serait insérée directement
dans une requête SQL sans subir de vérification sur son contenu ; elle pourrait alors être interprétée
comme du code SQL et dans ce cas effectuer des actions sur nos données.
Exemple concret :
Considérons deux champs texte contenant un nom d’utilisateur et un mot de passe pour une
authentification directement dans la base de données.
SELECT user FROM table_users WHERE
login=’login’ AND password=’password’
Dans le cas où nous n’effectuerions pas de vérifications sur le login et password entrés on
pourrait voir ceci :
login=’Administrateur’ ; –’ AND
password=’password’
Nous serions alors bien logué comme Administrateur sans avoir eu besoin du mot de passe.
- Utiliser des procédures stockées ou même des requêtes paramétrées à la place du SQL
dynamique. Les données entrées par l'utilisateur sont alors transmises comme paramètres,
sans risque d'injection.
- Vérifier de manière précise et exhaustive l'ensemble des données venant de l'utilisateur. On
peut, par exemple, utiliser une expression régulière afin de valider qu'une donnée entrée par
l'utilisateur est bien de la forme souhaitée.
- Utiliser des comptes utilisateurs SQL à accès limité (en lecture seule) quand cela est possible.
- Réaliser un contrôle en amont en bloquant systématiquement les entrées contenant EXEC,
SELECT, INSERT, DROP, CREATE, ALTER, UPDATE...
- Utiliser du LinQ qui empêche ce genre d’attaque nativement.
Date
30 Création d’application d’entreprise
Avec votre application ASP.NET vous êtes protégé contre ce genre d’attaque, du fait que par
défaut la variable validateRequest est définit à « true » protège contre tout code intrusif et génère
une exception dans ce cas. Si par contre vous désirez pouvoir insérer du code HTML dans les entrées
utilisateur, il sera nécessaire de le désactiver et vous devrez alors utiliser par exemple une expression
régulière pour contrer ce genre d’attaque. Cette variable est accessible directement depuis votre
Web.config : <pages validateRequest="false" />
Nous avons un champ texte rempli par l’utilisateur et il y insert du code HTML.
En laissant notre variable validateRequest à « false », tout se passe bien et le code est
interprété. Si nous la passons à « true » nous obtenons ceci :
On peut également, pour ne pas que le code HTML bloque le fonctionnement de notre
application, utiliser la fonction « Server.HtmlEncode ». Elle nous permettra d’obtenir du code
gardant son format HTML mais qui ne sera plus interprété. En réalité le format HTML sera reformaté
comme nous allons le voir sur le même exemple que précédemment.
Date
31 Création d’application d’entreprise
Voici le résultat :
Nous avons donc gardé l’intégralité de notre code mais reformaté en HTML pour qu’il ne soit
plus interprété, en retournant dans le mode édition nous avons alors ceci :
Cette méthode est donc intéressante mais ne nous permet pas d’utiliser un formatage HTML
tout en empêchant l’usage de script.
Ayant maintenant vu les tentatives d’intrusion les plus connues auxquelles vous serez amené à
faire face, nous espérons que votre réflexion dans le développement se fera de façon sécurisée.
Date
32 Création d’application d’entreprise
12 Les tests
Dans ce chapitre nous aborderons les différents tests qui doivent être réalisés avant de mettre
une application en production. En effet, une application correctement testée permet d’être plus
stable. De nos jours, il n’est pas concevable de livrer une application non testée à un client !
Pour certains les tests peuvent être considérés comme une perte de temps mais ils ont tout
faux : le gain est énorme car le temps passé à débuguer l’application s’en verra réduit d’autant plus
que les tests seront importants. En effet, l’exécution de tests amènera plus rapidement à identifier
les bugs et pourra permettre alors au développeur de les corriger. Le gain d’énergie et de temps sera
d’autant plus considérable pour le développeur puisqu’il lui suffira de quelques minutes pour corriger
son code.
Date
33 Création d’application d’entreprise
Définition : Un test unitaire est une portion de code qui va permettre de tester une autre
portion de code en exécutant celle-ci et en analysant son résultat.
Les tests unitaires permettent de rendre une application le plus robuste possible en testant
comment elle réagit à diverses situations (erreurs, performances,…). De plus, le temps gagné par
l’exécution de tests automatisés est très appréciable !
Il existe plusieurs types de bonnes pratiques pour la mise en place des tests préconisées par la
méthode Extreme programming :
Implémenter les tests unitaires avant d’écrire le code afin de pouvoir tester du début à la fin
du développement de notre portion de code (appélée Test Driven Programming).
Il existe aussi la programmation croisée qui nécessite deux développeurs : l’un implémente
les tests pendant que l’autre écrit le code.
Implémenter les tests unitaires après l’écriture du code afin d’avoir une vue d’ensemble des
fonctionnalités à tester.
Par définition, un test unitaire doit pouvoir être autant disponible que le code qu’il teste. En
effet un autre développeur doit pouvoir tester la portion de code. De ce fait, il doit aussi être
exécutable sur le poste d’un autre développeur : il doit donc être indépendant de l’environnement
de travail. Pour assurer un gain de temps optimal, le test unitaire doit pouvoir être exécuté
automatiquement : par exemple juste après la compilation de la portion de code à tester afin de
pouvoir immédiatement répertorier les éventuels bugs.
Ce Framework a été développé par Charlie Poole, Michael Two, Alexei Vorontsov, et Jim
Newkirk dans le langage C#. Cependant, il est utilisable par les langages .NET (C#, VB.NET,…).
Sachez qu’il existe la version console de NUnit qui est installé en même temps que la version
GUI. La version console présente le logiciel en mode texte et affiche la sortie des tests dans la
console. Cette version ne sera pas abordée dans ce cours.
Une fois l’installation réalisée, il suffit de lancer l’exécutable pour avoir la fenêtre suivante qui
s’ouvre :
Date
34 Création d’application d’entreprise
Dans la partie de gauche, on trouve une arborescence qui affichera les classes de tests et les
méthodes de test du projet chargé. Pour charger un projet il suffit de venir récupérer la dll du projet
à tester.
Dans la partie droite de l’application, on peut trouver deux boutons (Run & Stop) et une barre
de progression. Ces boutons permettent de lancer/stopper le test d’une des méthodes. Le résultat
du test est affiché dans le cadre de la partie basse à droite.
Le barre de menu possède les options comme la modification visuelle de l’affichage (taille de la
police,…), de récupérer les informations sur l’assembly courante ou encore la gestion des Addins.
Sachez qu’il est possible de charger plusieurs assemblies en même temps : pour cela cliquer sur
« Project » « Add assembly ».
Maintenant que l’on sait se servir du logiciel NUnit, nous allons voir comment, dans notre
code, implémenter des méthodes de tests afin de pouvoir les exécuter via le logiciel NUnit.
Premièrement, pour pouvoir utiliser le Framework NUnit, il faut le référencer dans le projet
dans lequel seront créés les tests : Pour cela faire clic droit sur le projet dans Visual Studio
« Ajouter une référence ». Ensuite dans l’onglet « .NET », il faut référencer la dll
nunit.framework.dll.
Date
35 Création d’application d’entreprise
Attention à bien choisir celle correspondant au runtime v2.0.50727 si vous travaillez avec le
Framework .NET 2.0 ou supérieur.
Nous allons maintenant créer notre méthode à tester : cette méthode sera volontairement
très simpliste.
/// <summary>
/// Méthode qui vérifie l'exactude du format d'une heure
/// </summary>
/// <returns></returns>
public bool MethodeATester(string email)
{
if (email == null)
throw new NullReferenceException();
return Regex.IsMatch(email, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-
9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
}
}
Dans cette classe nous avons donc une méthode permettant de tester la validité d’un champ
correspondant à une adresse e-mail.
Pour qu’une classe soit interprétée par NUnit comme étant une classe de test il faut qu’elle ait
l’attribut [TestFixture] en en-tête de la classe. Désormais, toutes les méthodes ayant l’attribut
[Test] seront à leur tour considérées comme des méthodes de test.
Date
36 Création d’application d’entreprise
Nous allons donc ajouter une classe de test possédant deux méthodes permettant de tester
notre méthode créée précédemment :
[TestFixture]
public class ClassTest
{
public ClassTest()
{
/// <summary>
/// Methode permettant de tester l’@ email avec des noms de domaine
erronés
/// </summary>
[Test]
public void TestSansDomaine()
{
Assert.IsTrue(new ClasseATester().MethodeATester("test@test.com"));
Assert.IsFalse(new ClasseATester().MethodeATester("test@test"));
Assert.IsFalse(new ClasseATester().MethodeATester("test@test."));
Assert.IsFalse(new ClasseATester().MethodeATester("test@"));
}
/// <summary>
/// Méthode permettant de tester l’@ email sans partie locale
/// </summary>
[Test]
public void TestSansPartieLocale()
{
Assert.IsTrue(new ClasseATester().MethodeATester("test@test.com"));
Assert.IsFalse(new ClasseATester().MethodeATester("@test.com"));
Assert.IsFalse(new ClasseATester().MethodeATester(" @test.com"));
}
}
L’attribut [Test] possède plusieurs attributs supplémentaires qui peuvent être utiles :
Une fois la dll chargée dans NUnit, voilà l’affichage que l’on obtient :
Date
37 Création d’application d’entreprise
Si un test se déroule avec succès il s’affiche en vert et en rouge s’il y a une erreur. De plus,
lorsqu’il y a une erreur sur un test, un message indicatif apparait dans la partie en dessous de la barre
de progression.
Pour simuler une erreur dans notre code nous allons modifier l’expression régulière de notre
classe à tester : En supprimant de l’expression régulière la vérification de la partie locale d’une
adresse e-mail, le test « TestSansPartieLocale » ne sera pas exécuté avec succès :
Date
38 Création d’application d’entreprise
Dans le code contenu dans les méthodes de tests, on peut noter plusieurs appels aux
méthodes de la classe Assert. Cette classe permet de faire des assertions dans notre code et
permet donc de tester les valeurs de retour des méthodes à
tester.
Date
39 Création d’application d’entreprise
Les bonnes pratiques pour bien réaliser ses tests unitaires sont les suivantes :
Une classe à tester = une classe de test en effet autant tester l’intégralité de notre classe
dans une seule classe de test possédant plusieurs méthodes de test.
Développer à la fois des tests simples et des tests plus conséquents afin de tester en
profondeur l’application pour être sûr de sa robustesse
Enfin, les tests doivent être dans la même assembly que les classes à tester afin de garder le
bon niveau de visibilité.
Pour conclure sur cette partie, les tests unitaires permettent donc : de gagner du temps sur le
débogage, une non régression du code étant donné que les tests sont exécutés très souvent ainsi
qu’une meilleure documentation.
Voyons un exemple simple : Il pourra être testé le bon fonctionnement d’un composant
permettant d’afficher une liste d’utilisateurs et un autre composant permettant d’ajouter un
utilisateur. Lorsqu’on ajoutera un utilisateur il devra s’être affiché dans le composant listant tous les
utilisateurs.
Pour être bien sûr de valider la totalité des composants et de leurs fonctionnalités, il est
fortement recommandé de garder une trace de tous ces tests en réalisant des fiches. Dans ces fiches
on pourrait répertorier deux grandes parties : la présentation du test d’intégration et le rapport de
test afin de garder une trace du résultat obtenu.
Voici les grandes lignes de ce que l’on peut trouver dans la présentation d’un test d’intégration :
Voici une liste non exhaustive des points abordés dans un rapport de test d’intégration :
Date
40 Création d’application d’entreprise
Tout comme pour les tests d’intégration il est fortement recommandé de tenir à jour une
documentation de compte-rendu de tests de validation. En effet, il est possible que ce soit des
équipes de développement différentes qui testent l’application de celles qui développent
l’application. De ce fait, il est important pour l’équipe en charge du développement d’avoir une trace
de ce qui a été réalisé au niveau des tests.
Voici les informations que peuvent contenir une fiche de test de validation :
L’objectif du test ainsi qu’une courte description comme par exemple : tester le cas
d’utilisation « connexion à l’application »
La description des actions que l’utilisateur doit réaliser pour atteindre l’objectif du test
L’environnement nécessaire pour mener à bien le test
Date
41 Création d’application d’entreprise
13 Le déploiement
On distingue le projet de déploiement (Setup Project) qui sera utilisé pour les applications
clientes (Windows Form) et le projet de déploiement Web (Web Setup Project) qui comme son nom
l’indique sera utilisé pour les applications web.
Le Setup Wizard est un assistant pour créer votre projet de déploiement, seuls les deux
principaux projets de déploiement cités précédemment seront étudiés ici.
Nous allons voir ci-dessous plus en détail à quoi correspondent ces différents outils :
Date
42 Création d’application d’entreprise
La partie de gauche est constituée de multiples répertoires qui peuvent être de deux types :
- Répertoire standard
- Répertoire spécial (avec l’étoile bleue sur le logo)
Les répertoires spéciaux nous permettent d’accéder à différents endroits de Windows. Nous
utiliserons ces dossiers par exemple pour définir des raccourcis sur le bureau, dans le menu
« Démarrer » ou encore des Assemblies (Attention les Assemblies doivent absolument être signées) :
Dans la partie de droite on pourra venir mettre des fichiers dans les différents répertoires. Ces
fichiers pourront être de différents types :
Date
43 Création d’application d’entreprise
L’interface présente ici nous permet d’ajouter une sortie de projet. C’est le moyen d’intégrer
notre application au projet de déploiement. Il faudra ensuite choisir parmi les différents types de
sortie :
- Sortie principale : L'exécutable ou la dll générée par le projet ainsi que toutes ses
dépendances.
- Ressources localisées : Les ressources associées à des projets localisés (multi langues. Par
exemple dans le cas des applications Windows).
- Symboles de débogages : Tous les fichiers pdb qui permettent de débugger l'application.
Cette sortie n'est pas conseillée car généralement on n'installe jamais la version Debug d'un
projet.
- Content file : Installe les fichiers marqués comme « Contenu » dans le projet.
Registry Editor
Date
44 Création d’application d’entreprise
Cet outil vous permettra de configurer l’interface d’installation de votre application cependant
si vous ne désirez pas le paramétrer, l’interface par défaut sera mise en place.
Nous ne détaillerons pas ici les actions personnalisées, elles permettent des actions très
complètes mais nécessite une configuration plus longue notamment en redéfinissant la classe
Installeur.
Cet outil nous permet de définir des conditions d’installation, comme par exemple la présence
d’une certaine version du Framework .NET, ou encore si IIS es requis pour l’installation.
On commencera par effectuer une recherche qui pourra être de différents types :
- Présence de fichiers : Permet de rechercher un fichier en fonction de ses paramètres (par
exemple son nom).
- Présence de clés dans base de registre : Regarde si une clé existe à un emplacement donné.
- Présence d'une installation antérieure d'un MSI : Cette recherche se base sur l'identifiant
d'installation du MSI.
Date
45 Création d’application d’entreprise
Nous avons vu de façon globale comment paramétrer notre projet d’installation. Nous allons
maintenant découvrir qu’il existe d’autres moyens de déploiement.
Click Once est une nouveauté du Framework 2.0, il utilise le protocole HTTP pour diffuser
notre projet et permet de l’installer simplement mais également d’effectuer des mises à jour. Il faut
savoir que ce type d’installeur nécessite donc que le client dispose d’une connexion Internet et que
nous ayons un serveur Web IIS installé.
Nous allons commencer par créer notre projet que l’on désire installer ; On utilisera ici un
projet WindowsForm.
Une fois notre projet compilé, nous allons directement le déployer. On va alors dans les
propriétés de notre application et on coche la case « Sign the ClickOnce manifest » (signer le
manifeste ClickOnce) dans l’onglet « Signing ».
Date
46 Création d’application d’entreprise
On définit ensuite les autorisations de sécurité. Il sera bon de les restreindre au maximum,
pour suivre la règle du moindre privilège abordée dans le chapitre sur la sécurité. Vous pouvez
utiliser l’outil fournit par Visual Studio « Calculer les permissions » afin de vérifier les permissions qui
sont nécessaires.
Vient ensuite la partie publication dans l’onglet « Publish ». Sur cette page, nous allons définir
si l’application sera publiée sur un FTP, un partage réseau ou un serveur IIS. On définira également si
notre application sera accessible uniquement de façon online (retélechargée à chaque fois) ou de
façon offline : téléchargée et installée sur le poste client.
Date
47 Création d’application d’entreprise
Date
48 Création d’application d’entreprise
Nous avons maintenant configuré notre déploiement Click Once, il reste alors à l’installer .
Ici nous avons une application sans intérêt, qui n’a aucun contenu mais nous
pouvons voir que le déploiement c’est bien effectué.
Une autre fonctionnalité simple que permet ClickOnce est la mise à disposition de mise à jour
et la détection de celle-ci.
Dans la page des propriétés de notre application, nous irons dans la partie « Update » et il faut
alors cocher l’option pour vérifier les mises à jour de l’application. Ici nous décidons d’effectuer la
vérification avant le lancement de l’application.
Date
49 Création d’application d’entreprise
Pour publier une mise à jour il faudra simplement après avoir reconstruit notre projet, cliquer
sur publier. L’utilisateur lançant son application, aura maintenant une fenêtre de recherche de mise à
jour qui se lancera au démarrage.
Nous avons la possibilité de signer le manifest de notre application ClickOnce ainsi que de
signer notre assembly .NET. Pour cela il nous suffit d’aller dans la partie Signing (Signature) et de
choisir l’option « Sign the assembly ».
Date
50 Création d’application d’entreprise
Rappelons que signer les assemblies .NET est une technique efficace et très pratique, dans le
cas où vous seriez amené à les réutiliser dans d’autres projets. Cela vous permet de les inscrire dans
le GAC (Global Assembly Cache) et vous évite ainsi, de devoir redéployer la DLL de votre assembly à
chaque fois que vous déployez un nouveau projet.
On peut également utiliser un certificat de sécurité pour signer le manifest de votre application
ClickOnce.
ClickOnce est donc un outil très simple à mettre en place, performant et facilement
paramétrable. Cependant, il ne convient pas à tous les types de déploiement, notamment parce que
son mode de publication se fait par Internet.
Date
51 Création d’application d’entreprise
14 Le travail collaboratif
Il constitue un portail web et intranet permettant aux membres d’une entreprise de pouvoir
centraliser des documents et des informations relatives au travail d’équipe : plannings,
espaces de discussions, carnets de rendez-vous, gestions
de tâches, etc…
Création et gestion de site webs : il est possible de créer
des applications web basées sur SharePoint. Ces
applications web sont totalement personnalisable grâce
entre autres à la création de webparts et masterpages
intégrables aux sites web.
Il constitue aussi une vraie base documentaire grâce à la
mise en place de stockage/partage de documents de tous
types ainsi que la gestion des droits d’accès sur ces
documents. De plus, WSS 3.0 propose une gestion des
versions des documents permettant à tout moment de revenir à une version antérieure.
Fonctionnalités supplémentaires : création de blogs, wikis, gestion d’alertes et de flux RSS
pour être au fait de modifications faites sur le portail.
Cet outil permet donc entre autres d’améliorer la productivité d’une équipe grâce à des outils
faciles à utiliser puisque toutes les informations relatives à leur travail sont centralisées sur une
même application. De plus, il permet de ce fait, de faciliter la gestion des ressources documentaires
Date
52 Création d’application d’entreprise
et humaines pour les chefs de projets. Enfin, il constitue une base solide pour venir créer des
applications web grâce à ses fonctionnalités de customisation et de création.
Pour installer Team Foundation Server il faut avoir un serveur sous Windows
Server 2003 ou 2008 avec IIS et SQL Server 2005 ou 2008.
Les utilisateurs du serveur TFS devront posséder une version Team System de Visual Studio
(Database Edition, Development Edition, Test Edition ou Architecture Edition). De plus, les
utilisateurs de TFS devront avoir installé le plugin Visual Studio Team System Team Explorer. Ce
plugin permet, sous Visual Studio Team System, de se connecter à un serveur TFS et ainsi de pouvoir
bénéficier des fonctionnalités Team System.
Date
53 Création d’application d’entreprise
Cet outil de travail collaboratif permet à une équipe de développement ayant accès à un projet
d’équipe de pouvoir partager des documents, de pouvoir travailler sur le même code source en
même temps et de pouvoir « versionner » celui-ci. Par exemple deux développeurs peuvent
travailler sur la même classe en même temps et au moment de la publication sur le serveur, les
éventuels conflits de version et de collision de code feront le nécessaire pour éviter que chacun des
développeurs perdent son travail ou écrase celui de l’autre. Grâce à l’outil Team Explorer il vous sera
possible d’établir des verrouillages afin que les autres développeurs ne puissent pas modifier le
fichier que vous êtes en train de modifier.
Pour le chef de projets, l’intérêt de cet outil n’est pas négligeable : il pourra mettre en place
des éléments de travail ou « Work Items ». Ceux-ci permettront d’indiquer aux développeurs des
tâches à réaliser comme la résolution d’un bug, d’un composant à réaliser, etc… De plus, le chef de
projet pourra mettre en ligne des documents utiles à l’équipe (spécifications, diagrammes, etc…).
Enfin, il sera possible de créer des règles dans le contrôle de code source afin d’imposer à vos
développeurs certaines bonnes pratiques : imposer que la solution compile avant de pouvoir publier
la version sur le serveur, imposer un pourcentage de commentaires dans le code.
Comme on peut le voir, Team Foundation Server est un outil très complet permettant aux
équipes de développement en collaboration très facilement. Le gain de productivité peut être
considérablement accru.
Date
54 Création d’application d’entreprise
Pour cela vous pouvez vous aidez de logiciel tel que MS Project.
Vous pourrez générer un diagramme de Gantt qui pourra se synchroniser sur un SharePoint.
Date