EFREI Microsoft

Développement .NET : 2/3

WinForms & évènements

8 décembre 2008
 Développement .NET : 2/3

Sommaire

Introduction .................................................................................................................. 3
Votre premier programme WinForm ............................................................................. 4
Création de votre projet ................................................................................................................ 4
Projet Application Console vs Applicaiton Windows ...................................................................... 5
Projet Application Console ........................................................................................................ 5
Projet Application Windows ...................................................................................................... 5
Importation des classes métiers de l’atelier 1 ............................................................................... 6
Le designer de Visual Studio .......................................................................................................... 6
Les classes partielles (optionnel) ................................................................................................... 7
C’est parti : réalisation de notre programme.................................................................. 9
Votre premier contrôle .................................................................................................................. 9
Le traditionnel menu déroulant ..................................................................................................... 9
Les évènements en théorie (optionnel) ........................................................................................ 10
Liste de données .......................................................................................................................... 10
Tableau de données .................................................................................................................... 12
Pour aller plus loin (Optionnel) .................................................................................................... 13
Conclusion ................................................................................................................... 14
Liens et Ressources ...................................................................................................... 15

Ce document est le TP proposé lors de la formation “Développement .NET : WinForms et

évènements ». Cette formation est la deuxième d’une série de trois consacrées au
développement .NET.

2
 Développement .NET : 2/3

Introduction
Dans cet atelier, nous vous proposons de continuer l’application de gestion de commandes d’une
entreprise en négoce commencée dans l’atelier 1. Cette fois, nous allons donner un peu plus de style
à notre interface, en passant du traditionnel mode console à la fenêtre Windows évoluée. A nous les
tableaux, boutons et autres gestion de souris !

En plus des bases des applications WinForms, cet atelier vous permettra de vous familiariser avec
les notions d’évènements, indispensables lorsque nous créons un programme dans un langage de
haut niveau.

Cet atelier est divisé en 3 parties :

- Création d’un programme WinForm

- Vos premiers contrôles
- C’est parti ! Evénements et DataBinding

Tout au long de ce TP, vous trouverez différentes astuces de Visual Studio, qui apporte aux
développeurs .NET une aide précieuse ce qui en fait un élément prépondérant dans « l’écosystème
.NET ».

3
 Développement .NET : 2/3

Votre premier programme WinForm

La semaine dernière, nous vous avons indiqué que le Framework .NET était constitué de deux
éléments principaux : la CLR, Common Langage Runtime, machine virtuelle (comme la machine
virtuelle Java) qui gère l’exécution de votre programme en gérant notamment la mémoire ; et la BCL,
Base Classe Library. Il n’y a donc pas de secret, les WinForm (abréviation de Windows Form) font
parties de la BCL.

En réalité, il s’agit simplement d’un ensemble de classes de la BCL permettant d’interagir avec les
éléments d’interface natifs de Windows, à partir de .NET. Il s’agit donc d’une surcouche (wrapper)
encapsulant les APIS Windows pour les programmeurs .NET.

C’est en partie pour cela que .NET n’est pas portable et ne fonctionne que dans un
environnement Windows. Néanmoins, il est possible de trouver des implémentations de .NET
compatibles avec d’autres systèmes, comme Mono, développé par Novell. Mais cela dépasse le cadre
de notre formation…

Création de votre projet

Encore une fois, Visual Studio va être votre meilleur ami pour réaliser votre application .NET. Il va
d’ailleurs être très efficace lors de la réalisation de projet WinForm car il va vous proposer une série
d’assistants réalisant beaucoup de tâches rébarbatives pour vous. Nous allons donc créer notre
premier projet WinForm.

1. Pour cela, ouvrez Visual Studio

2. Dans la page de démarrage, ou via le menu Fichier, veuillez créer un nouveau projet.
3. Vous avez dans l’arborescence de gauche les différentes catégories de projet que vous
pouvez créer avec les différents langages .NET installés sur votre machine. Sélectionnez la
catégorie Visual C#dans cette liste, puis Windows, et enfin le type de projet « Application
Windows ».
4. Entrez un nom pour cette solution « AppliGestion » et un emplacement dans votre système
de fichier.

En sélectionnant « Application Windows » comme type de projet, vous avez indiqué à Visual
Studio de créer pour vous les bases de votre programme, en créant les quelques fichiers nécessaires
à celui-ci. Mais concrètement, quelles sont les différences et similitudes entre un projet WinForm et
un projet console ?

4
 Développement .NET : 2/3

Projet Application Console vs Applicaiton Windows

Projet Application Console Projet Application Windows

Fichiers de votre projet Fichiers de votre projet

Les dossiers « Properties » et

« References » mis à part, il ne reste plus
que le fichier « Program.cs » et la classe
associée. Ce fichier contient seulement la
méthode statique Main, méthode executée
lorsque votre programme se lance.
Cette fois, en plus des dossiers « Properties » et
« References », le projet contient non seulement la
classe Program.cs avec la méthode statique Main, mais
également le fichier Form1.cs, décrivant la classe de
notre interface. En effet, rappelez vous, en .NET, tout
est objet !

Contenu du main Contenu du main

static void Main(string[] args) [STAThread]
{ static void Main()
} {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Rien est fait de base, c’est donc à Application.Run(new Form1());
l’utilisateur de créer la logique de son }
programme.
Ici, par défaut, nous constatons que 3 instructions
sont présentes. Le but de ces instructions est d’établir
les paramètres nécessaires à l’exécution de notre
interface, puis d’instancier un objet de type Form1,
dont la classe est définie dans le fichier Form1.cs
suscité.
Le but de ce main est donc de définir des
paramètres généraux de notre programme, puis de
lancer notre interface graphique.

Propriétés de compilation Propriétés de compilation

En faisant un clic droit sur votre projet Ici, la propriété « Output type » est sur « Windows
dans l’explorateur de solution, vous Application ».
accéderez aux propriétés de compilation.
Le but ici n’est pas de détailler toutes ces Cette propriété est présente pour indiquer au
propriétés et tous le processus de compilateur la cible de votre programme.
compilation, mais de vous montrer que la
propriété « Output type » est sur « Console
Application »

5
 Développement .NET : 2/3

Importation des classes métiers de l’atelier 1

Lors de notre premier atelier, nous avons créé un ensemble de classes (Entreprise, Commande…).
Ces classes ne sont pas spécifiques pour des projets WinForm ou Console, ce sont simplement des
classes .NET. Nous allons donc les réutiliser dans notre nouveau projet.

Pour cela, nous allons les importer dans notre projet en passant par l’explorateur de solution.

1. Dans l’explorateur de solution, faite un clique droit sur votre projet puis « Ajouter » et enfin
« Elément existant ».
2. Dans l’explorateur qui vient de s’ouvrir, sélectionner les classes « Client », « Commande »,
« Entreprise » et « Fournisseur ». (Pensez à maintenir la touche Ctrl pour les sélections
multiples…)
3. Vérifier que vos classes sont bien dans le même namespace que votre application. Si vous
avez suivis nos tutoriels, elles doivent se trouver dans le namespace AppliGestion, c'est-à-
dire le même namespace que les autres classes (dont votre programme et votre formulaire)
de votre application.

Pour information, une autre solution aurait été de créer un projet de type « Librairie de classe »
contenant nos classes métiers. Nous aurions ainsi séparé complètement ces classes de notre
interface. Nous reviendrons sur ce genre de considérations lors de l’atelier 3.

Le designer de Visual Studio

En ouvrant le fichier Form1.cs, Visual Studio va ouvrir votre fichier en mode Design. Grâce à celui-
ci, vous allez pouvoir positionner les éléments sur votre interface en effectuant de simples « glisser-
déposer ».

Vous devriez avoir dans un coin de votre IDE (Integrated Development Environment : Visual
Studio) la ToolBox, contenant les contrôles de base que vous allez pouvoir ajouter à votre interface.
N’hésitez pas à jouer avec en insérant sur votre form des boutons, labels, images…

Une autre boite de dialogue intéressante est la fenêtre « Propriétés » qui va vous afficher sous
forme de tableau les différentes propriétés que vous allez pouvoir modifier sur l’élément actif. Cet
élément actif peut être la Form, ou tous les autres contrôles que vous aurez ajouté. Il suffit
simplement de cliquer sur un contrôle pour que les propriétés s’actualisent.

Une fois que vous avez sélectionné un contrôle pour afficher ses propriétés, vous pouvez cliquez
sur l’éclair présent dans les boutons de la boite de dialogue « Propriétés ». Cet éclair va vous
permettre de switcher cette boite de dialogue vers le mode « Evènements ». Vous serez ainsi capable
d’afficher et de modifier les méthodes que vous souhaitez associer aux différents évènements du
contrôle actifs. Ne vous inquiétez pas, vous aurez plus de détails sur les évènements dans quelques
paragraphes…

Tous ces outils (Mode Design, boîte à outils, fenêtre de propriétés) ne sont que des assistants de
Visual Studio. Derrière, rien n’est magique. En réalité, Visual Studio va juste générer pour vous le
fichier Form1.Design.cs (complément à la classe Form1.cs), contenant toutes les déclarations et
instructions nécessaires pour reproduire l’interface que vous avez créé en mode design, et que vous
avez configuré grâce à la fenêtre des propriétés.

6
 Développement .NET : 2/3

Par exemple, le fait d’avoir glisser un bouton sur votre Form a créé dans la méthode
InitializeComponent() les instructions suivantes :

//
// button1
//
this.button1.Location = new System.Drawing.Point(81, 67);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.TabIndex = 0;
this.button1.Text = "button1";
this.button1.UseVisualStyleBackColor = true;

Les classes partielles (optionnel)

Jusqu’à présent, nous avons créé un fichier et seulement un fichier à chaque fois que nous
voulions créer une classe.

Si vous le souhaitez, il est tout à fait possible de créer plusieurs classes dans un seul fichier (cas de
classes utilitaires simples dans un fichier Utils par exemple…). Néanmoins, je ne préconise pas cette
solution car il est beaucoup plus facile de s’y retrouver lorsque l’on respecte le principe « une classe,
un fichier ».

Par contre, avec le framework 1.0, il était impossible de créer une classe sur plusieurs fichiers. Le
framework 2.0 a apporté une nouveauté appréciable : les classes partielles. Grâce au mot clé
« Partial », il est donc possible de décrire une classe dans plusieurs fichiers. Mais à quoi cela sert t-
il ?

7
 Développement .NET : 2/3

 Il est envisageable de séparer des définitions de classes trop longues. Mais je ne conseille
pas cette solution. Si vous avez une classe vraiment trop longue, c’est que vous avez un
problème de conception. Essayez de factoriser ;-)
 Il peut être plus facile de travailler à plusieurs sur une classe en même temps. Attention,
selon moi, cela n’arrive pas aussi souvent que cela, ne créez pas un fichier par
développeur pour toutes les classes de votre projet !
 Vous utilisez des outils générateurs de code, comme Visual Studio ;-) Il sera ainsi pratique
de pouvoir séparer le code généré, du code écrit par vous-même. Cela vous permettra de
vous concentrer sur l’essentiel, et de vous assurez également que l’outil ne va pas
modifier le code que vous avez écrit ! C’est donc ce mécanisme qui est utilisé par le
designer et la fenêtre de propriétés. Les fichiers Form1.designer.cs et Form1.cs
définissent la même classe !

Vous avez compris, je pense que les classes partielles doivent être utilisées avec précaution pour
garder une architecture de projet confortable et maintenable. Néanmoins, elles sont indispensables
lorsque l’on travaille avec un générateur de code.

8
 Développement .NET : 2/3

C’est parti : réalisation de notre programme

Durant cette séance de formation nous allons apprendre à manipuler les principaux contrôles de
bases de l’environnement de développement Visual Studio. Le framework .NET intègre de base
plusieurs dizaines de composants graphiques pouvant être utilisés dans vos applications winforms. Il
faut savoir qu’il est aussi possible de créer soit même ses propres composants ayant leurs propres
comportements et leurs propres design.

Votre premier contrôle

Pour commencer nous allons ajouter un premier contrôle à notre winform. Pour réaliser cette
opération il est nécessaire de ce mettre en mode designer au sein de Visual Studio.

Dans un premier temps nous allons ajouter un composant « label ». Celui-ci a pour vocation
première d’afficher du texte. Pour le placer sur la forme, on sélectionne donc le composant label
dans la « boite à outils» et on le drag & drop sur la winform de notre projet. Voilà, vous venez
d’ajouter votre premier composant, et il faut savoir que cela fonctionne de la même manière pour la
quasi-totalité des composants présents dans Visual Studio.

Pour faire simple nous allons modifier le texte du Label. Pour cela, nous allons utiliser la fenêtre
de propriétés décrit dans la partie précédente. N’hésitez pas à passer un peu de temps pour
découvrir toutes les propriétés présentes pour un Label, certaines vont être communes aux autres
contrôles. Pour étudier plus en détail les différents contrôles et connaître leurs propriétés, méthodes
et comportements n’hésitez pas à consulter la librairie de classe MSDN en ligne
(http://msdn2.microsoft.com)

Pour modifier, le texte, il suffit simplement d’éditer le champ « Text » se trouvant dans les
propriétés du label. Renseignez le champ avec le texte qui vous plaira (par exemple « Toto » ou «
Hello World» ). Vous avez réussiavec succès la création et l’édition d’un composant graphique. A
présent nous allons composer notre interface de la même manière; en déposant, étudiant et codant
le comportement des contrôles (Hé oui, il y a malgré tout quelques petits choses à coder avec ses
mains…)

Le traditionnel menu déroulant

Nous allons ajouter un menu déroulant au notre application. Dans la « Boite à outils » de Visual
Studio, on fait glisser le composant « menustrip » sur notre winform.

Comme vous pouvez le constater, ce composant de ne se place pas où l’on veut sur la fenêtre,
mais vous pouvez noter qu’une barre de menu a fait son apparition dans winform, et que le
composant « menustrip » est représenté dans un menu sous le designer.

Nous allons créer notre premier menu. Sur la winform cliquez à l’endroit où il y a marqué « cliquer
ici » dans barre de menu. A présent vous pouvez éditer les « label » de votre menu. Entrons comme
nom de menu « Fichier » puis en dessous ajouter un sous menu que vous appelez « Exit » ou
« Fermer ».

Nous allons maintenant tester notre application. Pour cela, nous allons demander à Visual Studio
de compiler notre programme, puis de l’exécuter. Le raccourci magique pour faire cela est F5. Visual
Studio va même lancer le mode Debug, que nous détaillerons lors de la troisième séance.

9
 Développement .NET : 2/3

Testez votre tout nouveau menu. Formidable tout fonctionne, mais malheureusement lorsque
l’on clique sur « Exit » rien ne se passe ! Pour cela il est nécessaire de coder un comportant se
rattachant au contrôle. Concrètement, l’élément Exit a un évènement, correspondant au click
gauche, onClick auquel on va devoir répondre pour pouvoir exécuter des instructions lorsque celui-ci
va se déclencher. Cette réponse est en réalité une méthode.

Nous allons donc créer une méthode pour répondre à l’évènement onClick du ToolStripMenuItem
« Exit » et indiquer à cet objet d’exécuter cette méthode lorsque l’évènement onClick se produira.
Pour l’évènement onClick, rien de plus simple, Visual Studio nous offre un petit raccourci
sympathique, il suffit de double cliquer sur notre élément (sur « Exit ») pour créer la méthode et
l’attacher à l’évènement.

Nous allons donc coder la fonction de fermeture de l’application. Entre les accolades entrez le
code suivant :

this.close() ;

Normalement, vous ne devriez pas avoir de soucis pour comprendre cette instruction. this
représente l’objet en cours, c'est-à-dire l’instance de votre fenêtre Form1, et close() est une méthode
de la classe Form1. Vous allez me dire que vous n’avez pas créé cette méthode form. Mais souvenez-
vous des notions d’héritage ! Form1 hérite de la classe System.Windows.Forms.Form, qui contient la
méthode close() !

Compilez et exécutez une nouvelle fois l’application. Si tout se passe bien vous devriez être en
mesure de pouvoir fermer la fenêtre de votre programme. Vous venez de créer votre premier
évènement ! A présent vous avez quasiment toutes cartes en mains pour faire vos propres interfaces
graphiques. Toute IHM se programme de cette manière.

Nous n’allons pas en rester là ! Il pourrait être intéressant de manipuler des contrôles un peu plus
évolués.

Les évènements en théorie (optionnel)

Les événements offrent le moyen à une classe ou un objet de notifier d'autres classes ou objets
lorsqu'une situation intéressante se produit. La classe qui envoie (ou déclenche) l'événement est
appelée éditeur et les classes qui reçoivent (ou gèrent) l'événement sont appelées abonnées.

Dans une application C# Windows Forms ou Web typique, vous vous abonnez à des événements
déclenchés par des contrôles tels que les boutons et les zones de liste. Vous pouvez utiliser
l'environnement de développement intégré (IDE) de Visual C# pour parcourir les événements qu'un
contrôle publie et sélectionner ceux que vous souhaitez gérer. L'IDE ajoute automatiquement une
méthode de gestionnaire d'événements vide, ainsi que le code pour s'abonner à l'événement

Liste de données
Lors de notre première formation, nous avions créé une application console permettant de
« gérer » des commandes avec des clients et des fournisseurs. Les classes que nous avions
développées représentées la couche métier de l’application. Pour rappel, le but de notre projet est
d’ajouter une couche de présentation grâce aux winforms.

10
 Développement .NET : 2/3

Avant toute chose, il faut initialiser des données pour que notre futur programme puisse les
exploiter. Nous allons donc créer une liste de clients au sein de notre programme (dans cette
formation nous n’appliquerons pas les principes du modèle MVC, ou d’autres architectures avancées
afin de faciliter le plus possible la compréhension des composants formant une IHM).

Créons une « List » qui sera une donnée de la classe forme. Pour cela on place la déclaration juste
après le « public partial class Form1 : Form », dans le fichier Form1.cs.

Pour créer une liste contenant des clients, copier-coller cette ligne de code

private BindingList<Client> clientList;

Pour utiliser une BindingList, vous allez devoir, comme pour le premier atelier, utiliser le
namespace (système de noms en français) System.ComponentModel. Vous devez donc ajouter cette
ligne dans la liste des using de votre fichier (tout en haut) :

Using System.ComponentModel;

Pour initialiser des données dans cette liste, nous allons créer une commande dans le menu de
notre application. Cette commande, que vous pouvez intituler « Charger les données » va, lors de
l’appel de l’évènement click, créer quelques clients et les ajouter dans la liste clientList que nous
venons de créer. Pour faire tout cela, il suffit de faire comme pour la commande « Exit », c'est-à-dire
de créer l’intitulé de la commande, puis de double cliquer dessus pour générer automatiquement
toute la mécanique événementielle. Ensuite, vous pouvez remplir la méthode générés par les
instructions suivantes :

clientList = new BindingList<Client>();

// Chargement des clients

Entreprise tempInterlocuteur = new Client("Leroy Merlin", "43 Allé des Platanes", "44 Allé des
Platanes");
this.clientList.Add((Client)tempInterlocuteur);

tempInterlocuteur = new Client("Microsoft", "54 rue Charle de Gaulles", "126 av de la

République");
this.clientList.Add((Client)tempInterlocuteur);

Commande myCommand = new Commande(DateTime.Now, "truc", 21, 34);

tempInterlocuteur.AjouterCommande(myCommand);

myCommand = new Commande(DateTime.Now.AddMonths(-1), "machin", 2, 8);

tempInterlocuteur.AjouterCommande(myCommand);

myCommand = new Commande(DateTime.Now.AddMonths(-12), "troisième", 567, 12);

tempInterlocuteur.AjouterCommande(myCommand);

myCommand = new Commande(DateTime.Now.AddMonths(-3), "dernier", 123, 543);

tempInterlocuteur.AjouterCommande(myCommand);

11
 Développement .NET : 2/3

Nous avons besoin d’afficher la liste de notre liste de client. Nous allons utiliser le composant
« ListBox » pour représenter cette liste au sein de notre programme. On drag & drop le composant
sur la winform (sur laquelle nous sommes en tain de travailler).

Pour le moment la «listbox » n’affiche rien, il est nécessaire de spécifier avec quelles données elle
doit travailler. Pour cela il existe une propriété de listbox appelé «DataSource » qui permet de fournir
une collection d’objet au composant, et lui ce charge de l’afficher tous les items compris dans cette
collection (ceci est rendu possible grâce à l’implémentation de l’interface IList. La propriété
DataSource n’est donc compatible uniquement avec les collections implémentant cette interface.)

Ceci se traduit par une seule ligne de code à ajouter à la suite de notre initialisation de données
au sein de la méthode générée pour répondre à l’événement click de la commande « Charger les
données ». Vous pouvez donc utiliser l’instruction suivante à la suite de l’initialisation des différentes
commandes et clients :

listBox1.DataSource = clientList;

Compilez l’application. Normalement vous devriez voir apparaitre dans le composant listbox, les
deux clients que nous avons défini. Vous remarquez que l’affichage du nom du client ne parait pas
« standard ». Vous avez raison, en fait lorsque la listbox veut afficher la string correspondant à l’objet
client, elle appelle notre surcharge de la méthode ToString() que nous avions codé lors de notre
premier TP !

Tableau de données
Maintenant que nous avons notre liste de clients, il serait bon d’afficher les commandes relatives
à chaque client. Lorsque l’on clique sur un des clients de la liste, il faut afficher sa liste de commande,
il y a donc un évènement à coder.

Le composant qui permettra d’afficher la liste des commandes sera un « DataGridView »

Le contrôle DataGridView fournit une table personnalisable pour l'affichage des données. La
classe DataGridView permet la personnalisation des cellules, des lignes, des colonnes et des
bordures. Vous pouvez utiliser un contrôle DataGridView pour afficher des données avec ou sans
source de données sous-jacente. Sans spécifier une source de données, vous pouvez créer des
colonnes et des lignes qui contiennent des données et les ajouter
directement au DataGridView. Vous pouvez également définir les
propriétés DataSource et DataMember pour lier le DataGridView à une
source de données et le remplir automatiquement avec des données.

Ajoutons le DataGridView à notre winform, pour cela nous

procédons comme nous l’avons fait auparavant, on drag & drop le
composant sur notre form, puis on le place comme bon nous semble.

Nous allons à présent créer un évènement sur notre listbox qui se

déclenchera lorsque l’utilisateur cliquera sur un client différent, cet
évènement s’appelle « SelectedIndexChanged ». Allez modifier cet
évènement en passant par la fenêtre de propriété, puis en cliquant sur
l’éclair. Double cliquez sur la case vide à côté de

12
 Développement .NET : 2/3

« SelectedIndexChanged » pour créer automatiquement la méthode s’y rattachant. Nous voilà de

nouveau en mode code source avec une nouvelle méthode qui devrait s’appeler
« onSelectIndexChanged ».

Écrivons dans cette méthode le code source suivant puis tentons de comprendre comment tout
cela fonctionne.

Client monClient = (Client)((ListBox)sender).SelectedItem;

dataGridView1.DataSource = monClient.Commandes;
Notre principale préoccupation est que lorsque l’on clique sur un client dans la listbox, nous
souhaiterions récupérer l’instance de l’objet sur lequel nous avons cliqué (objet Client ). C’est le rôle
de la première ligne de code. Nous créons d’abord un objet Client nommé « monClient». Ensuite
vous pouvez remarquer que nous utilisons le paramètre « sender » qui est présent dans la signature
de l’entête de la méthode. L’objet sender de type Object, représente l’objet qui appelle l’évènement,
dans notre cas c’est la listbox. Mais comme vous pouvez le constater sender est un object, il est
impératif de le caster en listbox si nous voulons le manipuler comme tel, c’est se que nous faisons
grâce à ce morceau de code « ((ListBox)sender) ». Ce cast est possible car nous savons qu’en plus
d’être un objet (tout est objet…), sender est une listeBox. On touche ici aux notions de
polymorphisme, notions avancées du développement objet.

Une fois casté en listbox, nous pouvons utiliser toutes les méthodes de ce composant. Il existe
une méthode permettant de récupérer l’objet sélectionné dans la liste, cette méthode se nomme
«SelectedItem» et retourne un object. Nous allons donc écrire « ((ListBox)sender).SelectedItem »,
mais comme nous souhaitons manipuler un objet de type client a la sortie de cette ligne, il est donc
nécessaire de caster à nouveau mais cette fois en Client, se qui nous donne la ligne de code
suivante : « Client monClient = (Client)((ListBox)sender).SelectedItem; »

Ensuite nous allons alimenter notre datagridview grâce à un DataSource comme nous avons fait
un peu plus haut avec la listbox. Nous souhaitons afficher la liste des commandes du client en cours
de sélection. On indique que le DataSource du DataGridView sera remplis par la liste de commande
du client soit «monClient.Commandes ». Compilez et admirez le résultat. Vous venez de faire de la
programmation évènementielle en écrivant moins de 5 lignes de code !

Pour aller plus loin (Optionnel)

A partir des fonctionnalités que nous avons déjà intégrées, vous avez les bases nécessaires à la
réalisation d’une dernière fonctionnalité : la suppression d’une commande. Bien entendu, il manque
encore beaucoup d’aspects pour avoir un programme complet, mais nous nous arrêterons là pour ce
TP.

N’hésitez pas à explorer les différentes possibilités d’implémentations en regardant les différents
évènements associés au gridView, explorer ce que vous propose l’IntelliSense, demandez aux
formateurs…

13
 Développement .NET : 2/3

Conclusion
Grâce à ce TP, vous devez avoir les bases nécessaires à la découverte de tous les aspects des
technologies .NET. En effet, ces bases sont communes que vous vouliez faire du développement
d’application Windows, du développement sur téléphones/PDA, du développement de jeux vidéo, du
développement Web ou autre encore…

Vous trouverez sur la fiche de la formation sur le site www.efrei-microsoft.fr un zip contenant le
projet que vous avez réalisé lors de cette séance.

14
 Développement .NET : 2/3

Liens et Ressources

Les ressources de cette formation (Power Point et ce document) sont accessibles sur
notre site web : www.efrei-microsoft.fr, rubrique Formations

 Le coach C# : http://msdn2.microsoft.com/fr-fr/vcsharp/bb409645.aspx

 La saga .NET pour les nuls : http://www.efrei-microsoft.fr/news.aspx?id=90

 La documentation officielle MSDN : http://msdn2.microsoft.com/fr-

fr/library/default.aspx

A bientôt !

Ce document a été réalisé en décembre 2007 par Benjamin Talmard et Vincent Dieudonné pour
EFREI Microsoft. Il a été révise en décembre 2008 par Benjamin Talmard

15