[Link]

com

Windows Application
SUPINFO DOT NET TRAINING COURSE

Auteur : Gregorie Ghez & Lehajam Boujemaoui

Version 2.0 – 10 décembre 2004
Nombre de pages : 80

Ecole Supérieure d’Informatique de Paris

23. rue Château Landon 75010 – PARIS
[Link]
Windows Application 2 / 80

Table des matières

1. CREATION D’UNE APPLICATION WINDOWS APPLICATION........................................................... 4
1.1. ASSISTANT VISUAL STUDIO .NET 2003......................................................................................................... 4
1.2. ARCHITECTURE DU PROJET ........................................................................................................................... 4
1.2.1. Les fichiers du projet............................................................................................................................. 4
1.2.2. Les références ....................................................................................................................................... 6
1.3. POINT D’ENTREE, OBJETS APPLICATIONCONTEXT ET APPLICATION .............................................................. 7
1.3.1. Définition du point d’entrée .................................................................................................................. 7
1.3.2. L’objet ApplicationContext ................................................................................................................... 8
1.3.3. L’objet Application................................................................................................................................ 9

2. LES FORMULAIRES..................................................................................................................................... 11
2.1. METHODES ET PROPRIETES.......................................................................................................................... 11
2.1.1. Méthode InitializeComponent ............................................................................................................. 11
2.1.2. Méthodes et propriétés principales ..................................................................................................... 14
2.2. EVENEMENTS .............................................................................................................................................. 14
2.2.1. Présentation ........................................................................................................................................ 14
2.2.2. Paramètres d’un Gestionnaire d’évènement ....................................................................................... 15
2.3. AFFICHAGE MODAL ET NON MODAL ............................................................................................................ 16
3. CONTROLES.................................................................................................................................................. 19
3.1. INTRODUCTION ........................................................................................................................................... 19
3.2. CONTROLES COMMUNS ............................................................................................................................... 20
3.2.1. Label ................................................................................................................................................... 20
3.2.2. TextBox................................................................................................................................................ 21
3.2.3. Button .................................................................................................................................................. 23
3.2.4. ListBox ................................................................................................................................................ 24
3.2.5. ListView, TreeView et ImageList......................................................................................................... 26
3.3. BOITES DE DIALOGUES ........................................................................................................................ 31
3.3.1. OpenFileDialog et SaveFileDialog..................................................................................................... 31
3.3.2. FolderBrowserDialog ......................................................................................................................... 33
3.3.3. FontDialog .......................................................................................................................................... 34
3.3.4. ColorDialog ........................................................................................................................................ 35
3.4. DATAGRID .................................................................................................................................................. 35
3.4.1. Introduction......................................................................................................................................... 35
3.4.2. Liaison à une source de donnée ......................................................................................................... 36
3.4.3. Editeur de Styles.................................................................................................................................. 37
3.5. USERCONTROLS..................................................................................................................................... 39
3.5.1. Présentation ........................................................................................................................................ 39
3.5.2. Création .............................................................................................................................................. 39
3.5.3. Utilisation............................................................................................................................................ 43

4. MENUS ............................................................................................................................................................ 46
4.1. L’OBJET MENUITEM.................................................................................................................................... 46
4.2. MAINMENU ................................................................................................................................................ 47

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 3 / 80

4.3. CONTEXTMENU .......................................................................................................................................... 49

4.4. TOOLBAR .................................................................................................................................................... 50
4.4.1. Présentation ........................................................................................................................................ 50
4.4.2. L’objet ToolBarButton ........................................................................................................................ 50
4.4.3. Création d’une barre d’outil ............................................................................................................... 51

5. DRAG & DROP............................................................................................................................................... 52

5.1. PRESENTATION............................................................................................................................................ 52
5.2. UTILISATION ............................................................................................................................................... 52
6. DESSIN AVEC GDI+ ..................................................................................................................................... 54
6.1. PRESENTATION............................................................................................................................................ 54
6.2. LES ELEMENTS DE BASE .............................................................................................................................. 54
6.3. LA CLASSE GRAPHICS ................................................................................................................................. 55
6.4. LES OBJETS BRUSH ET PEN .......................................................................................................................... 56
6.5. LES IMAGES ................................................................................................................................................ 58
6.5.1. Chargement d’un fichier image........................................................................................................... 58
6.5.2. Création à partir d’un flux .................................................................................................................. 58
6.5.3. Création manuelle............................................................................................................................... 59
6.5.4. Affichage ............................................................................................................................................. 59
6.6. AFFICHER DU TEXTE.................................................................................................................................... 60
6.7. EXEMPLES CONCRETS ................................................................................................................................. 61
7. IMPRESSION.................................................................................................................................................. 62
7.1. L’OBJET PRINTDOCUMENT ......................................................................................................................... 62
7.2. APERÇU AVANT IMPRESSION ....................................................................................................................... 63
7.3. SELECTION DE L’IMPRIMANTE ..................................................................................................................... 64
8. GENERATION................................................................................................................................................ 65
9. DEPLOIEMENT ............................................................................................................................................. 67
9.1. PRESENTATION............................................................................................................................................ 67
9.2. PROJET DE DEPLOIEMENT ............................................................................................................................ 67
9.2.1. Création .............................................................................................................................................. 67
9.3. ACTION PERSONNALISEE ............................................................................................................................. 70
9.3.1. Interface graphique............................................................................................................................. 71
9.3.2. Ajouter une fenêtre.............................................................................................................................. 71
9.3.3. Paramétrer une fenêtre ....................................................................................................................... 72
9.3.4. Récupérer une donnée entrée par l’utilisateur.................................................................................... 73

10. FICHIER DE CONFIGURATIONS................................................................................................... 77

10.1. PRESENTATION............................................................................................................................................ 77
10.2. UTILISATION ............................................................................................................................................... 78
10.2.1. Données propres à votre application .................................................................................................. 78
10.2.2. Paramètres concernant l’exécution de votre application.................................................................... 79

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 4 / 80

1. Création d’une application Windows

Application
1.1. Assistant Visual Studio .Net 2003
Une fois Visual Studio lancé, créez un nouveau projet :

Fichier >> Nouveau >> Projet… ou CTRL + MAJ + N

La fenêtre vous permettant de créer de nouveaux projets va alors s’ouvrir. Sélectionnez Application
Windows dans le dossier Projets Visual C#.

Figure 1 - Création d'un nouveau Projet C# avec Visual Studio .Net

Donnez un nom à votre projet, puis choisissez l’emplacement où sera créé votre projet. Par défaut,
celui-ci est créé dans le répertoire Visual Studio Projects qui est créé lors de l’installation de Visual
Studio .Net. Vous devriez trouver ce répertoire dans Mes Documents.

1.2. Architecture du projet

1.2.1. Les fichiers du projet
Un répertoire du nom de «Premier_Projet » a donc été créé. Celui-ci contient à lui seul tous les
fichiers nécessaires au développement de notre application. Ainsi, nous pourrions déplacer ce
répertoire localement, voir même vers une autre machine (équipée du Framework .Net et de Visual
Studio 2003 bien sûr) et continuer sans aucun problème le développement de notre application.

8 fichiers et 2 sous répertoires sont créés :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 5 / 80

• [Link] : Il s’agit de l’icône représentant notre application. Nous verrons par la suite
comment créer une icône pour son application.
• [Link] : Il s’agit du fichier qui contiendra au moins la classe représentant notre formulaire.
C’est le fichier de code principal de votre projet.
• Premier [Link] : Le principal fichier du projet Visual C#.
• Premier [Link] : Le principal fichier de la solution Visual C#.
• [Link] : Un fichier source C# contenant des données nécessaires pour l’assemblage
généré par le projet. Par exemple, si vous donnez un nom fort à votre assemblage, c’est dans
ce fichier qu’il faudra le spécifier.
Vous pouvez également renseigner des informations concernant le nom de l’assemblage, sa
version, etc… Des champs ont été prévus à cet effet comme en témoigne l’exemple ci-dessous
qui vous présente une partie d’un fichier [Link] :

Figure 2 - Fichier [Link]

• [Link] : Un fichier XML qui conserve certaines informations sur les ressources
associées à [Link].
• Premier [Link] : Un fichier de projet Visual C# contenant les paramètres choisis
par l’utilisateur.
• Premier [Link] : Le fichier de solution Visual C# contenant des informations propres à
l’utilisateur.
• Répertoire bin : L’assemblage généré par votre projet sera placé dans ce répertoire, que ce
soit en Release ou en Debug.
• Répertoire obj : Répertoire permettant de stocker des fichiers temporaires nécessaires à la
génération de l’assemblage.

Vous pouvez bien sûr ajouter ou supprimer vous-même des fichiers :

• Pour supprimer un fichier, dans l’explorateur de solutions, faites un clique droit sur le fichier à
supprimer, puis sélectionner Supprimer.
• Pour ajouter un fichier, dans l’explorateur de solution :
• Click droit >> Ajouter >> Ajouter un nouvel élément…
• Click droit >> Ajouter >> Ajouter un élément existant…

Les fichiers sont regroupés selon 6 types :

Interface utilisateur, Code, Données, Web, Utilitaire, Ressources.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 6 / 80

1.2.2. Les références

Vous pouvez voir les références (assemblages) actuellement ajoutées au projet, via l’explorateur de
solutions (Affichage >> Explorateur de solutions). Il vous suffira de développer le nœud
Références.

Figure 3 - Références dans Visual Studio

Par défaut, les références ajoutées à notre projet sont :

• System : Namespace racine qui contient presque tous les autres (le Namespace Microsoft
propre à l’architecture Windows n’est pas inclus dans ce Namespace).
• [Link] : Cet espace de nom contient toutes les classes vous permettant d’accéder à des
bases de données via [Link].
• [Link] : Il s’agit de l’ensemble des classes fondées sur GDI+ et qui vous
permettront d’effectuer des manipulations graphiques.
• [Link] : Il s’agit des classes permettant de développer des applications
Windows.
• [Link] : Ensemble des classes permettant de manipuler des données au format XML.

Pour en ajouter de nouvelles, il suffit de faire un click droit sur le nœud Références, puis de
sélectionner Ajouter une référence…

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 7 / 80

Figure 4 - Ajout de référence

La fenêtre Ajouter une référence va alors s’ouvrir. Elle est composée de 3 onglets :
• .NET : Permet d’ajouter un assemblage .Net
• COM : Permet d’ajouter un objet COM
• Projets : Permet d’ajouter un assemblage en provenance d’un projet de la solution actuelle.

Il vous suffit de sélectionner les références à ajouter dans la liste proposée ou en les recherchant
manuellement. Une fois toutes les références sélectionnées, cliquer sur OK pour valider, et les
nouvelles références viendront alors s’ajouter à celles déjà présentes.

1.3. Point d’entrée, objets ApplicationContext et

Application
1.3.1. Définition du point d’entrée
[STAThread]
static void Main()
{
[Link](new Form1());
}

Voici notre point d’entrée principal. C’est lui qui sera appelé pour instancier la classe représentant
notre application, c’est pourquoi il est déclaré en static.

Si votre application comporte plusieurs formulaires, elle comportera sûrement plusieurs points
d’entrées et il vous faudra spécifier celui qui sera appelé au lancement de l’application. Il s’agira du
point d’entrée principal.

Pour ce faire, allez dans les propriétés du projet, puis dans la rubrique Général. En face du champ
Objet de démarrage sélectionner l’objet de démarrage qui contient votre point d’entrée principal.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 8 / 80

Figure 5 - Sélection du point d'entrée principal

1.3.2. L’objet ApplicationContext

Cet objet va vous permettre de gérer le comportement de votre application. Vous allez pouvoir
effectuer des traitements lors du lancement de votre application, ou encore durant l’arrêt de celle-ci.

L’objet Application que nous verrons juste après, utilise une instance de la classe ApplicationContext
pour lancer le formulaire. L’instance qu’il utilise représente un comportement par défaut, aussi, vous
pourrez définir votre propre comportement en créant une classe qui hérite de ApplicationContext.

Dans l’exemple suivant, un message de bienvenu est affiché au lancement de l’application, puis un
message de fin est affiché à l’arrêt de l’application.

public class CustomContextClose : ApplicationContext

{
//Constructeur, prend en argument un formulaire Form1
public CustomContextClose(Form1 form)
{
//On affiche une boite de dialogue
[Link]("Bienvenue");
//On affiche le formulaire
[Link]();
//On va gérer l’évènement Closing du formulaire
[Link] += new
CancelEventHandler(form_Closing);
}

//Méthode appelée à la fermeture du formulaire

private void form_Closing(object sender,
CancelEventArgs e)
{
//Une boite de dialogue affiche un message avant la
//fermeture de l'application
[Link]("Fermeture de l'application");
//On arrête l'application
ExitThread();
}
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 9 / 80

Nous allons maintenant voir comment lancer une application, et comment lui appliquer le
comportement que l’on a implémenté dans la classe CustomContextClose.

1.3.3. L’objet Application

L’objet Application possède une méthode nommée Run qui permet de lancer une application. Cette
méthode démarre une boucle de message sur le Thread en cours, et utilise un objet ApplicationContext
pour gérer le comportement de l’application.

Par défaut, ce dernier ne définit aucun comportement spécifique durant le lancement ou l’arrêt d’une
application.

Une des versions surchargée de la méthode Run permet de spécifier un objet ApplicationContext dont
vous avez modifié le comportement (grâce à l’héritage).

Voici les trois versions surchargées de la méthode Run :

• Sans argument : Utile si vous souhaiter afficher le formulaire principal ultérieurement, ou si
vous devez en afficher aucun. Une instance de la classe ApplicationContext. est créée pour
gérer le comportement de l’application, et vous pourrez effectuer des traitements avant
d’afficher un formulaire.
Lorsqu’une nouvelle instance de notre formulaire sera créée, l’exemple suivant va afficher un
message de bienvenue à l’utilisateur avant d’afficher le formulaire.

//Constructeur du formulaire Form1

//Modifié pour nos besoins
public Form1()
{
InitializeComponent() ;

//On affiche un message de bienvenue à l'utilisateur

[Link]("Bienvenue");
[Link]();
}

La ligne suivante vous permet d’afficher un formulaire :

[Link]();

L’exemple suivant montre le point d’entrée permettant de lancer une telle application.

[STAThread]
static void Main()
{
//On instancie un nouveau formulaire de type Form1
//Mais il ne sera pas affiché
Form1 f = new Form1();

//On démarre l'application qui suivra le comportement

//par défaut implémenté par la classe ApplicationContext
[Link]();
}

Lorsqu’une application est lancée de cette manière, la fermeture du formulaire principal ne

provoquera pas l’arrêt de l’application. Il faudra utiliser la méthode Exit que nous verrons plus
tard.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 10 / 80

• Un formulaire en argument : C’est la surcharge utilisée par défaut. Le formulaire passé en

argument sera affiché et l’application aura un comportement par défaut (aucune action durant
le lancement ou l’arrêt de l’application).
• Un objet ApplicationContext en argument : L’application sera lancée avec le comportement
que vous aurez défini.

L’exemple suivant nous montre comment lancer une application qui suivra le comportement
CustomContextClose que l’on a défini à la partie précédente.

[STAThread]
static void Main()
{
//On instancie un nouveau formulaire de type Form1
Form1 f = new Form1();

//On instancie un nouvel objet CustomContextClose

CustomContextClose c = new CustomContextClose(f);

//On démarre l'application qui suivra le comportement

//défini par la classe CustomContextClose
[Link](c);
}

L’objet Application vous permet également de fermer l’application à l’aide de la méthode Exit, elle
est aussi déclarée en static. Cette méthode ne provoque pas un arrêt immédiat de l’application. Elle va
bloquer les sources de messages et la méthode Run se terminera.

L’exemple suivant montre comment forcer la fin d’une application durant la fermeture de son
formulaire principal. Cette méthode est pratique lorsque vous avez utilisé la version sans arguments de
la méthode Run pour lancer l’application.

private void Form1_Closing(object sender, CancelEventArgs e)

{
[Link]();
}

Vous pourrez également utiliser la méthode ExitThread qui va arrêter le Thread courant.

L’objet Application possède également des propriétés très pratiques permettant au développeur
d’obtenir très rapidement des informations sur l’application :
• ProductName : Obtient le nom du produit associé à cette application.
• StartupPath : Obtient le chemin d’accès au fichier exécutable ayant démarré l’application,
sans le nom de l’exécutable.
• AllowQuit : Booléen indiquant si l’utilisateur peut quitter ou non l’application. Attention, ce
champ est en lecture seule, vous ne pouvez pas lui affecter une valeur.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 11 / 80

2. Les formulaires
2.1. Méthodes et propriétés
2.1.1. Méthode InitializeComponent

private void InitializeComponent()

{
//
// Form1
//
[Link] = new [Link](5, 13);
[Link] = new [Link](292, 266);
[Link] = "Form1";
[Link] = "Form1";
[Link] += new [Link](this.Form1_Load);
}

Cette méthode permet de stocker les propriétés des contrôles modifiés dans le Concepteur de Form.

Avec Visual Basic 6, par exemple, ces données étaient placées dans un autre fichier auquel le
développeur n’avait pas accès.

Cette méthode est donc directement éditée par Visual Studio suivant les modifications apportées aux
contrôles, et il est déconseillé de l’éditer soit même.
Bien sûr, les propriétés par défaut des contrôles ne seront pas ajoutées à cette méthode.

Par défaut, elle définit des propriétés pour le formulaire tels que sa taille, son nom et son affichage. Si
vous modifier les propriétés du formulaire dans le concepteur de Form, ces modifications seront
automatiquement apportées à la méthode InitializeComponent.

Dans le concepteur de Form, nous allons modifier quelques propriétés de notre formulaire.

Tout d’abord, nous allons modifier la propriété BackColor qui représente la couleur de fond de notre
formulaire. On lui affecte la couleur blanche.

On va ensuite changer le texte qui est affiché en haut de notre formulaire. Par défaut la propriété Text
de notre formulaire est initialisée avec la valeur « Form1». Affecter lui, la chaîne de caractères
« Formulaire principal ».

Enfin nous allons modifier l’icône affichée à gauche du texte. Dans le Concepteur de Form, choisissez
une icône pour la propriété Icon.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 12 / 80

Figure 6 - Concepteur de Form, boite à outils et fenêtre de propriétés

L’exemple suivant montre notre méthode InitializeComponent une fois ces modifications appliquées.

private void InitializeComponent()

{
[Link] resources =
new [Link](typeof(Form1));
//
// Form1
//
[Link] =
new [Link](5, 13);

[Link] = [Link];

[Link] =
new [Link](292, 266);

[Link] =
(([Link])([Link]("$[Link]")));

[Link] = "Form1";
[Link] = "Formulaire principal";

[Link] +=
new [Link](this.Form1_Load);
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 13 / 80

Remarquez tout d’abord qu’un ResourceManager a été créé pour le formulaire. Il va permettre de
gérer les ressources utiles au formulaire tel que l’icône que nous avons défini.
Visual Studio a ajouté toutes les lignes de codes correspondantes aux modifications apportées dans le
concepteur de Form.

De même, si vous ajoutez des contrôles dans le concepteur de Form, les déclarations le concernant
seront automatiquement générées dans la méthode InitializeComponent.

Nous allons ajouter un contrôle Button puis constater les modifications faites à InitializeComponent.
Tout d’abord, la déclaration du contrôle va être ajoutée à notre formulaire :

private [Link] button1;

Nous avons modifié le fond du bouton pour qu’il apparaisse en noir, et la couleur de texte pour que
celui ci apparaisse en blanc. Le texte du bouton a été également modifié pour afficher « Test ».

private void InitializeComponent()

{
[Link] resources =
new [Link](typeof(Form1));

this.button1 = new [Link]();

[Link]();
//
// button1
//
[Link] = [Link];
[Link] = [Link];
[Link] = new [Link](88, 208);
[Link] = "button1";
[Link] = 0;
[Link] = "Test";
//
// Form1
//
[Link] =
new [Link](5, 13);

[Link] = [Link];

[Link] =
new [Link](292, 266);

[Link](this.button1);

[Link] =
(([Link])([Link]("$[Link]")));

[Link] = "Form1";
[Link] = "Formulaire principal";

[Link] +=
new [Link](this.Form1_Load);

[Link](false);
}

Toutes les propriétés nécessaires à l’initialisation de notre contrôle Button ont été automatiquement
générées.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 14 / 80

On remarquera l’ajout de la ligne suivante au début de la méthode InitializeComponent:

[Link]();

La méthode SuspendLayout du formulaire permet de suspendre le dessin des contrôles : Tout contrôle
initialisé après l’appel à cette méthode ne sera pas dessiné immédiatement.

Une fois la méthode ResumeLayout du formulaire appelée, les contrôles pourront alors être dessinés.
Cette méthode prend en argument un booléen, qui va indiquer si le dessin des contrôles doit avoir lieu,
dès l’appel de la méthode (true) ou ultérieurement (false).
On constate, que cette méthode est appelée à la fin de la méthode InitializeComponent (une fois tous
les control initialisés) :

[Link](false);

Ici, le dessin des contrôles n’est pas forcé (il pourra se faire ultérieurement).

2.1.2. Méthodes et propriétés principales

• Hide : Cette méthode va vous permettre de cacher le formulaire. Attention, celui ci ne sera pas
détruit mais simplement caché à l’utilisateur.
• Refresh : Force le formulaire à se redessiner avec tout ses control enfants.
• Close : Permet de fermer un formulaire (contrairement à Hide qui ne fait que le cacher).

Pour empêcher l’utilisateur de redimensionner le formulaire, il faudra tout d’abord lui affecter un style
de bordure fixe, initialiser la valeur de la propriété FormBorderStyle avec la valeur FixedSingle.
Il faudra ensuite empêcher l’utilisateur de mettre le formulaire en plein écran. Pour cela, mettez à false
la propriété MaximizeBox. Enfin, n’oubliez pas de fixer la taille définitive que devra avoir votre
formulaire.

2.2. Evènements
2.2.1. Présentation
Les événements vont vous permettre d’effectuer des tâches lors d’actions précises de l’utilisateur. Ils
sont donc à la base de l’interaction entre l’utilisateur et l’application.

Par exemple, lorsque vous cliquez sur un bouton pour afficher une boite de dialogue, vous déclenchez
l’évènement Click du control Button qui contiendra le code pour afficher la boite de dialogue.

Le mécanisme de gestions d’évènements repose sur deux composants :

• Un gestionnaire d’évènement : Méthode qui sera appelée lorsque l’évènement sera déclenché.
Elle devra donc contenir le code implémentant la tâche à effectuer en réponse à l’événement.
• Un délégué : Cet objet permet de faire correspondre un gestionnaire d’évènement à
l’événement que vous voudrez exploiter.

Dans l’exemple suivant, nous allons définir l’événement Click d’un control Button pour qu’une boite
de dialogue soit affichée quand vous cliquez sur le bouton.

Nous allons tout d’abord créer un délégué pour l’événement Click du bouton boutonEvenement :

[Link] += new
EventHandler(boutonEvenement_Click);

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 15 / 80

Il suffira ensuite de créer une méthode qui correspondra à la signature de l’événement Click du
bouton. Dans cette méthode, nous allons tout simplement ajouter le code permettant d’afficher une
boite de dialogue

private void boutonEvenement_Click(object sender, EventArgs e)

{
[Link]("L’utilisateur a cliqué sur le bouton");
}

Maintenant, lorsque vous cliquerez sur votre bouton, la méthode boutonEvenement_Click sera
appelée, et dans notre cas, une boite de dialogue sera affichée.

Astuce : Tapez seulement la ligne suivante et appuyer deux fois sur la touche Tab après l’opérateur +=

[Link] +=

Lorsque vous cliquerez une première fois sur la touche Tab, la ligne sera complétée :

[Link] += new EventHandler();

Lorsque vous appuierez la seconde fois sur la touche Tab, Visual Studio génère le gestionnaire
d’évènement correspondant à l’événement Click, puis complète la ligne précédente avec le nom du
nouveau gestionnaire d’évènement créé :

[Link] += new
EventHandler(boutonEvenement_Click);

Dans le concepteur de Form, il vous suffit de double cliquer sur le contrôle en question pour que
Visual studio génère son délégué et son gestionnaire d’évènement. Bien sûr l’initialisation du délégué
sera faite dans InitializeComponent. L’exemple le plus parlant est la création d’un délégué pour
l’évènement Load du formulaire lorsque vous double cliquez dessus pour afficher le code.

Le point néfaste avec cette méthode est que Visual Studio définira uniquement l’événement principal
du contrôle : Pour un contrôle Button, l’événement principal est le clique. Vous ne pourrez donc pas
définir le délégué et le gestionnaire d’évènement pour l’événement DoubleClick du control Button en
double cliquant sur celui-ci dans le concepteur de Form.
De même, pour le formulaire, c’est l’événement Load qui est géré par défaut.

2.2.2. Paramètres d’un Gestionnaire d’évènement

Par convention, un gestionnaire d’évènement possède deux arguments :
• Sender : Argument de type object qui désigne l’objet qui à générer l’évènement. Si vous
devez effectuer des traitements sur l’objet ayant déclenché l’évènement (modifier son
apparence, mettre à jour ses données…), celui-ci sera disponible directement à l’aide de ce
paramètre.
• e : Ce paramètre représente l’objet contenant les arguments de l’évènement. Si vous devez
récupérer des données spécifiques dans votre gestionnaire d’évènement, c’est dans cet objet
qu’elles devront être passées.
Le paramètre e est un objet de type EventArgs. Si vous voulez créer votre propre paramètre, il
faudra le faire hériter de cette classe et lui ajouter les propriétés ou méthodes dont vous aurez
besoin.

private void buttonLog_Click(object sender,[Link] e)

{
if([Link]() == typeof(Button))

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 16 / 80

{
[Link]("L’appelant est un bouton");
}

2.3. Affichage modal et non modal

Dans une application Windows, un formulaire peut être affiché de deux manières :
• Modal : L’application sera bloquée tant que celui-ci sera affiché.
• Non modal : L’application ne sera pas bloquée pendant l’affichage du formulaire.

Comme formulaire modal, nous pouvons citer la boite de dialogue (MessageBox). Tant que celle-ci
n’est pas fermée ou validée avec le bouton OK, vous n’avez pas accès aux autres formulaires de
l’application.

Figure 7 - Fenêtre modale

En revanche, si vous ajoutez un formulaire à votre application, et que vous l’affichez à l’aide de sa
méthode Show, vous pouvez quand même accéder au reste de l’application (ici le formulaire de
démarrage).

Figure 8 - Fenêtre non modale

Nous avons utilisé la méthode Show dans l’exemple précédent pour afficher le second formulaire.

private void buttonForm2_Click(object sender,[Link] e)

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 17 / 80

{
Form2 f = new Form2();
[Link]();
}

Nous allons reprendre l’exemple précédent et utiliser la méthode ShowDialog plutôt que Show pour
lancer le second formulaire :

private void buttonForm2_Click(object sender, [Link] e)

{
Form2 f = new Form2();
[Link]();
}

En exécutant de nouveau l’application, vous remarquerez que, lorsque le second formulaire s’affiche,
vous n’avez plus accès au formulaire de démarrage. Il s’agit d’un affichage modal.

Ce n’est donc pas une propriété d’un formulaire qui permet de définir son affichage comme modal ou
non, mais la méthode utilisée pour l’afficher :
• Show : Permet d’afficher un formulaire non modal.
• ShowDialog : Permet d’afficher un formulaire modal.

La méthode ShowDialog renvoi une valeur de l’énumération DialogResult qui va indiquer comment
l’utilisateur a quitté une boite de dialogue. On pourra donc savoir s’il a validé, ignoré.…

Pour déterminer ces informations, il suffit de renseigner la propriété DialogResult du bouton qui
servira à quitter le formulaire.
L’exemple suivant montre un formulaire auquel on ajoute deux boutons permettant de le fermer :
• Un bouton portant le texte Valider avec sa propriété DialogResult initialisée avec la valeur
[Link]
• Un bouton portant le texte Annuler avec sa propriété DialogResult initialisée avec la valeur
[Link]

Figure 9 - Fenêtre renvoyant une valeur DialogResult

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 18 / 80

Figure 10 - Choix de la valeur DialogResult

Dans l’exemple suivant, on lance le formulaire de confirmation créé précédemment pour s’assurer que
l’utilisateur veut vraiment quitter l’application. Il suffit de lancer le formulaire à l’aide de la méthode
ShowDialog, puis de tester la valeur renvoyée.
Si l’utilisateur quitte la boite de dialogue en cliquant sur le bouton Valider, alors cela provoquera la fin
de l’application.

En revanche, si l’utilisateur quitte la boite de dialogue en cliquant sur le bouton Annuler, alors il va
falloir annuler la fermeture du formulaire.
Pour cela, l’argument CancelEventArgs possède une propriété prévue à cet effet. Si elle est mise à
true, la propriété Cancel provoquera l’annulation de l’évènement déclenché (ici, l’annulation de la
fermeture du formulaire).

private void Form1_Closing(object sender, CancelEventArgs e)

{
//On lance le formulaire de confirmation
Form2 ConfirmationForm = new Form2();

//On test la valeur DialogResult renvoyée par le

//formulaire f Lorsqu'il est fermé
switch([Link]())
{
case [Link]:
//On ferme l’application
[Link]();
break;

case [Link]:
//On annule la fermeture de l'application
[Link] = true;
break;
}
}

L’énumération DialogResult propose d’autres valeurs :

• [Link] : Valeur transmise lorsque l’utilisateur clique sur un bouton intitulé Oui.
• [Link] : Valeur transmise lorsque l’utilisateur clique sur un bouton intitulé Non.
• [Link] : Valeur transmise lorsque l’utilisateur clique sur un bouton intitulé
Ignorer.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 19 / 80

3. Contrôles
3.1. Introduction
Comme vous le savez certainement, les contrôles Windows sont des objets graphiques permettant
d’interagir avec l’utilisateur. Ils peuvent être définis et utilisés directement dans le code, mais il est
possible également de les utiliser et paramétrer leurs propriétés dans le concepteur de Form.
La boite à outil vous permettra d’ajouter des contrôles. Affichez-la en passant par le menu Affichage
de Visual Studio .Net, ou en utilisant le raccourci Ctrl + Alt + X.

Figure 11 - ToolBox de Visual Studio

Par défaut, la boite à outils ne listent pas tous les contrôles disponibles, aussi, pour en ajouter il vous
suffira de faire un clique droit dessus, puis de sélectionner Ajouter/Supprimer des éléments…

Vous pourrez ensuite configurer les propriétés de vos contrôles en passant par la fenêtre des propriétés
également disponible dans le menu Affichage ou à l’aide du raccourci Alt + Entrée.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 20 / 80

Figure 12 - Propriétés du contrôle

3.2. Contrôles communs

3.2.1. Label
Il s’agit d’un contrôle permettant d’afficher du texte non éditable par l’utilisateur. Il est souvent utilisé
pour accompagner des contrôles qui ne peuvent pas afficher du texte.

Placer un control Label sur votre Form. Faites un clique droit dessus et sélectionner Propriétés.

Définissez les propriétés suivantes :

Figure 13 - Propriété de Form

Cliquer ensuite sur le bouton affichant 3 points, en face du champ Image. Une boite de dialogue va
vous permettre d’ajouter une image qui sera affiché dans votre label.
Sélectionnez l’icône dans le répertoire suivant :

C:\Program Files\Microsoft Visual Studio\Common\Graphics\Icons\Misc\[Link]

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 21 / 80

Il s’agit d’un icône représentant une clé dorée et qui est fournie avec Visual Studio.

Figure 14 - Ajout d'une image dans un label

Voici les modifications apportées à votre code concernant cet objet Label. Bien sûr ces modifications
ont été générées dans InitializeComponent par Visual Studio.

[Link] =
[Link];

[Link] = new [Link]("Verdana",

9.75F, [Link],
[Link],
(([Link])(0)));

[Link] =
([Link])([Link]("[Link]"));

[Link] = new [Link](24, 24);

[Link] = "lblLogin";
[Link] = new [Link](100, 16);
[Link] = 0;
[Link] = "Login";

On constate que toutes les propriétés modifiées dans le concepteur de Form figurent ci-dessus. Nous
aurions pu éditer ces lignes de codes nous même (dans le constructeur du formulaire par exemple)
mais l’utilisation du concepteur de Form est bien plus pratique.

3.2.2. TextBox
[Link]. Présentation et utilisation
Le contrôle TextBox représente une zone de texte éditable par l’utilisateur. Elle est utilisée pour
récupérer des données de l’utilisateur, mais également pour lui en afficher.

Sur le formulaire précédent, ajouter une TextBox en dessous du Label.

private void Form1_Load(object sender, [Link] e)

{
[Link] = 6;
[Link] = [Link];
[Link] = [Link];
}

Le code précédent permet de forcer l’utilisateur à entrer une chaîne de 6 caractères au maximum en
majuscule.
La propriété TextAligne est basée sur l’énumération HorizontalAlignment et permet d’aligner le texte
à gauche.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 22 / 80

Pour permettre à l’utilisateur d’entrer du texte qui pourra tenir sur plusieurs lignes, il suffira de mettre
la propriété MultiLine du contrôle à true.

Pour l’empêcher de modifier le texte affiché, il faudra mettre la propriété ReadOnly à true.

[Link]. Validation du contenu entré par l’utilisateur

Tous les contrôles héritant de [Link] fournissent des évènements permettant
de gérer la validation de son contenu.

Ces évènements sont :

• Validating : Se produit lorsque le control est en cours de validation.
• Validated : Se produit lorsque le control a fini sa validation.

La validation d’un contrôle a lieu lorsque celui-ci perd le focus (on sélectionne un autre control…) ou
lorsque le formulaire se ferme.

Dans l’exemple suivant, nous allons gérer l’événement Validating pour le control TextBox. Supposer
que l’entreprise impose un Login entre 4 et 6 caractères. A l’aide de la propriété MaxLenght de la
TextBox, nous imposons un texte d’une longueur maximal de 6 caractères. Il nous reste donc à vérifier
durant la validation du control que le texte comporte au moins 4 caractères.

On commence par créer un CancelEventHandler pour l’événement Validating qui contiendra le code
permettant de valider le contenu de la TextBox.

private void txtLog_Validating(object sender, CancelEventArgs e)

{
if([Link] < 4)
{
[Link]("Login trop court");
[Link] = true;
}
else
{
//Traitement pour identifier l’utilisateur
}
}

On affichera une boite de dialogue en cas de Login trop court.

De plus, on va utiliser la propriété Cancel de l’argument de type CancelEventArgs transmis en
paramètre du CancelEventHandler.
Ainsi, le contrôle TextBox ne perdra pas le focus en cas de login trop court et l’utilisateur sera forcer
d’entrer un login composé de plus de 4 caractères avant de pouvoir passer sur un autre contrôle.

Il nous reste à créer un délégué pour l’événement Validating de la TextBox qui pointera vers la
méthode définie ci-dessus.

[Link] +=new CancelEventHandler(txtLog_Validating);

Ainsi, dès que la TextBox perd le focus, on vérifie l’intégrité du Login, et si celui-ci est correct, on
passe à la phase d’identification de l’utilisateur.

Cette méthode présente néanmoins des inconvénients, car si vous avez un grand nombre de contrôle à
gérer, cela deviendra vite lourd et complexe.

Par ailleurs, si vous appuyer accidentellement sur la touche Tab, le control perdra le focus (sauf si il
est configuré pour prendre en compte la touche Tab) et la validation sera lancée.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 23 / 80

[Link]. Gestion des mots de passe dans les TextBox

Toujours sur le formulaire précédent, ajouter de nouveau un Label, et une TextBox comme ci
dessous :

Figure 15 - Exemple de boite de Login

Dans la méthode Form1_Load, ajoutez le code suivant :

[Link] = 10;
[Link] = "$";
[Link] += new
CancelEventHandler(txtPass_Validating);

L’exemple précédent limite le mot de passe à 10 caractères et remplace le texte entré par l’utilisateur
par des $.

On créé également un délégué pour gérer la validation du contrôle. On pourra donc vérifier l’intégrité
du mot de passe comme on l’avait fait pour le Login.

3.2.3. Button
Ce contrôle qui est un bouton vous permettra d’effectuer des traitements lorsque vous cliquerez dessus
par exemple. Ajoutez un contrôle de ce type et initialisez-le avec les valeurs suivantes :

[Link] = "Login";
[Link] = [Link];

Il est beaucoup plus pratique de définir les propriétés de ce genre de contrôle directement dans le
concepteur de Form plutôt que dans le code.

Nous allons maintenant gérer la vérification du login et du mot de passe à l’aide du bouton et non plus
en passant par les évènements de validations des contrôles TextBox.

Pour ce faire, il va falloir gérer l’événement Click pour le bouton. Il s’agit de l’événement par défaut
pour ce contrôle, aussi, il vous suffira de double cliquer sur le bouton dans le concepteur de Form pour
qu’un délégué et un Gestionnaire d’évènement soient générés pour cet événement.

Il suffit alors d’ajouter le code nécessaire dans le nouveau Gestionnaire d’évènement :

private void buttonLog_Click(object sender, EventArgs e)

{
if(([Link] < 4) ||([Link] < 6))
{

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 24 / 80

[Link]("Login ou mot de passe incorrect");

}
else
{
//Traitement pour identifier l’utilisateur
}
}

Cette manière de faire est beaucoup plus simple : On gère les TextBox prévues pour le Login et le mot
de passe dans la même méthode.

Par ailleurs, la validation sera lancée lorsque l’utilisateur le voudra, c’est à dire lorsqu’il cliquera sur le
bouton. Plus de problème de validation accidentelle donc.

3.2.4. ListBox
[Link]. Présentation
Le contrôle ListBox permet d’afficher des données sous forme de liste à l’utilisateur. On utilise
souvent les ListBox pour permettre à l’utilisateur de sélectionner des données parmi une liste, comme
dans l’exemple suivant :

Figure 16 - Utilisation du control ListBox

La fenêtre ci-dessus est composée de deux Label, deux ListBox et deux Button. Nous allons créer
ensemble une application qui va nous permettre de sélectionner des données dans la première ListBox
pour les ajouter dans la seconde. On aura alors dans la seconde ListBox uniquement les données utiles
à l’utilisateur.

[Link]. Utilisation
La ListBox possède une collection d’objets nommées Items. Pour ajouter des Items à votre ListBox, il
suffira d’appeler la méthode Add de la collection en spécifiant en argument un objet de type object ou
héritant de object.

En général, les Items d’une ListBox sont simplement des chaînes de caractères.
Voici comment ajouter une chaîne de caractère à la collection Items :

string s = "Nouvel Item";

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 25 / 80

[Link](s);

Vous pouvez également ajouter directement une liste d’Items. Dans notre cas, par exemple, on voudra
afficher une liste de sociétés françaises dans la ListBox de gauche.
Voici comment faire :

//On initialise un tableau de string

//avec le nom de différentes entreprises françaises.
string[] s = {"France Telecom","Alcatel","Total",
"Société Générale","A Novo","Accor"};

[Link](s);

Bien sûr, vous arriverez au même résultat avec la fonction Add utilisée dans une boucle While.
ListBox
Nous allons maintenant voir comment sélectionner un Item puis l’ajouter à la de droite :

Dans la méthode Click du bouton destinée à ajouter des Items (buttonAdd), ajoutez le code suivant :

[Link]([Link]);

Ainsi, lorsque vous cliquerez sur le bouton, l’item actuellement sélectionné dans la ListBox de gauche
sera ajouté à la ListBox de droite.

Il reste néanmoins un problème, vous pourrez ajouter plusieurs fois le même Item. La méthode
Contains de l’objet ListBox va nous permettre de pallier à cela.

private void buttonAdd_Click(object sender,[Link] e)

{
string s = [Link]();

//Si la ListBox de droite ne contient pas l’item Qui est

//sélectionné dans la ListBox de gauche alors on l’ajoute
if()
{
[Link](s);
}
}

Voici ce que devient la méthode Click du bouton d’ajout buttonAdd. Cette fois ci, grâce à la méthode
Contains de la collection Items, on peut tester si un Item existe déjà dans la ListBox de droite avant de
l’y ajouter.

Il nous reste plus qu’à gérer l’événement Click du bouton buttonSuppr, afin de pouvoir supprimer des
éléments de la ListBox de droite.

private void buttonSuppr(object sender, [Link] e)

{
[Link]([Link]);
}

Pour vider l’objet ListPortfolio (correspondant à la liste de droite), il suffit d’appeler la méthode Clear
de sa collection d’Items.

La propriété SelectionMode permet de gérer la sélection des items au sein d’une ListBox. Elle prend
ses valeurs dans l’énumération SelectionMode du namespace [Link].

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 26 / 80

Dans le concepteur de Form, assignez-lui la valeur MultiSimple. Vous pourrez ainsi sélectionner un
ensemble d’items à la fois.

Dans l’exemple suivant, nous avons modifié le code permettant d’ajouter l’item sélectionné dans la
liste de gauche (listAction) dans la liste de droite (listPortfolio). On gère maintenant la multi-
sélection à l’aide de la collection SelectedItems qui représente l’ensemble des objets sélectionnés dans
une ListBox.

private void buttonAdd_Click(object sender,[Link] e)

{
foreach(string s
in [Link])
{
if()
{
[Link](s);
}
}
//Plus aucun n’objet n’apparaît sélectionné
[Link] = null;
}

3.2.5. ListView, TreeView et ImageList

[Link]. ImageList
Un control ImageList centralise les ressources d’images pour un formulaire. Chaque contrôle possède
une propriété ImagelList qui permet d’utiliser les images d’un objet ImageList du formulaire.
Pour utiliser un objet ImageList, il suffit de l’ajouter au formulaire et d’initialiser sa collection
ImageCollection avec des images. Bien sûr vous pouvez faire tout cela dans le concepteur de Form.

Dans les propriétés de l’objet ImageList, cliquer sur le bouton en face du champ Images. Une boite de
dialogue va alors s’afficher pour vous permettre d’ajouter ou de supprimer des images au contrôle.

Figure 17 - Editeur de collections d'objets Image pour le contrôle ImageList

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 27 / 80

Ajoutez un bouton à votre formulaire et dans le concepteur de Form, initialiser la propriété ImageList
du bouton avec l’objet ImageList du formulaire.

Sélectionnez ensuite l’image que vous voudrez utiliser grâce à la propriété ImageIndex.

Voici l’affichage que nous obtenons :

Figure 18 - Utilisation d'une image contenue dans un contrôle ImageList

[Link]. TreeView
L’objet TreeView est très similaire à l’objet ListBox. La principale différence est que l’objet TreeView
introduit une notion de hiérarchie entre les différents Items qui le composent. Vous affichez donc des
nœuds qui eux même pourront en contenir de d’autres.

Ainsi, ce contrôle repose sur la classe TreeNode qui représente un nœud. Un nœud pourra lui même en
contenir un autre et ainsi de suite.
Pour créer un nœud et le configurer, il existe un assistant dans le concepteur de Form, accessible en
cliquant sur le bouton en face du champ Nodes dans les propriétés du contrôle.

Figure 19 - Propriétés du contrôle TreeView

L’éditeur va alors apparaître et vous proposera les fonctionnalités suivantes. Voici l’éditeur d’objets
TreeNode fournit par le concepteur de Form :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 28 / 80

Figure 20 - Editeur de TreeNode

Vous pouvez ajouter des nœuds à la racine du contrôle en cliquant sur le bouton « Ajouter une
racine ». Ici, nous avons deux nœuds racines, Actions et Indices. On va ensuite pouvoir ajouter des
enfants à un nœud sélectionné à l’aide du bouton « Ajouter un enfant ».

Si vous avez ajouté un control ImageList à votre formulaire, vous pourrez afficher des images à
gauche de vos nœuds. Pour cela, c’est très simple, toutes les images de votre ImageList seront listées
dans deux listes déroulantes :
• Image : Permet de choisir une image qui sera affichée à gauche du nœud.
• Image sélectionnée : Détermine l’image à afficher lorsque le nœud est sélectionné.

[Link]. ListView
Ce contrôle permet de lister des Items sous forme d’icônes. Il repose également sur une collection
d’Items que vous pourrez créer et initialiser via un assistant dans le concepteur de Form. Vous pourrez
également utiliser des images stockées dans un objet ImageList de votre formulaire. Il suffira
d’initialiser la propriété ImageList du control avec l’objet ImageList présent dans votre formulaire.
Une liste déroulante est prévue à cet effet dans le concepteur de Form.

A ce propos, le control ListView possède une propriété View permettant de paramétrer l’affichage du
contrôle et qui peut prendre les valeurs suivantes :
• LargeIcon : Si vous choisissez cette valeur, le contrôle ira chercher les images à afficher dans
l’objet ImageList correspondant à la propriété LargeImageList. Les icônes affichées seront
plus grandes.
• Details : Ce mode vous permettra d’afficher composées de plusieurs colonnes à la manière de
l’explorateur Windows.
• SmallIcon : Avec cette valeur, le contrôle ira chercher ses images dans l’objet ImageList
correspondant à la propriété SmallImageList. Les icônes affichées seront plus petites.
• List : Permet d’afficher vos nœuds sous forme d’une liste.

Dès que votre contrôle ListView possède un objet ImageList, vous pouvez lui ajouter des Items. Pour
cela, cliquer sur le bouton en face du champ Items dans les propriétés du contrôle. L’assistant va alors
s’afficher.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 29 / 80

Figure 21 - Editeur de collections de ListViewItem

Pour ajouter un Item à la ListView, il suffit de cliquer sur le bouton Ajouter. Il vous restera alors à
configurer les propriétés du nouvel Item.

Les principales propriétés pour un Item sont :

• ImageIndex : Représente l’indice de l’image à utiliser dans l’objet ImageList du contrôle.
• Text : Représente le texte qui sera affiché sous l’image de l’Item.
• Font : Pour paramétrer l’aspect graphique du texte de la propriété Text.

Voici à quoi ressemble la ListView que nous avons initialisé dans l’assistant du concepteur de Form :

Figure 22 - Contrôle ListView

Il nous reste à gérer le comportement de notre ListView, lorsque vous double cliquez sur un de ses
Items par exemple.

Il va tout d’abord falloir initialiser la propriété Activation du contrôle ListView avec une des trois
valeurs de l’énumération ItemActivation :

[Link] = [Link];

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 30 / 80

Avec la ligne précédente, l’événement ItemActivate d’un Item de la liste sera déclenché lorsque vous
double cliquez dessus.

Définissez ensuite un gestionnaire d’évènement pour l’événement ItemActivate :

private void maListV _ItemActivate(object sender,EventArgs e)

{
foreach(ListViewItem mItem in [Link])
{
[Link]([Link]);
}
}

Et enfin, un délégué :

[Link]+=new EventHandler(maListV_ItemActivate);

Lorsque vous utilisez l’affichage détaillé de votre ListView, vous pouvez afficher plusieurs colonnes.
Pour les ajouter ou les supprimer, servez vous de l’assistant prévu à cet effet, accessible en cliquant
sur le bouton en face du champs Columns dans les propriétés du contrôle. L’ajout de colonnes est très
simple.

Figure 23 - Editeur de collections de ColumnHeader

Une fois vos colonnes ajoutées, il vous faudra passer par la collection SubItems de l’objet
ListViewItem pour ajouter des éléments qui seront affichées dans les différentes colonnes.

//L’item principal sera affiché dans la première colonnes

ListViewItem myItem =
new ListViewItem("Conole MMC", 1);

// Ajout des valeurs pour les trois colonnes restantes

[Link]("Valeur Colonne 2");

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 31 / 80

[Link]("Valeur Colonne 3");

[Link]("Valeur Colonne 4");

//On ajoute notre Item au control

[Link](myItem);

En supposant que votre ListView possède 4 colonnes, l’exemple précédent montre comment créer un
objet ListViewItem possédant une valeur pour chacune des colonnes.
L’objet ListViewItem sera automatiquement affiché dans la première colonne. Les objets contenus
dans sa collection SubItems seront affectés aux autres colonnes.

3.3. BOITES DE DIALOGUES

3.3.1. OpenFileDialog et SaveFileDialog
Ces deux contrôles représentent les boites de dialogues utilisées par Windows pour vous proposer
d’ouvrir un fichier ou de le sauvegarder.

Il s’agit de boites de dialogue modales, elles seront donc lancées à l’aide de la méthode ShowDialog.
Vous pourrez paramétrez le répertoire initiale de la boite de dialogue à l’aide de la propriété
InitialDirectory.

[Link] = @"C:\Documents and Settings";

[Link] = @"C:\Documents and Settings";

Vous pouvez également paramétrez vos boites de dialogues pour qu’elles n’affichent que les fichiers
ayant une certaines extension. Pour cela, il faudra utiliser la propriété Filter. Cette propriété prend une
chaîne de caractère dont la syntaxe est la suivante :

Type_de_Fichier|*.extension

Nous allons voir un exemple pour illustrer cette propriété. Si vous voulez afficher uniquement les
fichiers Word au format doc, voici la chaîne à utiliser :

[Link] = "Fichier Word|*.doc";

Fichier sera le libellé affiché dans la boite de dialogue, ce qui suit le | permettra de filtrer les fichiers.
Vous pouvez également préciser une chaîne de caractère avant l’extension si vous voulez recherchez
un fichier comportant cette chaîne.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 32 / 80

Figure 24 - Contrôle OpenFileDialog

La propriété CheckFileExists permet de vérifier si le fichier stipulé par l’utilisateur existe lors de la
fermeture de la boite de dialogue. Il s’agit d’un booléen, à true la vérification sera faite et à false,
aucune vérification ne sera effectuée.

La propriété AddExtension permettra de contrôler l’extension du fichier sélectionné par l’utilisateur.

Prenons le cas où la propriété est mise à true : Si l’utilisateur a précisé l’extension après le nom de
fichier, aucun problème. Dans le cas contraire, l’extension sera automatiquement ajoutée.

Mise à false, aucune vérification ne sera effectuée et si l’utilisateur ne précise pas l’extension à la fin
du non du fichier, celle-ci ne sera pas ajoutée.

Si de plus, vous mettez la propriété CheckFileExists à true alors une erreur sera générée puisque le
fichier ne sera pas trouvé (il manquera l’extension).

Figure 25 - Utilisation de la propriété CheckFileExists

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 33 / 80

Voyons un exemple plus concret qui va nous permettre de sélectionner des images à travers un
contrôle OpenFileDialog puis d’afficher l’image sélectionnée par l’utilisateur.

Tout d’abord, nous allons paramétrer notre boite de dialogue pour qu’elle ne liste que les fichiers avec
l’extension JPG :

private void formPict_Load(object sender, [Link] e)

{
[Link] = true;
[Link] = true;

[Link] =
@"C:\Documents and Settings\Images personnelles"

[Link] = "Fichiers images|*.jpg" ;

}

Ajoutons maintenant un bouton. Lorsque l’utilisateur cliquera sur le bouton, la boite de dialogue
s’affichera. Une fois son fichier sélectionné, s’il valide la boite de dialogue alors l’image sera affichée
dans un contrôle PictureBox (control servant à afficher des images) :

private void picButton_Click(object sender,[Link] e)

{
//Si la boite de dialogue est validée
if([Link]() == [Link])
{
//On affiche l’image dans un control PictureBox
[Link] = [Link]([Link]);
}
}

Voici ce que l’on obtient:

Figure 26 - Afficher une image sélectionnée à travers le contrôle OpenFileDialog

3.3.2. FolderBrowserDialog
Ce contrôle représente la boite de dialogue Windows permettant de sélectionner un répertoire. Il s’agit
en fait d’une boite de dialogue composée d’un TreeView et qui ne liste que les répertoires.

La propriété Description vous permettra d’ajouter une petite description en haut de la boite de
dialogue :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 34 / 80

Figure 27 - Contrôle FolderBrowserDialog

Vous pourrez choisir le répertoire racine à partir duquel commencera l’arborescence de votre contrôle
à l’aide de la propriété RootFolder. Seuls les sous répertoires du répertoire racine (correspondant à la
propriété RootFolder donc) seront listés. Vous pourrez choisir votre répertoire racine parmi ceux
proposés dans la liste déroulante. Dans l’exemple précédent, nous avions initialisé cette propriété avec
la valeur ProgramFiles qui nous permettra d’avoir une arborescence qui commencera à partir du
répertoire "Program Files" de l’utilisateur.

Ce contrôle représente également une boite de dialogue modale, aussi pour pouvoir l’afficher, il vous
faudra utiliser la méthode ShowDialog :

[Link]();

Enfin, pour récupérer le répertoire choisi par l’utilisateur lorsqu’il valide la boite, il suffira d’utiliser la
propriété SelectedPath :

private void mbutton_Click(object sender, [Link] e)

{
if([Link]() == [Link])
{
[Link]([Link]);
}
}

Dans l’exemple précédent, on affiche une boite de dialogue FolderBrowserDialog. Si elle est validée
par l’utilisateur alors on affiche le chemin du répertoire qu’il a sélectionné dans une boite de dialogue
simple.

3.3.3. FontDialog
Tous les contrôles affichant du texte possèdent une propriété Font. Elle vous permet de paramétrer
l’aspect graphique du texte à afficher (police, taille etc.…). En générale, ces données sont initialisées
par le développeur et l’utilisateur n’y a pas accès. Si vous voulez permettre à l’utilisateur de modifier

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 35 / 80

l’aspect graphique d’un texte alors le control FontDialog vous fournit une interface graphique pour
interagir avec l’utilisateur.

Il s’agit de la boite de dialogue standard de Windows (Word etc.…), ce contrôle est très facile à
utiliser :

Le concept est simple, le contrôle FontDialog possède une propriété Font. Lorsque l’utilisateur
effectuera ses modifications dans la boite de dialogue, celles-ci seront stockées dans la propriété Font
de la boite de dialogue. Il suffira ensuite d’initialiser la propriété Font du contrôle cible avec celle de
votre objet FontDialog.

private void mButton_Click(object sender, [Link] e)

{
FontDialog maFontDg = new FontDialog();

if([Link]() == [Link])
{
//On affecte l’objet Font du control FontDialog
//à la propriété Font d’un control TextBox
[Link] = [Link];
}
}

Dans l’exemple précédent, lorsque l’utilisateur clique sur le bouton mButton, on créé un nouvel objet
FontDialog, puis on le lance avec la méthode ShowDialog. La boite de dialogue sera donc affichée de
façon modale et le reste de l’application sera bloqué tant que la boite restera affichée.
Lorsque l’utilisateur ferme la boite, on teste à l’aide de la propriété DialogResult s’il l’a validé ou non.
S’il a validé la boite de dialogue, alors on affecte la Font paramétrée par l’utilisateur à celle d’un
control TextBox.

3.3.4. ColorDialog
Le contrôle ColorDialog est très similaire au contrôle FontDialog. Il affichera une boite de dialogue à
l’utilisateur lui permettant de modifier les couleurs affichées par vos contrôles.

private void mButton_Click(object sender, [Link] e)

{
ColorDialog maColorDg = new ColorDialog();

if([Link]() == [Link])
{
[Link] = [Link];
}
}

3.4. DataGrid
3.4.1. Introduction
Le contrôle DataGrid est un contrôle qui vous permettra d’afficher des données très simplement, sous
la forme d’une grille.
Cette grille est représentée par une collection d’objets DataGridTableStyle. Il ne faut absolument pas
confondre cet objet et l’objet DataTable que vous étudierez plus en détail dans le cours [Link].

L’objet DataGridTableStyle représente quant à lui une table au sein du contrôle DataGrid.
Contrairement à l’objet DataTable, l’objet DataGridTableStyle prendra en compte l’aspect graphique.
L’objet DataGridTableStyle est composé d’objets DataGridColumnStyle qui représentent les
colonnes au sein d’un DataGridTableStyle.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 36 / 80

Au final, la structure est très proche de celle d’une base de données (une base qui va contenir des
tables qui seront composées de colonnes) avec la possibilité de gérer l’affichage des éléments.

Figure 28 - Structure du contrôle DataGrid

3.4.2. Liaison à une source de donnée

Un Dataset est un groupe de données. Il sera étudié plus en détail dans le cours [Link].
Vous pouvez lier votre Datagrid à un Dataset pour en afficher les données. Il suffira de spécifier le
Dataset à utiliser à l’aide de la propriété DataSource du Datagrid. Dans le concepteur de Form, une
liste déroulante vous proposera toutes les sources disponibles au sein du projet.

Figure 29 - Choix de la source de donnée pour un contrôle DataGrid

La propriété DataMember vous permettra de spécifier l’objet DataTable à utiliser au sein du DataSet.

Figure 30 - Contrôle DataGrid au sein d'une application Windows

Le DataSet adoptera la structure de la table avec laquelle on a initialisé la propriété DataMember.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 37 / 80

3.4.3. Editeur de Styles

Cet éditeur accessible en cliquant sur le bouton en face du champ TableStyles vous permettra d’ajouter
et de supprimer des styles pour vos tables qui contiendront les données pour votre DataGrid. Vous
pourrez ensuite choisir les colonnes à afficher et lui affecter un style.

Figure 31 - Editeur de collections d'objets DataGridTableStyle

Pour ajouter un style de table à votre DataGrid, il vous suffit de cliquer sur "Ajouter". Vous pourrez
ensuite paramétrer le nouveau style dans la partie de droite. La gestion de l’affichage des données se
voit donc simplifiée.

Voici les différentes propriétés graphiques d’un objet DataGridTableStyle :

Figure 32 - Propriétés graphiques de l'objet DataGridTableStyle

La propriété BackColor permet de modifier la couleur de fond de votre grille. La propriété

SelectionBackColor permet de choisir la couleur d’une ligne lorsqu’elle sera sélectionnée. Cette
propriété va de paire avec la propriété SelectionForeColor qui permet de modifier la couleur de police
pour la ligne sélectionnée.

Enfin, la propriété AlternatingBackColor permet de spécifier une couleur de fond qui apparaîtra une
ligne sur deux.

Vous allez pouvoir affecter ce style à une table de votre structure de données. Pour cela, initialiser la
propriété MappingName de l’objet avec le nom de la table en question.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 38 / 80

Une fois votre objet DataGridTableStyle configuré, il ne vous reste plus qu’à lui ajouter des styles de
colonnes en passant par sa collection d’objets DataGridColumnStyle. Il existe également un éditeur
pour les d’objets de ce type. Pour y accéder, cliquer sur le bouton en face du champ GridColumnStyle
dans les propriétés de votre objet DataGridTableStyle. Grâce à cette collection, vous allez pouvoir
sélectionner les colonnes à afficher, l’ordre dans lequel elles apparaîtront.

Figure 33 - Editeur de collections d'objets DataGridColumnStyle

Cet éditeur permet de configurer les paramètres pour les données au niveau d’une colonne. Vous allez
pouvoir spécifier le texte d’en-tête de la colonne à l’aide de la propriété HeaderText. La propriété
NullText permet de spécifier le texte lorsqu’une valeur de la colonne est nulle.

Pour affecter ce style à une colonne de votre structure de données, utiliser la propriété MappingName
comme pour l’objet DataGridTableStyle. Il suffira de spécifier le nom de la colonne.

Pour résumer, notre DataGrid est lié à la table Produit contenu dans notre structure de donnée
dsQuote1.
Ensuite, nous avons ajouté un style de table que nous avons affecté à la table Produit.
Pour n’afficher que les colonnes Nom et Valeur (dans notre cas, l’utilisateur n’a pas besoin de l’id
d’un produit ni de son type), nous avons créé deux styles de colonnes que nous leur avons affecté.

Voici le résultat :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 39 / 80

Figure 34 - DataGrid

3.5. USERCONTROLS
3.5.1. Présentation
Nous avons vu comment utiliser les principaux contrôles présents lorsque vous créer une application
Windows. Il vous est également possible de créer vos propres contrôles.
Tous les contrôles héritent de la classe Control., vous pourrez donc créer vos propres contrôles en
créant des classes dérivant de UserControl.

3.5.2. Création
Visual Studio .Net vous propose deux solutions pour créer vos contrôles :
• Ajoutez à votre projet un control utilisateur. Il s’agit d’un fichier de code qui contient une
classe héritant de UserControl. Dans l’explorateur de solution, faites un click droit sur projet
puis : Ajouter >> Ajouter un contrôle utilisateur…

Figure 35 - Ajout d'un contrôle utilisateur à un projet d'application Windows

Par défaut, le contrôle utilisateur aura le nom du fichier qui le contient. Le contrôle utilisateur
apparaît dans le concepteur de Form, vous pouvez lui ajouter n’importe quel contrôle
Windows Form (comme pour un formulaire).

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 40 / 80

• Créer un projet Bibliothèque de contrôles Windows : Il s’agit d’un type de projet vous
permettant de créer des contrôles qui seront réutilisables par d’autres applications. Vous
pourrez également déployer ce type de projet, ainsi la réutilisation du code se voit accrue et
simplifiée.

Figure 36 - Création d'une bibliothèque de contrôles utilisateur

Vous pourrez donc créer des contrôles pour des besoins ponctuels (première méthode) ou pour des
besoins à long terme (deuxième méthode).

Quelque soit la méthode utilisée, le contrôle utilisateur apparaît dans le concepteur de Form, aussi
vous pouvez le designer, c’est à dire lui ajouter des contrôle un peu à la manière des formulaires.
Vous pourrez également lui ajouter du code, gérer des évènements déclenchés par un des contrôles
(qu’il possède) ou par lui même.

L’événement principal d’un contrôle utilisateur est Load qui est déclenché lorsque le contrôle est
chargé par le formulaire.

Figure 37 - Contrôles utilisateur dans le concepteur de Form

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 41 / 80

Nous allons créer un contrôle d’authentification : Ce contrôle devra permettre à l’utilisateur d’entrer
son Login et son mot de passe, puis il devra vérifier que les informations entrées par l’utilisateur sont
valables.

Au niveau de l’interface graphique, notre contrôle devra donc posséder deux TextBox paramétrées
pour nos besoins, ainsi que deux Label les accompagnants et un bouton.
Pour créer le contrôle utilisateur, reprenez tout simplement l’exemple qui nous a permis d’illustrer les
contrôles Label, TextBox et Button. Votre contrôle utilisateur devrait ressembler à cela :

Figure 38 - Contrôle utilisateur "AuthenticationControl"

[Link] vous fournit des classes représentant des structures de données, telles qu’une table de base
de données, une colonne d’une table etc…

Ainsi, lorsqu’un développeur utilisera le contrôle, il aura juste à entrer les paramètres nécessaires à
l’initialisation du DataSet, et tout sera géré automatiquement.

Nous allons ajouter quatre propriétés à notre contrôle :

• UserTable : Cet objet DataTable représentera la table d’utilisateur dans laquelle on ira
chercher l’utilisateur qui aura tenté de s’authentifier.

private DataTable _userTable;

public DataTable UserTable

{
get
{
return _userTable;
}
set
{
_userTable = value;
}
}

• PasswordColumn : Il s’agira d’un entier qui représentera l’index de la colonne contenant les
mots de passe des utilisateurs (Selon l’objet DataTable utilisé, cette colonne pourra se trouvée
en première position, deuxième position etc.…).

private int _passwordColumn;

public int PasswordColumn

{
get
{

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 42 / 80

return _passwordColumn;
}
set
{
_passwordColumn = value;
}
}

• LoginColumn : De même que pour la propriété précédente, celle-ci représentera l’index de la

colonne contenant les logins cette fois-ci.

private int _loginColumn;

public int LoginColumn

{
get
{
return _loginColumn;
}
set
{
_loginColumn = value;
}
}

• FormSuivante : Si notre utilisateur est authentifié, il arrivera sur une page d’accueil. Cette
page d’accueil sera un formulaire Windows. Grâce à cette propriété, il suffira de créer son
formulaire d’accueil et de l’affecter à la propriété pour que l’utilisateur arrive directement
dessus en cas d’authentification.

private [Link] _formSuivante;

public [Link] FormSuivante

{
get
{
return _formSuivante;
}
set
{
_formSuivante = value;
}
}

L’authentification se passera au niveau du bouton : dès que l’utilisateur cliquera sur le bouton, il
suffira de comparer les données entrées dans les TextBox avec celles contenues dans l’objet
DataTable du contrôle.
Si les données existent, l’utilisateur sera authentifié et il arrivera sur le formulaire FormSuivante.
Sinon, un message d’erreur sera affiché.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 43 / 80

L’exemple suivant illustre le code utilisé lorsque l’événement Click du bouton sera déclenché:

private void loginButton_Click(object sender,EventArgs e)

{
bool userExist = false;

string login = [Link];

string password = [Link];

//Pour chaque ligne de l’objet DataTable

//On compare le login et le mot de passe
foreach(DataRow dr
in [Link])
{
//Si le login et le mot de passe correspondent
//avec une entrée dans table
if([Link](LoginColumn) == login
&& [Link](PasswordColumn) == password)
{
//l’utilisateur est authentifié
userExist = true;
//On quitte la boucle
break;
}
}

//Si l’utilisateur existe dans la table

//il arrive sur la page d’accueil
if(userExist)
{
[Link]("Bienvenue");

[Link]();

//On lance la page d’accueil

_formSuivante.Show();
}
else
{
//Message d’erreur, l’utilisateur n’est pas reconnu
[Link]("Login ou Mot de passe erroné");
}
}

3.5.3. Utilisation
Une fois, notre contrôle créé, il nous reste plus qu’à l’utiliser dans une de nos applications.
Deux cas de figures se présentent à nous :
• Si vous avez créé votre contrôle utilisateur directement au sein de votre application, pour
l’utiliser il faudra le déclarer et de l’initialiser dans le code :

private void AuthenticationControlInit(DataTable usrTable,

int passCol, int logCol, Form Accueil)
{
//On créer une instance de notre control
AuthenticationControl myAuthControl =
new AuthenticationControl();

//On initialise les différentes propriétés du control

[Link] = usrTable;

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 44 / 80

[Link] = passCol;
[Link] = logCol;
[Link] = Accueil;

//On définit l’emplacement du control sur le formulaire

[Link] = new Point(70,0);

//On ajoute le control au formulaire

[Link](myAuthControl);
}

L’exemple précédent illustre une méthode permettant d’initialiser votre contrôle au sein du
formulaire. Il vous suffira d’appeler cette méthode dans le constructeur de votre formulaire par
exemple :

//Constructeur du formulaire loginForm qui contiendra notre //control

utilisateur
public loginForm()
{
// Requis pour la prise en charge du Concepteur Windows
//Forms
InitializeComponent();
//
// TODO : ajoutez le code du constructeur après l'appel à
//InitializeComponent
//
//Méthode qui va créer et initialiser notre control
AuthenticationControlInit(new DataTable(),1,2,
new formAccueil());
}

• Si vous avez créé un projet de bibliothèque de contrôles utilisateurs, il vous faudra générer
votre projet :
Générer >> Générer en tâche de fond…
Dans la boite de dialogue, cochez la case qui vous permettra de générer votre projet en mode
Release puis cliquer sur Générer (voir chapitre 8).

Une fois votre projet générer, vous disposerez d’un assemblage contenant votre contrôle et il
vous suffira de l’ajouter à un projet.
Dans l’application à laquelle vous voulez ajouter ce contrôle, faites un clique droit sur la boite
à outils. Sélectionner Ajouter/Supprimer des éléments…
Une boite de dialogue va s’afficher. Elle va vous permettre d’ajouter ou de supprimer des
contrôles à votre boite à outils.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 45 / 80

Figure 39 - Ajout d'un contrôle à la boite à outils

Cliquer sur Parcourir, puis recherchez l’assemblage généré par votre projet de bibliothèque de
contrôles Windows.
Ajoutez-le puis valider la boite de dialogue. Le contrôle va être ajouté à la boite à outils et vous
pourrez l’utiliser dans le concepteur de Forrm.

Figure 40 - Contrôle AuthenticationControl dans la boite à outils

Vous pourrez ainsi ajoutez votre contrôle à votre formulaire. Il ne vous restera plus qu’à initialiser ses
propriétés dans le code, et il sera fonctionnel au sein de votre application.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 46 / 80

4. Menus
4.1. L’objet MenuItem
Les contrôles MainMenu et ContextMenu reposent sur le même fonctionnement : Ils sont basés sur
des objets MenuItem qui peuvent répondre à des évènements tels qu’un clique d’une souris.
• Text : Correspond au texte affiché pour l’élément.
• Checked : Booléen qui indique si l’élément est sélectionné ou non (il apparaît coché ou non).
• ShortCut : Permet de définir un raccourci clavier pour l’élément.
• MenuItems : Chaque objet MenuItem peut lui même contenir une collection d’objet
MenuItem. Autrement dit, un élément peut lui même contenir une liste. C’est le principe des
menus Windows.

Le code suivant montre comment créer des objets MenuItem liés par une arborescence :

private void menuItemConnection()

{
MenuItem connItem =
new MenuItem("Chaine de connexion");
[Link] = Shortcut.F5;
[Link] += new
EventHandler(connItem_Click);

MenuItem ItemDefaut = new MenuItem("Défaut");

[Link] = true;
[Link] += new
EventHandler(ItemDefaut_Click);

MenuItem ItemSecure = new MenuItem("Sécurisée");

[Link] += new
EventHandler(ItemSecure_Click);

MenuItem[] tmp = {ItemDefaut,ItemSecure};

[Link](tmp);
}

La méthode AddRange permet d’ajouter une collection d’objet MenuItem. Pour ajouter seulement un
élément, il vous faudra utiliser la méthode Add.

On va gérer un clique de l’utilisateur sur l’élément grâce à l’événement Click.

Nous disposons de deux chaînes de connexions stockées dans un fichier de configuration. L’exemple
suivant montre comment nous allons pouvoir changer de chaîne de connexion en gérant l’événement
Click de deux objets MenuItem appartenant à l’arborescence définie précédemment.

private void ItemDefaut _Click(object sender,

[Link] e)
{
//Si l’autre élément est sélectionné,
//On le décoche
if([Link])
{
[Link] = false;
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 47 / 80

//On initialise la chaîne de connexion avec la bonne

//valeur récupérée dans le fichier de configuration
[Link] =
[Link]["Default"];

//On coche l’élément que l’on vient de sélectionner

[Link] = true;
}

private void ItemSecure _Click(object sender,

[Link] e)
{
if([Link])
{
[Link] = false;
}

[Link] =
[Link]["Default"];

[Link] = true;
}

Nous allons maintenant voir comment utiliser des objets MenuItem au sein des objets MainMenu et
ContextMenu.

4.2. MainMenu
Ce contrôle vous permet d’ajouter des menus Windows, autrement dit, une barre de listes déroulantes
pouvant elles même contenir d’autres listes déroulantes. Cette barre apparaîtra constamment en haut
de votre formulaire.

Voici à quoi ressemble un Menu créé à partir de l’objet MainMenu :

Figure 41 – Contrôle MainMenu dans une application Windows

Vous l’aurez compris, ce menu repose sur des objets MenuItem liés par une arborescence telle que
celle que l’on a défini à la partie précédente.
Le contrôle MainMenu va permettre d’afficher l’arborescence d’objets MenuItem sous forme de
menu Windows.

Ajoutez un contrôle MainMenu à votre formulaire. Remarquez tout d’abord que celui-ci ne va pas se
placer sur la Form. C’est le menu qu’il représente qui sera placé en haut du formulaire. Lorsqu’il
n’existe pas encore de liste dans le menu, celui-ci n’est visible que lorsque vous sélectionnez l’objet
MainMenu.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 48 / 80

Figure 42 - Contrôle MainMenu dans le concepteur de Form

Le contrôle MainMenu possède une collection d’objets MenuItem. Par exemple, si vous disposez
d’une arborescence d’objet MenuItem, il vous suffira d’ajouter le MenuItem racine (celui qui contient
tous les autres) à la collection d’objets MenuItem du control MainMenu.

private void menuItemConnection(MainMenu menuPrincipal)

{
MenuItem connItem =
new MenuItem("Chaine de connexion");
[Link] = Shortcut.F5;
[Link] +=
new EventHandler(connItem_Click);

MenuItem ItemDefaut = new MenuItem("Défaut");

[Link] = true;
[Link] +=
new EventHandler(ItemDefaut_Click);

MenuItem ItemSecure = new MenuItem("Sécurisée");

[Link] +=
new EventHandler(ItemSecure_Click);

MenuItem[] tmp = {ItemDefaut,ItemSecure};

[Link](tmp);

//On ajoute simplement le MenuItem racine

//à la collection
[Link](connItem);
}

Pour ajouter une liste déroulante, il suffit d’entrer son nom. Vous pourrez ensuite lui ajouter des
éléments de proche en proche. Pour définir l’évènement Click d’un objet MenuItem de la barre de
menu, il vous suffira de double cliquer dessus comme pour tout autre contrôle.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 49 / 80

Figure 43 - Création d'un Menu MainMenu dans le concepteur de Form

4.3. ContextMenu
L’objet ContextMenu est le même que l’objet MainMenu, à la différence près que celui ci ne
s’affiche que lorsque vous faites un clique droit sur un contrôle.

D’ailleurs chaque contrôle possède une propriété ContextMenu. Ainsi, il suffit de construire une
arborescence d’objets MenuItem, de la rattacher à un objet ContextMenu via la collection
MenuItems.
Il ne restera plus qu’à initialiser la propriété ContextMenu de n’importe quel contrôle avec ce nouveau
menu pour que celui-ci s’affiche en cas de clique droit sur le contrôle en question.

private void menuItemConnection(ContextMenu menuFormulaire)

{
MenuItem connItem =
new MenuItem("Chaine de connexion");
[Link] = Shortcut.F5;
[Link] +=new
EventHandler(connItem_Click);

MenuItem ItemDefaut = new MenuItem("Défaut");

[Link] = true;
[Link] +=new
EventHandler(ItemDefaut_Click);

MenuItem ItemSecure = new MenuItem("Sécurisée");

[Link] +=new
EventHandler(ItemSecure_Click);

MenuItem[] tmp = {ItemDefaut,ItemSecure};

[Link](tmp);

//On ajoute simplement le MenuItem racine

//à la collection
[Link](connItem);

//on assigne le nouveau ContextMenu au formulaire courant

[Link] = menuFormulaire ;
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 50 / 80

4.4. ToolBar
4.4.1. Présentation
Le control ToolBar permet d’afficher une barre de menu, composée cette fois ci de boutons et non de
liste déroulante.

Le principe reste le même, vous ajoutez une collection d’objets ToolBarButton à un objet ToolBar qui
permet d’afficher la barre d’outil et d’effectuer des actions lors d’un clique sur un des boutons.

Figure 44 – Contrôle ToolBar au sein d'une application Windows

La propriété Dock de votre contrôle ToolBar permettra de définir où celui-ci apparaîtra sur le
formulaire. Cette barre pourra apparaître en haut, en bas, à droite ou à gauche de votre formulaire.

La propriété ImageList du control ToolBar permet d’ajouter un contrôle ImageList à celui-ci. Vous
pourrez ensuite afficher des images de votre objet ImageList sur les boutons de votre barre d’outils.

4.4.2. L’objet ToolBarButton

Le control ToolBar repose donc sur une collection d’objets ToolBarButton, dont nous allons voir les
principales propriétés :
• Text : Texte qui sera affiché sur le bouton.
• ToolTipText : Info Bulle affichée lors du passage de la souri sur le bouton.
• Visible : Indique si le bouton est visible ou non.
• ImageIndex : Index d’une image que l’on voudra afficher pour le bouton. Cette Image devra
faire partie d’un ImageList assignée à l’objet ToolBar par sa propriété ImageList.
• Pushed : Valeur indiquant si le contrôle apparaît comme enfoncé.

Voici la déclaration d’un objet ToolBarButton :

ToolBarButton boutonGraphe = new ToolBarButton();

[Link] = "";
[Link] = "Tracer une courbe";
[Link] = true;
[Link] = 0;
[Link] = false;

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 51 / 80

4.4.3. Création d’une barre d’outil

Il suffira ensuite d’ajouter cet objet à notre ToolBar. L’exemple suivant montre comment faire :

ToolBar maBarre = new ToolBar();

[Link](boutonGraphe);

Un assistant va vous permettre de créer et d’ajouter directement vos objets ToolBarButton à l’objet
ToolBar.

Cet assistant est accessible via la propriété Buttons du contrôle ToolBar.

Voici à quoi il ressemble :

Figure 45 - Editeur de collections d'objets ToolBarButton

Vous pourrez ajouter des ToolBarButton à votre Toolbar et éditer directement les propriétés du
nouvel élément. Vous pourrez également supprimer des objets ToolBarButton.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 52 / 80

5. DRAG & DROP

5.1. Présentation
Sous Windows, le Drag & Drop est un mécanisme qui joue un rôle majeur dans l’interaction entre un
utilisateur et une application. Il permet à l’utilisateur de déplacer des données d’un contrôle à l’autre
même si ceux-ci ne font pas parti de la même application.
Le Drag & Drop utilise la souris pour déplacer des données d’un contrôle vers un autre.

Par exemple, pour ajouter des contrôles à votre formulaire dans le concepteur de Form, vous utiliser le
Drag & Drop.

5.2. Utilisation
Nous allons voir dans cette partie comment utiliser le Drag & Drop entre deux ListBox dans une
même application. Nous allons reprendre l’exemple qui nous a servi à illustrer le control ListBox.
Nous n’utiliserons plus les deux boutons pour ajouter un élément ou pour le supprimer.

La première chose à faire est d’autoriser le Drag & Drop sur le control qui devra recevoir les données.
Vous pourrez faire cela à l’aide de la propriété AllowDrop du contrôle cible.
Dans notre cas, l’utilisateur devra déplacer des éléments de la ListBox de gauche (listAction) vers la
ListBox de droite (listPortfolio). Il faudra donc autoriser le Drag & Drop pour l’objet listPortfolio.

[Link] = true;

Ensuite, il faut déclencher le Glisser/Déplacer lorsque vous aurez sélectionné un item dans le contrôle
listAction.
La méthode DoDragDrop est prévue à cet effet, elle se trouve dans la classe Control qui est la classe
mère de tous vos contrôles Windows Application.
Dans notre cas, il faut lancer cette méthode lorsque l’utilisateur aura sélectionné un item dans l’objet
listAction et avant qu’il ait relâché le clique de la souris.
Nous appellerons donc la méthode DoDragDrop lorsque l’évènement MouseDown de l’objet
listAction sera déclenché. Cet évènement est déclenché lorsque le clique de la souris est enfoncé au
dessus de la ListBox.

private void listAction_MouseDown(object sender,

MouseEventArgs e)
{
//Si la ListBox ne comporte aucun item, rien ne se passe
if([Link]==0) return;

//On récupère l’item en dessous du pointeur de la souri

//lorsque le click est enfoncé
string s = (string)
[Link][[Link](e.X,e.Y)];

//On démarre l’opération de glisser/déplacer

[Link](s,[Link]);
}

Pour le control cible (celui qui recevra les données), l’implémentation du Drag & Drop repose sur
deux évènements principaux (il en existe d’autres) qui sont définis pour tous les contrôles.

• DragOver : Se déclenche lorsque l’on déplace un élément sur le contrôle à l’aide de la souris.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 53 / 80

• DragDrop : Se produit lorsque l’on relache le click de la souri.

On commence par définir l’évènement DragOver pour le control listPortfolio. On va définir dans cet
évènement l’effet appliqué aux données qui seront déplacées. On utilise pour ce faire les membres de
l’énumération DragDropEffects. Dans notre cas, on utilise la valeur Copy qui indique que les données
seront copiées vers la cible de déplacement.

private void listPortfolio_DragOver(object sender,

DragEventArgs e)
{
[Link]= [Link];
}

Il nous reste maintenant à définir l’évènement DragDrop de l’objet listPortfolio. Il faut tout
simplement que le code permette de copier les données du Glisser/Déplacer dans la ListBox en
question. Nous reprenons pour cela le code qui nous avait servi pour le bouton Ajouter dans notre
l’exemple du control ListBox.

private void listPortfolio_DragDrop(object sender,

DragEventArgs e)
{
//On teste si les données déplacées vers la ListBox
//sont bien de type string
if([Link]([Link]))
{
//On récupère les données
string str= (string)
[Link]([Link]);

//Si la ListBox ne contient pas l’item,

//On l’ajoute
if()
{
[Link](str);
}
}
}

Notre application est maintenant complète, vous pourrez glisser des items de la ListBox de gauche
vers celle de droite.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 54 / 80

6. Dessin avec GDI+

[Link]ésentation
La bibliothèque de classes de GDI+ repose sur GDI qui est une technologie de Microsoft utilisée par
Windows pour effectuer les dessins de fenêtres et autres composants visuels de votre interface
utilisateur. GDI est une couche d’abstraction entre le matériel et les applications ce qui rend le
développement indépendant du hardware.
GDI+ est une API de développement permettant de réaliser des rendus graphiques de manière
simplifiée. En effet, GDI+ est une extension des possibilités de GDI avec une couche objet intuitive
facilitant son utilisation. Parmi les améliorations apportées par GDI+, on peut noter la gestion de la
transparence et les transformations géométriques.

[Link] éléments de base

Nous allons tout d’abord présenter les structures élémentaires présentes fréquemment dans la
programmation graphique.
Ces structures sont les suivantes :

• [Link] et [Link]
Ces deux structures représentent un point avec ses coordonnées en 2D, X et Y qui sont également des
propriétés de Point et PointF.
Les coordonnées d’un Point sont exprimées avec des int alors que celles d’un PointF le sont en float.
Le constructeur le plus simple est le suivant :

// x et y sont de type int.

Point pt = new Point(x, y);

Pour PointF, x et y seront des variables de type float.

• [Link] et [Link]
Comme leur nom l’indique, ces deux structures définissent une dimension. Concrètement,
l’association d’une longueur et d’une largeur représentées par les propriétés Width et Height.
Le constructeur est le suivant :

// width et height sont de type int.

Size sz = new Size(width, height);

Pour SizeF, width et height seront des variables de type float.

• [Link] et [Link]
Ces deux structures représentent un rectangle, avec les propriétés Left, Top, Width et Height pour le
définir.
La différence entre Rectangle et RectangleF vient du fait que les coordonnées et dimensions d’un
Rectangle sont exprimées avec des int alors celles du RectangleF sont exprimées avec des float.
Les deux principaux constructeurs de cette entité sont :

// En précisant les coordonnées du coin supérieur gauche ainsi que les

dimensions width et height du rectangle (longueur et largeur).
// x, y, width et height sont de type int.
Rectangle rect = new Rectangle(x, y, width, height);

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 55 / 80

// En précisant le point représentant le coin supérieur gauche (Point) et

les dimensions (Size).
// rectLocation et de type Point et rectSize de type Size.
Rectangle rect = new Rectangle(rectLocation, rectSize);

Pour RectangleF se sont les mêmes constructeurs à la différence, que les coordonnées sont des float,
rectLocation et de type PointF et rectSize de type SizeF.

• [Link]
Enfin, la structure Color, représente une couleur ARGB (Alpha, Red, Green, Blue). Le alpha
représente le niveau de transparence de cette couleur.
Il est possible de créer une couleur grâce à la méthode statique FromArgb :

// a, r, g et b sont de type byte.

Color c = [Link](a, r, g, b);

Mais aussi par le biais des propriétés de la structure Color représentant des couleurs prédéfinies:

• [Link]
• [Link]
• [Link]
• …

[Link] classe Graphics

Cet objet est l’outil de base dans le développement graphique avec GDI+. Il va nous permettre
d’effectuer les rendus sur des surfaces diverses telles que l’écran, une fenêtre, un composant (Button,
Panel, etc…) ou même une image.
La classe Graphics se situe dans le namespace [Link].
Nous allons donc voir comment obtenir une instance de cet objet.

A partir d’une fenêtre (Form) :

// A l’intérieur d’une méthode d’un formulaire.

Graphics g = [Link]() ;

A partir d’un composant (ici Button) :

// button1 de type Button.

Graphics g = [Link]() ;

A partir d’une image (celle d’une PictureBox) :

/* pictureBox1 de type PictureBox.

La propriété Image renvoie un objet de type Image représentant l’image
affichée dans ce composant.
*/
Graphics g = [Link]([Link]);

La méthode CreateGraphics se charge d’instancier un objet Graphics à partir du composant auquel

elle s’applique.
La méthode statique FromImage, permet d’obtenir un objet Graphics à partir de l’objet Image passé
en paramètre.

La classe Graphics met à votre disposition une batterie de méthodes pour dessiner de nombreuses
formes géométriques, telles que des rectangles, ellipses, polygones, etc… En voici quelques une :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 56 / 80

• DrawRectangle • Dessine un rectangle grâce à un Pen.

• FillRectangle • Dessine et rempli un rectangle grâce à une Brush.
• DrawLine • Dessine une ligne à partir de 2 points.
• DrawEllipse • Dessine une ellipse à partir d’un rectangle dans lequel elle
• FillEllipse sera circonscrite.
• … • Dessiner et rempli une ellipse grâce à une Brush.

Attention : n’oubliez pas d’appeler la méthode Dispose de votre objet Graphics après l’avoir utiliser.
Cette méthode libère notamment les ressources non managées associées à cet objet. N’appelez cette
méthode que lorsque vous avez créé l’objet Graphics.

[Link] objets Brush et Pen

Nous venons de voir comment récupérer une instance de notre classe Graphics. Maintenant, nous
allons l’utiliser pour dessiner des formes géométriques dessus grâce à la classe Pen et aux classes
dérivant de Brush, celle-ci étant en effet une classe abstraite.
Par exemple, SolidBrush et LinearGradientBrush sont deux classes dérivées de Brush.

Pour définir simplement ces deux entités, on peut comparer les objets Brush à un rouleau de peinture
permettant de colorier de larges surfaces, et l’objet Pen à un pinceau utilisé pour effectuer des tracés
plus précis.
Les différents types de Brush et la classe Pen se trouvent dans le namespace [Link].

• Utilisation de la SolidBrush
La classe SolidBrush représente un « rouleau de peinture », pour reprendre cette expression, de
couleur unie.
Voici un des constructeurs de la classe SolidBrush :

SolidBrush sb = new SolidBrush([Link]);

Ce constructeur prends en paramètre une couleur (type Color).

Par exemple, pour dessiner un rectangle rempli en rouge, nous allons créer et utiliser notre SolidBrush
de cette façon :

Rectangle rect = new Rectangle(30, 70, 100, 60);

Graphics g = [Link]();
SolidBrush sb = new SolidBrush([Link]);

[Link](sb, rect);
[Link]();
[Link]();

Résultat :

Figure 46 – Dessiner un rectangle sur un formulaire à l'aide de GDI+

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 57 / 80

Il existe une sélection de SolidBrush prédéfinie disponible à partir de la classe Brushes, il s’agit de
propriétés statiques de cette classe. En voici quelques une :

• [Link]
• [Link]
• [Link]
• …

Tout comme l’objet Graphics, les Brush propose une méthode Dispose permettant de libérer
correctement les ressources associées à cet objet.

• Utilisation du Pen
La classe Pen représente un « pinceau » d’une couleur unie, permettant de dessiner des lignes et les
contours de formes géométriques.
On peut créer un objet Pen de la façon suivante :

Pen p = new Pen([Link], 4f);

Ce constructeur prends en paramètre une couleur (type Color), ainsi qu’une taille de type float
définissant l’épaisseur du tracé.
Voici comment dessiner une ligne sur une surface :

Point p1 = new Point(30, 70);

Point p2 = new Point(130, 130);
Graphics g = [Link]();
Pen p = new Pen([Link], 4f);

[Link](p, p1, p2);

[Link]();
[Link]();

Résultat :

Figure 47 - Dessiner une droite sur un formulaire à l'aide de GDI+

Par analogie avec la classe Brushes, il existe une classe Pens offrant un panel de Pens préféfinis. En
voici quelques un :

• [Link]
• [Link]
• [Link]
• …

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 58 / 80

Comme la plupart des objets de GDI+, la classe Pen possède une méthode Dispose qu’il ne faut pas
oublier d’appeler après tous les traitements.

[Link] Images
Les images en GDI+ .NET sont représentées par la classe Image située dans le namespace
[Link].
Cette classe contient toutes les données d’une image en mémoire. Cette image peut être chargée dans
un objet de type Image à partir d’un fichier, d’un flux ([Link]) ou encore créée
directement dans le code.
Nous allons voir dans un premier temps comment créer notre objet Image, puis comment l’afficher sur
une surface grâce à l’objet Graphics.

6.5.1. Chargement d’un fichier image

La création d’une image à partir d’un fichier est relativement simple. Il existe une méthode statique
dans la classe Image nommée FromFile permettant de charger une image en fournissant son chemin
complet sur le disque.

Exemple :

Image img = [Link](@"c:\[Link]");

Il est possible de créer une image de la sorte à partir d’à peu près n’importe quel format d’image
connu : (JPEG, BMP, GIF, TIFF, PNG, etc…).
La méthode FromFile peut générer une exception si le fichier n’existe pas ou que le format de l’image
n’est pas reconnu.

6.5.2. Création à partir d’un flux

Cette construction est assez pratique quand il s’agit par exemple de récupérer une image dont le
contenu est incorporé dans notre assembly ou bien que cette image se trouve sur un site internet.
Nous allons donc voir comment créer notre image de ces deux façons en utilisant les flux.

• Image incorporée à l’assembly

Une image incorporée à une assembly est une image élément de votre projet dont vous avez défini la
propriété « Action de génération » à « Ressource incorporée ».
Tout d’abord, voici comment récupérer le flux associé à cette ressource :

// Récupère un objet Assembly identifiant notre assembly en cours

d’exécution. Le namespace de la classe Assembly est [Link].
Assembly asm = [Link]();

// Ouvre la resource incorporée et y associe un flux de lecture. La

classe Stream se trouve dans le namespace [Link].
// A noter que le nom de la ressource doit être précédée du namespace
de votre projet (ici MyProject).
Stream strm = [Link]("[Link]");

Maintenant nous allons créer notre image à partir de ce flux grâce à la méthode statique FromStream
de la classe Image :

Image img = [Link](strm);

[Link](); // N’oubliez pas de fermer le flux après avoir récupérer
l’image.

• Image située sur un site Web

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 59 / 80

Pour récupérer une image sur le Web, nous allons utiliser la classe WebClient du namespace
[Link].
Récupération du flux de l’image (ici le logo du laboratoire .NET) :

WebClient wc = new WebClient();

Stream strm = [Link]("[Link]
");

On utilise ensuite la méthode FromStream pour créer notre image.

6.5.3. Création manuelle

Il existe une manière de créer soit même des images, à partir de rien, uniquement dans le code. Pour se
faire, il faut utiliser la classe Bitmap du namespace [Link], qui est une classe dérivée de la
classe Image que nous venons de voir.
En effet, la classe Image ne possède pas de constructeur permettant d’instancier un nouvel objet de ce
type.

Voici comment créer une Bitmap de 100x80 :

Bitmap bmp = new Bitmap(100, 80);

Notre image une fois créée ne contient rien. Il va falloir lui ajouter du contenu.
Pour cela nous allons récupérer l’objet Graphics de notre image, grâce à la méthode statique
FromImage de la classe Graphics.

// bmp est de type Bitmap et Image car Bitmap hérite de Image.

Graphics gBmp = [Link](bmp);
// La méthode Clear effectue un effacement de la zone graphique à
l’aide d’une couleur.
[Link]([Link]);
[Link]([Link], 0, 0, 100, 80);
[Link]();

Il est donc possible de dessiner n’importe quoi sur notre image via son objet Graphics.

6.5.4. Affichage
Maintenant que nous savons comment créer nos images en mémoire, il va être interessant de savoir
comment les afficher à l’écran sur nos surfaces de dessin.
Nous avons donc toujours besoin d’un objet Graphics, qui va nous servir à effectuer le dessin de
l’image. Ensuite, il faudra appeler la méthode DrawImage de cet objet afin d’afficher le contenu de
l’image sur la surface gérée par l’objet Graphics.

Exemple :

Graphics g = [Link]();
// On utilisera l’objet bmp de type Bitmap comme image à afficher.
[Link](bmp, 30f, 70f);

[Link]();
[Link]();

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 60 / 80

Résultat:

Figure 48 - Dessiner une image sur un formulaire à l'aide de GDI+

[Link] du texte
L’affichage d’un texte sur une surface n’est bien sûr pas fait pour remplacer le control Label, mais afin
de pouvoir réaliser des effets graphiques sur ce texte.
Pour l’affichage du texte nous aurons besoin d’un objet de type Font définissant la police et la taille à
utiliser pour dessiner le texte.
Cet objet Font se construit ainsi :

// Crée un nouvel objet Font de police Arial, de taille 10 en

gras/italique.
Font ft = new Font("Arial", 10f, [Link] | [Link]);

L’affichage de texte se fait via la méthode DrawString de l’objet Graphics que vous aurez créé.
En voici un exemple :

Graphics g = [Link]();
string message = "Hello world !";

[Link](message, ft, [Link], 3f, 70f);

[Link]();
[Link]();

Comme vous pouvez le constater encore une fois, la classe Font propose également une méthode
Dispose pour effectuer la libération des ressources associées à cet objet.

Résultat :

Figure 49 - Ecrire sur un formulaire à l'aide GDI+

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 61 / 80

[Link] concrets
Voici quelques réalisations dont un issu d’un article du laboratoire .NET qui ont été codées en GDI+
.NET :

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 62 / 80

7. Impression
L’impression à partir d’une application Windows repose sur trois contrôles :
• PrintDocument : Représente le document à imprimer.
• PrintPreviewDialog : Représente la boite de dialogue d’aperçu avant impression.
• PreviewDialog : Représente la boite de dialogue de configuration de l’impression.

7.1. L’objet PrintDocument

Ce contrôle représente le document à imprimer. La propriété DefaultPageSettings vous permettra de
configurer les principaux paramètres de votre document.
Cette propriété contient elle même des propriétés telles que Margins qui vous permettra d’initialiser
les marges de votre document, ou Landscape qui vous permettra d’opter pour une impression en mode
paysage ou non.
L’exemple précédent montre un objet PrintDocument avec une marge de 50 pixels en haut, à droite et
à gauche. L’impression ne sera pas faite en mode paysage.

private void printForm_Load(object sender, [Link] e)

{
PrintDocument myDocument = new PrintDocument();

[Link] = 50;
[Link] = 50;
[Link] = 50;

[Link] = false;
}

L’objet PrintDocument possède une méthode Print qui va permettre de lancer l’impression. Cette
méthode va déclencher l’événement PrintPage qui devra contenir le code permettant l’impression.

private void printForm_Load(object sender, [Link] e)

{
PrintDocument myDocument = new PrintDocument();

[Link]+=
new PrintPageEventHandler(myDocument_PrintPage);
}

private void myDocument _PrintPage(object sender,

PrintPageEventArgs e)
{
//Code permettant d’imprimer le document
}

Dans le concepteur de Form, vous arriverez au même résultat en ajoutant un control PrintDocument à
votre formulaire et en double cliquant dessus.

Pour déclencher l’événement PrintPage, il suffira d’appeler la méthode Print de l’objet

PrintDocument :

[Link]();

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 63 / 80

Comme nous l’avons dit précédemment, c’est vous qui allez écrire le code pour imprimer votre
document.
Il va vous falloir passer par GDI+ : La méthode déclenchée par l’événement PrintPage va vous
transmettre en argument un objet PrintPageEventArgs. Celui-ci vous donnera accès à un objet
Graphics qui vous permettra donc de mettre vos données en forme.

L’exemple suivant va vous permettre d’imprimer la chaîne de caractère « Impression avec .Net » sur
une page :

private void myDocument_PrintPage(object sender,

PrintPageEventArgs e)
{
//Style et police avec lesquels on va écrire
Font myFont = new Font("Arial",10);
//Point de départ horizontal : On commence à la marge
int abscisse = [Link];
//Point de départ vertical
int ordonnee = [Link];
//Choix de la couleur
Brush printColor = [Link] ;
//Ecriture
[Link]("Impression avec .Net",myFont,
printColor,abscisse,ordonnee);
[Link] = false;
}

L’impression se voit donc régie par les lois de GDI+, pour écrire une ligne, il vous faudra utiliser la
méthode DrawString d’un objet graphique.

Ici, on définit un objet Font avec un style Arial et une police de 10.

On initialise le point de départ de la ligne avec les valeurs des marges que l’on avait initialiser
précédemment à travers la propriété DefaultSettings de l’objet PrintDocument(l’objet
PrintPageEventArgs nous permet en effet de récupérer ces données).
Enfin, on initialise la couleur d’impression à l’aide de l’objet printColor.

Il suffit ensuite d’appeler la méthode DrawString en lui passant tous ces arguments et votre document
sera imprimé avec la chaîne de caractères « Impression avec .Net ».

La propriété HasMorePages permet de renseigner le module d’impression à savoir s’il reste des
choses à imprimer. Si vous passer cette propriété à true, l’évènement lié à PrintPage sera de nouveau
déclenché sur une nouvelle page.
Par défaut cette propriété est à false, ce qui signifie que vous n’êtes pas obligés de la définir comme
ci-dessus.

7.2. Aperçu avant impression

L’aperçu avant impression fait à l’aide du contrôle PrintPreviewDialog. Ce contrôle représente une
boite de dialogue modale et possède une propriété Document qui nous permettra de la rattacher à
l’objet PrintDocument que l’on voudra visualiser.
Ainsi, il vous suffira d’afficher la boite de dialogue, et vous aurez un aperçu du document
correspondant à la propriété Document de l’objet.

private void printViewerButton_Click(object sender,

[Link] e)
{
[Link] = myDocument;

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 64 / 80

[Link]();
}

Pour générer l’aperçu, le control PrintPreviewDialog, simuler l’impression via l’évènement lié à
PrintPage.
Si vous décidez d’imprimer le document, il vous suffira de cliquer sur l’icône d’impression située en
haut à gauche de la boite de dialogue, ce qui provoquera l’appel de la méthode Print de l’objet
PrintDocument rattaché au control PrintPreviewDialog.

7.3. Sélection de l’imprimante

Après avoir vu comment imprimer un document et comment afficher un aperçu avant impression à
l’utilisateur, nous allons maintenant voir comment lui présenter la boite de dialogue permettant de
configurer le média d’impression, ainsi que le document à imprimer en lui même.

C’est le control PrintDialog qui va vous permettre d’afficher cette boite de dialogue. Pour cela, rien de
très original, il suffira de rattacher un objet PrintDocument au contrôle PrintDialog, puis de lancer la
boite à l’aide de la méthode ShowDialog.
Les modifications effectuées par l’utilisateur seront automatiquement prises en compte.

L’exemple suivant montre comment afficher cette boite de dialogue, puis comment lancer
l’impression si l’utilisateur valide la boite.

private void printButton_Click(object sender, EventArgs e)

{
[Link] = myDocument;
//Si l’utilisateur valide la boite de dialogue
if([Link]() == [Link])
{
//On lance l’impression
[Link]();
}
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 65 / 80

8. Génération
Une fois votre application créée vous allez pouvoir générer un fichier exécutable. Pour cela, allez
dans Générer >> Générer en tâche de fond…
Une fenêtre va alors s’ouvrir, vous permettant de configurer votre génération :

Figure 50 - Boite de dialogue "Générer en tâche de fond"

Pour générer votre exécutable final, cochez la case Release, (comme le montre l’image), cliquer
ensuite sur Générer, un fichier exécutable va alors être créé dans le répertoire Release du
répertoire Bin qui se situ lui-même à la racine du répertoire de votre solution.

Vous pouvez également générer votre solution à la ligne de commande. Pour cela, ouvrez l’invite
de commande de Visual Studio .Net 2003 :

Démarrer >> Programmes >> Microsoft Visual Studio .Net 2003 >> Outils Visual Studio
.Net 2003 >> Visual Studio .Net 2003 Command Prompt

Il s’agit d’une invite de commande, comme celui du Dos, mais qui contient des variables
d’environnements utiles à l’utilisation de Visual Studio .Net 2003.

Placez-vous ensuite dans le répertoire de votre solution. Utilisez cd pour vous déplacez, comme
dans l’invite de commande CMD. Une fois dans ce répertoire, tapez la ligne de commande
suivante :

csc [Link]

Il faut absolument spécifier le fichier comportant le point d’entrée principale (la méthode
Main).Ensuite, il faut spécifier tous les fichiers de codes utilisés dans l’application.
Par exemple, dans notre cas, nous n’utilisons pas le formulaire Form2, mais uniquement le
formulaire Form1. Nous pourrions donc générer notre exécutable en spécifiant uniquement le
fichier [Link].

Si on utilisait le second formulaire, alors il aurait fallu le compiler également :

csc [Link] [Link]

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 66 / 80

Par défaut, le fichier exécutable généré prend le nom du fichier comportant le point d’entrée
principal lorsque l’on génère à la ligne de commande, et il prend le nom du Namespace lorsque
l’on passe par le designer.
Dans notre cas, lorsque nous générons notre application, le fichier créé se nommera [Link]
lorsque l’on passe par l’invite de commande, et Premier_Projet.exe lorsque l’on passe par le
designer.
On peut modifier cela.

Ouvrez la fenêtre des propriétés du projet : Click doit sur le projet dans l’explorateur de
solutions, puis Propriétés.

Figure 51 - Modification du nom de l'assembly généré par le projet

Remplacez le champ en face de Nom de l’assembly par le nom de votre choix.

A l’aide de l’invite de commande de Visual Studio .Net 2003 :

Il vous faudra utiliser l’option OUT comme dans l’exemple ci-dessous :

csc /OUT:[Link] [Link] [Link]

Bien sûr, si vous utilisez un espace dans votre nom, une erreur sera générée car le nom sera
interprété comme deux argument différents: le premier comme argument de l’option OUT, et le
second comme un fichier à compiler qu’il ne trouvera pas.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 67 / 80

9. Déploiement
9.1. Présentation
Pour déployer une Application Windows, il existe deux moyens :
• Copier le fichier exécutable sur le(s) poste(s) client(s).
• Créer un projet de déploiement.

La première méthode est la plus simple : il suffit de copier le fichier exécutable sur le poste cible, et de
renouveler l’opération autant de fois qu’il y a de postes de cibles.

Cette solution présente deux inconvénients. Tout d’abord, il convient de remarquer que cette méthode
est lourde dès que le nombre de poste client devient important. Ensuite, avec cette méthode, vous ne
pouvez exécuter d’opération durant l’installation. Imaginez que vous devez créer une clé registre
indispensable au bon fonctionnement de l’application : il vous faudra copier le fichier, puis, créer la
clé à la main voir, au mieux, à l’aide d’un script. Il faudra donc à chaque fois copier le fichier, puis
lancer le script ou créer directement la clé.

La seconde méthode va ainsi vous faciliter la vie dans le sens, où elle va vous permettre de déployer
votre application de manière totalement automatisée. Il suffira de mettre le projet de déploiement à
disposition des utilisateurs, sur l’intranet de l’entreprise par exemple (projet de déploiement =
Setup), puis les utilisateurs pourront directement récupérer le fichier.
L’installation étant totalement automatisée, l’utilisateur peut procéder directement à l’installation
puisqu’il est entièrement assisté par Windows Installer.

9.2. Projet de déploiement

Il s’agit d’un type de projet, tout comme un projet d’application Windows, et qui va vous permettre de
déployer vos applications et autres. Celui ci est basé sur Windows Installer qui pourra être configuré
selon vos besoins, tant au niveau de l’interface (des fenêtres présentées à l’utilisateur) qu’au niveau
des actions effectuées lors de l’installation.
Le résultat sera un fichier [Link], portable (sur Windows uniquement) et simple d’utilisation.

9.2.1. Création
Pour créer un projet de déploiement, dans l’explorateur de solutions, faites un clicque droit sur la
solution, puis Ajouter >> Nouveau Projet…
La fenêtre de création de projet va alors s’affichée. Sélectionner Projets de déploiement et de
configuration, puis Projet de configuration.
Comme lors de la création du projet d’application Windows, il vous faudra spécifier un nom à votre
projet de déploiement.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 68 / 80

Figure 52 - Ajout d'un projet de déploiement à une solution

Un répertoire portant ce nom sera alors créé. Voyons ce qu’il contient :

• Un répertoire Bin vide
• Un répertoire Debug vide

Notre projet de déploiement est encore vide, et il va falloir le configurer avant de pouvoir déployer
notre application.
Intéressons nous tout d’abord aux propriétés de ce projet :
• Author : Il s’agit de l’auteur de l’application, c’est le nom qui sera affiché dans la fenêtre
d’ajout/suppression des programmes de windows.
• Description : Vous pourrez ajouter ici une description de votre application. Elle figurera
également dans la fenêtre d’ajout/suppression des programmes de Windows.
• DetectNewerInstal : Force le programme à vérifier l’existence d’une version plus récente de
l’application. Si une version plus récente est détectée, l’installation échoue. Pour passer à
travers cette vérification, il suffit de mettre cette propriété à false.
• Manufacturer : Nom du fabriquant. Ce nom servira à nommer le répertoire qui contiendra
l’application (par défaut), et sera également affiché dans la fenêtre d’ajout/suppression des
programmes Windows.
• ProductName : Il s’agit du nom de votre application. Comme pour les propriétés précédentes,
c’est ce nom qui sera listé au sein de Windows.
• UpgradeCode : Il s’agit d’un code qui est partagé entre les différentes versions d’une
application. Ce code nous permet alors de savoir si une version de l’application existe déjà sur
l’ordinateur cible. Il sera utilisé par Windows.
• ProductCode : Il s’agit d’un code qui, cette fois, identifie une application de manière unique.
En combinant la propriété UpgradeCode et ProductCode, Windows pourra ainsi détecter les
différentes versions d’une même application (UpgradeCode similaire mais ProductCode
différent), mais également distinguer d’entre les différentes applications (UpgradeCode et
ProductCode différents).
Par exemple, en mettant la propriété DetectNewerVersion à true, Windows va rechercher une
application possédant le même UpgradeCode que celle à installer, mais avec un ProductCode
différents. Il pourra ensuite évaluer si l’application trouvée est plus récente ou non que celle
qu’il doit installer.
• RemovePreviousVersion : Cette propriété va forcer Windows Installer à vérifier si une
version de l’application est déjà présente sur l’ordinateur cible. Mise à true, cette propriété va
forcer la désinstallation d’une éventuelle version déjà présente sur l’ordinateur avant
d’installer la nouvelle version. A false, aucune vérification n’est effectuée.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 69 / 80

• SupportPhone : Il s’agit du numéro de téléphone du manufacturier de l’application. Cette

information sera également visible dans la fenêtre d’ajout/suppression des programmes de
windows.

Les diverses fonctionnalités disponibles sont paramétrables à partir de fenêtres spécifiques.

Le menu présentant ces fenêtres est disponible en haut de l’explorateur de solution dès lors que le
projet de déploiement est sélectionné (menu encadré en rouge sur l’image ci-dessous).

Figure 53 - Menus du projet de déploiement

La première icône en partant de la gauche permet d’accéder à la fenêtre Editeur du système de

fichier. Cette dernière permet de sélectionner la sortie de votre projet : C’est ici que l’on paramètre ce
qui sera déployé sur l’ordinateur client. Vous pourrez également choisir les répertoires vers lesquels
les fichiers déployés seront envoyés.

Par défaut, cette fenêtre est composée de trois répertoires :

• Bureau de l’utilisateur : Il s’agit du répertoire représentant le bureau de l’ordinateur cible.
Par exemple, c’est dans ce répertoire qu’il faudra placer le raccourci pour votre application.
• Dossier d’application : Il s’agit du répertoire qui contiendra votre application. Par défaut ce
répertoire se situe dans Program Files, dans un répertoire portant le nom de l’application, lui-
même contenu dans un répertoire portant le nom du manufacturier.
Si l’on résume, l’arborescence sera la suivante :
C:\Program Files\Manufacturier\Nom_Application
Toutes les ressources nécessaires à l’application (documentation, fichier de configuration…)
pourront également être déployées dans ce répertoire.
• Menu Programmes de l’utilisateur : Il s’agit du menu programme situé dans le menu
démarrer de l’utilisateur.

Ces répertoires sont disponibles par défaut, mais vous pouvez en ajouter d’autres selon vos besoins.
Pour cela, clique droit sur Système de fichier de l’ordinateur cible, puis il suffit de sélectionner
Ajouter un dossier spécial. Une liste va alors s’afficher et vous n’avez plus qu’à choisir.

Figure 54 – Editeur du système de fichier

Voyons maintenant comment paramétrer la sortie de notre projet d’application Windows (ce qui sera
déployé sur l’ordinateur cible).

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 70 / 80

Commençons par l’application. Elle est considérée comme la sortie principale de notre projet de
déploiement. Aussi, pour la déployer, il suffit de faire un clique droit sur le dossier vers lequel elle
sera copiée (généralement le dossier d’application dans Program Files), puis : Ajouter >> Sortie du
projet…

Une boite de dialogue va alors s’afficher et il vous faudra alors choisir le type de fichier à déployer.

Figure 55 - Création d'une sortie de projet

Voici la description des principaux types de sorties disponibles :

• Fichier de documentation : Il s’agit de fichiers de documentation au format XML.
• Sortie principale : Il s’agit de tout ce qui sera généré par votre projet d’application Windows.
Pour un projet simple, il s’agira uniquement du fichier exécutable. Si vous ajoutez un fichier
de configuration par exemple, celui ci sera automatiquement ajouté à la sortie principale.
• Ressources localisées : Il s’agit de données non exécutables qui peuvent être présentées sous
plusieurs formes (chaînes de caractères, image…) et qui sont déployées logiquement avec une
application.
• Sources Files : Il s’agit des fichiers sources de l’application. Utile dans le cas d’une
application open source par exemple.

Nous voulons ici déployer uniquement l’application, et comme nous l’avons dit précédemment, il
s’agit de la sortie principale du projet. Sélectionnez donc cette option, puis cliquez sur ok.

La sortie du projet apparaît alors dans le dossier d’application (car c’est celui-ci que nous avons
sélectionné).
Votre projet est désormais prêt, et il ne manque plus qu’à le générer. Pour cela, ouvrez la fenêtre de
génération de tâche de fond (Générer >> Générer en tâche de fond…), puis cochez la génération en
release pour le projet d’application Windows ainsi que pour le projet de déploiement.

Ce dernier va en fait aller récupérer le résultat de la génération du projet de l’application pour en faire
un Stups (souvenez vous, nous avions choisi sortie principale).

9.3. Action personnalisée

Voyons maintenant comment effectuer une action durant l’installation de l’application. C’est ce que
l’on appel Action personnalisée. Pour notre exemple, nous allons créer une clé dans le registre à
l’installation.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 71 / 80

Pour cela, il va tout d’abord falloir modifier l’interface graphique de Windows Installer.

9.3.1. Interface graphique

Pour accéder au menu de configuration de l’interface graphique, cliquer sur qui l’icône
se trouve dans le menu du projet de déploiement (apparaissant en haut de l’explorateur de solutions
lorsque vous avez sélectionné le projet de configuration).

Vous arrivez alors sur un écran qui vous liste la totalité des fenêtres qui s’afficheront par défaut.
A noter que cette fenêtre est séparée en deux parties :
• Installer : C’est cette installation et donc ces fenêtres qui seront lancées lorsque vous n’êtes
pas Administrateur de votre machine.
• Installation d’administration : Cette installation sera lancée lorsque vous êtes
l’administrateur de la machine.

Figure 56 - Interface graphique de Windows Installer

Nous allons configurer uniquement la première partie, le mode de fonctionnement étant le même pour
les deux.

9.3.2. Ajouter une fenêtre

Le processus d’installation a été découpé en trois étapes :
• le début de l’installation : Phase pendant laquelle on va récupérer les informations de la part
de l’utilisateur. Au minimum, il faudra récupérer le chemin du répertoire d’installation.
• Progression : Phase durant laquelle Windows installer va procéder au déploiement de
l’application. Au minimum, cette étape comprendra la copie des fichiers vers le répertoire
cible sur la machine. C’est durant cette phase que s’effectuera une éventuelle action
personnalisée.
• Fin : Signale la fin de l’installation.

Pour ajouter une fenêtre qui devra apparaître au début de l’installation, faites un clique droit sur
Début. Sélectionnez ensuite Ajouter une boite de dialogue.

Vous arrivez alors sur l’écran de sélection des boites de dialogues, sachant que les boites que vous
pouvez ajouter sont prédéfinies, que vous ne pouvez ajouter qu’un nombre limité de boites, et
enfin qu’une boite ne peut être utilisée qu’une seule fois (on ne peut pas ajouter deux fois la même
boite).

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 72 / 80

Figure 57 - Ajout d'une fenêtre à l'interface graphique de Windows Installer

Nous choisissons d’ajouter une fenêtre de Zones de texte : Il s’agit d’une fenêtre pouvant présenter à
l’utilisateur jusqu’à quatre zone de texte.

Remarquez qu’il existe trois boites de dialogues nommées Zones de texte. Rappelez-vous, que vous
ne pouvez ajouter une boite qu’une seule fois, et donc si vous avez besoin de plus de quatre zones de
texte, il vous faudra ajouter une seconde boite (voir la troisième).

Par défaut, la nouvelle boite installée est placée de manière à apparaître à la fin de l’étape choisie. Or,
dans notre cas par exemple, aucune boite ne doit apparaître après la fenêtre Confirmer l’installation.
Il va donc falloir déplacer notre nouvelle boite. Pour cela, clique droit sur la boite à déplacer, puis
choisissez Monter. Faites en de même jusqu’à ce que la boite apparaisse en deuxième position (juste
après la boite Bienvenue).

9.3.3. Paramétrer une fenêtre

• BannerBitmap : Il s’agit de l’image qui s’affichera en haut de la fenêtre.
• BannerText : Il s’agit du texte qui s’affichera à coté de l’image.
• BodyText : Il s’agit du texte qui s’affichera dans le corps de la fenêtre.

On constate ensuite un groupe de propriété qui se répète 4 fois de suite. C’est ce groupe de propriété
qui permet de paramétrer une zones de texte, et étant donnée que l’on à le droit à 4 zones au
maximum, le groupe se répète 4 fois de suite.
• Edit1Label : C’est le texte qui va précéder votre zone de texte.
• Edit1Property : Il s’agit du nom (ou plutôt de l’index) de votre zone de texte. Celui ci
permettra de récupérer la valeur du champ (comme pour un formulaire Web).
• Edit1Value : Valeur par défaut qui sera affichée dans la zone de texte.
• Edit1Visible : Permet d’afficher ou non la zone de texte.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 73 / 80

Figure 58 - Fenêtre de zone de texte ajoutée à Windows Installer

9.3.4. Récupérer une donnée entrée par l’utilisateur

Avant toute chose, il va falloir ajouter un fichier d’installation mieux connu sous le nom de Classe
Installer. Ce fichier fait partie de la catégorie Code, pour l’ajouter, suivez la procédure d’ajout de
fichier classique. Bien sûr, ce fichier doit être ajouté au projet d’application Windows et non au
projet de configuration.
Ce fichier comportera une classe héritée de [Link]. C’est donc cette
nouvelle classe qui sera appelée durant l’installation et c’est elle qui devra comporter le code à
exécuter durant l’installation.

using System;
using [Link];
using [Link];
using [Link];

namespace Premier_Projet
{

[RunInstaller(true)]
public class myInstaller : Installer
{

private [Link] components = null;

public Installer()
{
// Cet appel est requis par le concepteur.
InitializeComponent();

// TODO : ajoutez les initialisations après

//l'appel à InitializeComponent
}

protected override void Dispose( bool disposing )

{
if( disposing )
{
if(components != null)

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 74 / 80

{
[Link]();
}
}
[Link]( disposing );
}

#region Code généré par le Concepteur de composants

private void InitializeComponent()

{
components = new
[Link]();
}
#endregion
}
}

Par défaut, cette classe est incluse dans le namespace du projet (ici Premier_Projet) et comporte les
directives Using nécessaires à son bon fonctionnement. Elle comporte également un constructeur, un
destructeur et une méthode d’initialisation (InitializeComponent) par défaut.

Remarquez la présence de l’attribut RunInstaller précédent la déclaration de la classe. En passant true

à cet attribut, l’action personnalisée sera prise en compte et effectuée durant l’installation. En prenant
false comme argument, l’action personnalisée sera ignorée durant l’installation.
La classe nommée Installer, faisant partie du namespace [Link], fournit la
base pour toutes les installations personnalisées.

Une fois ce fichier ajouté, ajoutez à la classe qu’il contient la méthode suivante :

public override void Install(IDictionary stateSaver)

{
}

C’est cette méthode qui sera appelée durant l’installation et c’est donc au sein de celle-ci que devra
figurer le code implémentant la tâche spécifique qui devra être exécutée durant l’installation.

Remarquer au passage le descripteur override. En effet, la méthode Install est déjà définie dans la
classe mère ([Link]) et l’utilisation de ce mot clé va permettre de
redéfinir cette méthode.

Cette classe contient une propriété nommée Parameters appartenant à la classe dont elle hérite et qui
est en fait un dictionnaire de tous les paramètres entrés par l’utilisateur lors de l’installation.
Les noms des zones de texte par lesquels ces paramètres ont été entrés, vont servir de clé au sein du
dictionnaire.
Ainsi, pour obtenir la valeur du champ nommé Text1 il faudra faire :

String maValeur = [Link]["Text1"];

Voyons maintenant un exemple avec l’ajout d’une clé au registre durant l’installation.
Voici tout d’abord une fonction permettant d’ajouter une clé au registre :

//Créé une nouvelle clé dans le registre à l'emplacement

//spécifié par Chemin et lui affecte la valeur Value
private void InitialiseCle(string Value, string Chemin)
{

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 75 / 80

//Création de la clé
[Link] MaCle =
[Link](Chemin);

//Initialisation de la valeur de la clé

[Link]("Port",Value);
}

Il nous suffit simplement d’appeler cette fonction dans la méthode Install de notre classe Installer afin
qu’elle soit exécutée. Bien sûr, il faudra au préalable avoir récupérer les deux paramètres entrés par
l’utilisateur.
En supposant que ceux-ci se nomment valeurCle et cheminCle, voici à quoi devrait ressembler notre
classe au final :

using System;
using [Link];
using [Link];
using [Link];

namespace Premier_Projet
{
[RunInstaller(true)]
public class myInstaller : Installer
{
private [Link] components = null;

public myInstaller()
{
// Cet appel est requis par le concepteur.
InitializeComponent();

// TODO : ajoutez les initialisations après

//l'appel à InitializeComponent
}

protected override void Dispose( bool disposing )

{
if( disposing )
{
if(components != null)
{
[Link]();
}
}
[Link]( disposing );
}

#region Code généré par le Concepteur de composants

private void InitializeComponent()

{
components = new
[Link]();
}

#endregion

#region Code ajouté pour l’exemple, en plus du code présent par défaut

public override void Install(IDictionary stateSaver)

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 76 / 80

{
String vCle = [Link]["valeurCle"];
String cCle = [Link]["cheminCle"];

InitialiseCle(vCle, cCle);
}

private void InitialiseCle(string Value, string Chemin)

{
[Link] MaCle =
[Link](Chemin);

[Link]("Port",Value);
}

#endregion

}
}

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 77 / 80

10. Fichier de configurations

10.1. Présentation
Comme son nom l’indique, un fichier de configuration va permettre de spécifier des paramètres
concernant le fonctionnement de l’application. Ces paramètres de configurations pourront soit être des
données propres à votre application, soit des spécifications concernant l’exécution de l’application.

En effet, les applications Windows étant compilées à la volée durant l’exécution, on pourra modifier
des paramètres concernant l’application sans avoir à la recompiler.

Imaginez que votre application soit conçue pour fonctionner avec la version 1.0 d’un assemblage
installé dans le GAC. Vous installez la version 1.2 de cet assemblage (toujours dans le GAC) et vous
voulez que votre application fonctionne avec cette nouvelle version. Vous allez pouvoir spécifier cela
dans le fichier de configuration.

Le fichier de configuration est un fichier au format XML. Pour être pris en compte, il doit :
• Avoir un nom de la forme Nom_Application.Config
• Etre installé dans le répertoire courant de l’application.

Par exemple si vous avez une application [Link]. Votre fichier de configuration devra
alors se nommé [Link] et se situé dans le même répertoire que votre application.

Pour disposer d’un fichier de configuration, vous pouvez soit :

• L’éditer avec n’importe quel éditeur de texte (il s’agit d’un fichier XML) et le déployer dans
le répertoire de l’application par un simple copier/coller.
• L’ajouter au projet en vue de le déployer directement avec l’application.

Pour ajouter un fichier de configuration à un projet, il suffit de suivre la procédure d’ajout de fichier à
un projet décrite au chapitre 2.1.
Les fichiers de configurations font parti de la catégorie Utilitaire.

Figure 59 - Ajout d'un fichier de configuration à un projet d'application Windows

Voyons à quoi ressemble un fichier de configuration :

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 78 / 80

</configuration>

On remarque tout d’abord les informations concernant le fichier XML (propre à tous les fichiers
XML), suivi du nœud configuration.

Il s’agit du nœud parent. Pour que des paramètres de configurations soient pris en compte, ils doivent
impérativement se situer entre ces deux nœuds.

Autrement dit, tout ce que vous ajouterez à ce fichier devra se trouver entre la balise
<configuration> et la balise </configuration>.

10.2. Utilisation
10.2.1. Données propres à votre application
Nous avons vu que le fichier de configuration permettait de spécifier soit des données propres à votre
application, soit des données propres à l’exécution de votre application. Voyons dans un premier
temps comment spécifier des données propres à votre application. Pour cela, il va vous falloir ajouter
un nœud <appSettings>.

Vous allez pouvoir spécifier dans ce nœud toutes les données propres à votre application, elles seront
indexées à l’aide d’un identifiant (clé), et pourront facilement être récupérer dans le code.

Imaginez que vous développiez une application devant écouter un port. En fonction des firewall de
chaque machines, de la politique de sécurité de chaque Entreprise, le port d’écoute ne sera pas le
même. Plutôt que de devoir convaincre la direction des systèmes d’information d’ouvrir le port
nécessité, il sera plus simple d’avoir juste à modifier ce port en fonction de ceux ouverts sur la
machine cliente.

Pour cela, il vous suffira d’ajouter dans votre nœud <appSettings> un nœud <add/> qui lui vous
permettra de spécifier vos données.

<appSettings>
<add key="Application Port" value="9000" />
</appSettings>

Ce nœud <add/> est composé de deux attributs, une clé (l’identifiant) et une valeur correspondant à
cette clé. Il peut être répété autant de fois que nécessaire dans la balise appSettings afin de définir
toutes vos constantes d’application. Voyons maintenant comment accéder à ces paramètres dans le
code.

Pour cela, il va falloir utiliser la classe ConfigurationSettings située dans le namespace

[Link] car c’est elle qui donne accès aux paramètres d’une section spécifiée du
fichier de configuration.
C’est la propriété AppSettings qui comme son nom l’indique va donner accès aux paramètres de la
section <appSettings> .

Voici la ligne de code permettant de récupérer la valeur de notre paramètre « Application Port » :

string appPort = [Link]["Application Port"];

Ainsi, avec une simple ligne de code on va pouvoir récupérer des données pour notre application.
Avec une application classique, il aurait fallut passer par la base de registre.

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 79 / 80

En plus du code que cela suscite (lecture de la base de registre), ce système était limité dans la mesure
où il était propre à une machine et donc pas facilement portable (à moins de recréer la clé sur la
nouvelle machine).
Avec un fichier de configuration, comme nous l’avons dit précédemment, il suffira de copier le fichier
dans le répertoire courant de l’application pour que celui-ci soit pris en compte.

10.2.2. Paramètres concernant l’exécution de votre application

Vous pourrez donc spécifier des données propres à votre application dans un fichier de configuration,
certes. Il faut savoir que vous pourrez également spécifier des paramètres concernant l’exécution de
votre application.

Pour reprendre l’exemple évoqué plus haut, une application conçue pour fonctionner avec un
assemblage ayant un nom fort continuera d’utiliser celui-ci même si une nouvelle version de
l’assemblage est disponible.
Pour pallier à ce problème, il va falloir utiliser le fichier de configuration. Il existe en effet des
paramètres de configuration permettant de spécifier cela.

Tout ce qui concerne les liaisons d’assemblages et les spécifications quant au Garbage Collector doit
être spécifié dans une section Runtime délimitée par les balises <runtime> et </runtime>.

Ensuite, tout ce qui va toucher à la redirection et à l’emplacement d’assemblages au sein de cette

section devra se trouver dans une sous section délimitée par les balises <assemblyBinding> et
</assemblyBinding>.

Cette balise requiert obligatoirement l’attribut xmlns qui permettra de spécifier l’espace de nom XML
nécessaire pour les liaisons d’assemblages.

Passons maintenant à la section délimitée par les balises <dependentAssembly> et

</dependentAssembly>.Cette section va permettre d’encapsuler les informations concernant un
assemblage. Une telle section est propre à un et un seul assemblage. Cette section pourra donc se
répétée en cas de besoin.

Chaque élément <dependentAssembly> doit avoir un enfant <assemblyIdentity>. Cet

élément va permettre d’identifier l’assemblage actuellement utilisé par l’application. Pour ce faire, cet
élément est composé de 3 attributs :
• name : Il s’agit du nom de l’assemblage.
• publicKeyToken : Il s’agit du nom fort de l’assemblage, qui est spécifié au format
hexadécimal.
• culture : Culture prise en charge par l’assemblage (langue et pays).

Une fois les informations permettant d’identifier l’assemblage actuellement utilisé, il va falloir
spécifier les informations concernant le nouvel assemblage vers lequel devra se faire la redirection.

Pour cela, il faudra utiliser l’élément <bindingRedirect>. Cet élément se compose des attributs
suivants :
• oldVersion : Il s’agit tout simplement de l’ancienne version de l’assemblage.
• newVersion : Il s’agit de la nouvelle version de l’assemblage.

Seuls ces deux informations seront nécessaires car le nouvel assemblage partagera le même nom, le
même nom fort que le précédent mais aura un numéro de version différent.

<?xml version="1.0" encoding="utf-8" ?>

<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Windows Application 80 / 80

<dependentAssembly>
<assemblyIdentity name="myAssembly"
publicKeyToken="32ab4ba45e0a69a1"
culture="neutral" />
<bindingRedirect oldVersion="[Link]"
newVersion="[Link]"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

[Link]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs