304
Total Views
247
Views on TechyLib
57
Views from Embeds
0
Favorites
4
Downloads
After making your selection, copy and paste the embed code above.
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
1
sur
91
Utili
ser les types et
les structures
du langage
C#
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
2
sur
91
Sommaire
1
INTRODUCTION
................................
................................
................................
................................
.........
3
1.1
C
ONTEXTE FONCTIONNEL
................................
................................
................................
...........
3
1.2
C
ONTEXTE TECHNIQUE
................................
................................
................................
...............
4
2
DEFINIR L’INTERFACE
UTILISATEUR DE L’APP
LICATION
................................
................................
.
5
2.1
C
REER LE PROJET ET LA
FENETRE PRINCIPALE
................................
................................
............
5
2.2
D
EFINIR LES MENUS
................................
................................
................................
.................
11
2.3
P
OSITIONNER LES CONTR
OLES DE DONNEES
................................
................................
.............
32
2.4
L
OCALISER L
’
APPLICATION
................................
................................
................................
........
41
3
ALIMENTER LA GRILLE
AVEC LE CONTENU D’UN
FICHIER CSV
................................
....................
48
3.1
C
REER ET UTILISER LA
TABLE EN MEMOIRE
................................
................................
................
49
3.2
A
LIMENTER LA TABLE EN
MEMOIRE AVEC LE FICH
IER
CSV
................................
..........................
58
3.3
F
INALISEZ LE COMPORTE
MENT DE LA FENETRE
................................
................................
..........
80
4
POUR ALLER PLUS LOIN
…
................................
................................
................................
...................
91
4.1
L
ES LIENS UTILES
................................
................................
................................
.....................
91
4.2
I
DEE
/
RESSOURCE
................................
................................
................................
.....................
91
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
3
sur
91
1
Introduction
Cet atelier s’inscrit dans
le cadre du tutorial du coach C# dont l’objectif est la
découverte et l’utilisation du langage C# 2.0 avec Visual Studio 2005 pour la
construction d’applications avec une approche orientée objet.
Les exercices de l’atelier
2
se proposent de vous présen
ter
l’utilisation des types et
des structures de bases du langage C# en développant une application simple à
base de formulaire Windows
.
1.1
Contexte fonctionnel
Rappel du contexte fonctionnel du tutorial du coach C#
L’objectif du tutorial du C# est
d’accompagner les développeurs à la prise en main du
langage C# dans le cadre de projets de développement. Il s’adresse à tous ceux qui,
connaissant un autre langage ou ayant une expérience de développement,
souhaite
nt
aller vers la programmation C#. Ce tu
torial se concentre donc
sur le
langage
, en l’abordant plus du point de vue des besoins des développeurs que de
celui d’une liste exhaustive des caractéristiques techniques.
Le guide de référence complet du langage C# est disponible en ligne sur
le site
MSDN de Microsoft à l’adresse suivante
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⼶Te昸sbd⡖E.UM⤮Fséx
=
=
Contexte fonctionnel du
deuxième
atelier
Cet atelier
décrit
la gr
ammaire du langage C# et
les différents types que vous allez
nécessairement utiliser
dans vos tâches de programmation. De plus
,
est abordé
e
la
gestion de
s blocs de programmation
, qui
est
importan
te tant du point de vue de la
p
o
r
tée des variables que de celui de la gestion de la mémoire.
Vous allez donc
développer une application à base d
e formulaire pour afficher une
liste d’information
s
, lu
e
dans un premier temps à partir d’un fichier
au format «
Texte
délimité
» ou CSV
.
Cette application présente
une
fenêtre avec une grille
de travail
sur les données
:
Grille de données
TextBox de résultat
de calcul
Menus de sauvegarde
et d’ouverture des
f楣桩e牳⁃ps
=
Ba牲eeaî楧a瑩tn
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
4
sur
91
Pour la programmation de cette partie, vous allez utiliser une approche «
à
l’ancienne
», c'est
-
à
-
dire que vous allez
utiliser
des objets
de données définis
à la
main
en lisant
un contenu au format texte
-
délimité.
La programmation que nous
allons utiliser confère
à
ce que l’on faisait dans un temps pas si ancien, lorsque nous
programmions en client/serveur à deux niveaux.
1.2
Contexte technique
A la fin de cet atelier, vous saurez comment :
Créer une application simple à base de formulaire
;
Différencier les types par valeurs et les types par référence
;
Définir la portée des variables
;
Organiser votre code en bloc, afin de limiter les portée
s des variables
;
Utiliser les
principales instructions
de bouclage et de tests
;
Utiliser les principaux opérateurs
;
Utiliser des objets fournis par le Framework
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
5
sur
91
2
Définir l’interface utilisateur de l’application
Dans cet exercice, vous allez apprendre à
:
-
Créer un projet de développement type formulaire Windows
;
-
Positionner les différents contrôles graphique
s
de l’interface utilisateur
=
X
=
J
=
Localiser l’application dans différentes langues
=
X
=
=
Objectif
L’objectif de cet exercice est de
débuter le
développement d’une application à base
de formulaire en positionnant les éléments et contrôles de l’interface utilisateur
, tout
en abordant les concepts de base du langage C#.
Contexte fonctionnel
Vous êtes développeur
, et vous avez à implémenter
des écrans qui ont été décri
t
s
dans l’analyse fonctionnelle, ou mieux qui ont été conçu
s
par un designer
d’application à base de formulaire (on peut rêver un peu, non
?).
Plus probablement,
on vous a donné un bout de feuille issu d’une réunion
et qui décr
it ce qu’il faudrait
faire
:
Votre p
remière tâche est de réaliser cette
interface utilisateur.
2.1
Créer le projet et la fenêtre principale
Déroulement de l’exercice
:
1.
Créez la solution
:
Lancez
Visual C#
Dans Visual C# Express, cliquez le menu
Fichier > Nouveau projet …
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
6
sur
91
La
boîte
de dialogue
Nouveau Projet
s’affiche. Dans cette
boîte
de
dialogue, sélectionnez le modèle de projet
Application
Windows
et
indiquez un nom de projet
Coach
.Editeur
;
Cliquez le bouton
OK
.
Un projet avec une fenêtre vide s’affiche
;
Modèle du projet
Nom du projet
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
7
sur
91
Si l’explorateur de sol
ution n’est pas visible, pour l’afficher dans Visual
C# Express
cliquez le menu
Affichage > Explorateur de solution
s
;
Dans la barre
d’outils, cliquez la disquette pour sauvegarder votre
solution
;
Dans la
boîte
de dialogue
Enregistrer un projet
, indiquez votre
répertoire de travail, en cochant la case à cocher
Créer le répertoire
pour la solution
;
Cliquez sur
Enregistrer
;
2.
R
enommez
la fenêtre principale
:
Dans l’Explorateur de Solutions, sur le fichier
Form1
.cs
, faites un
clic
-
droit
et sélectionnez le menu
Renommer
;
Changez
le nom de
Form1.cs
en
Main.cs
;
Appuyez
sur la touche
Entrée
;
La fenêtre suivante s’affiche
:
Sauvegarde de la solution
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
8
sur
91
Visual Studio vous propose ici de chercher automatiquement dans le
projet en cours tous les endroits où il y a une référence au nom de la
fenêtre
Form
1
et de le
s
remplacer par le nouveau nom donné
Main
. Il va
s’occuper pour vous de renommer les variabl
e猠s琠au瑲t猠
é泩men瑳
Ⱐ捥ⁱu椠
e獴s瑲t猠u瑩汥tdçn挮
=
=
Cliquez le bouton
Oui
;
En fait, un formulaire Windows est avant tout une classe
d’objet (d’ailleurs
tout est classe d’objet dans .Net
=
⤮)En
double cliquant
sur le nom de la
fenêtre
Main.cs
dans l’
Explorateur de solutions
, vous verrez le
designer de formulaire qui affiche l’interprétation du code de
=
déf楮楴içn=de=
污l捬慳獥.
=
䍥C捯de=éeu琠
au獳椠
ê瑲t=a晦楣ién=
cliq
uant
dans la barre d’outil
de l’explorateur de solutions l’icône
=
X
=
=
=
Il est possible d’afficher le code d’un formulaire en suivant d’autres
…
=
捨em楮i
=
»
=
W
=
愮
=
sçu猠 fa楴e猠 un=
clic
-
droit sur le fichier
du formulaire et
sélectionnez le menu
Afficher le code
;
b.
Vous
sélectionnez le fichier
du formulaire et vous cliquez
le menu
Visual C# Express
Affichage > Code
;
Un formulaire Windows est composé d
’au moins
=
deux楣桩i牳ans⁖楳畡氠
p瑵d楯⸠䥬
s
=
sçnt= î楳ib汥
s
=
en cliquant sur l’icône
=
é狩揩den琠汥l nçm= du=
f楣桩e爮ê
=
=
ie=f楣桩i爠=
Main.cs
contient tous les codes que vous allez programmer, et
le fichier
Main.Designer.cs
contient tous les codes qui sont générés par
Visual Studio.
Le code généré est exactement celui que nous devrions
développer à la main si nous voulions faire l’équivalent de ce que fera le
générateur. Il n’y a ainsi aucun code cach
é= e琠污l 瑯ta汩瓩= du
=
cçde= e獴s
a捣c獳楢汥
=
!
=
N’hésitez donc pas à aller y jeter un coup
=
d’œil, mais ne vous
污l捥z=éa猠à=汥l mçdifie爠獩sîçu猠ne=獡îez=éa猠捥=èue=îçu猠fa楴e猬=獡u映
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
9
sur
91
pour corriger des éve
ntuelles erreurs de compilation
lié
e
s à des
destructions intempestives de contrôles par exemple.
3.
Paramétrez la fenêtre principale
:
Affichez
le formulaire
Main.cs
en
double
-
cliquant
sur son fichier dans
l’explorateur de solutions
;
Il y
a de fortes chances que le formulaire
ait déjà été ouvert, et
dans ce
cas vous pouvez cliquer
directement sur l’onglet
Main.cs [Design]
de la
zone de travail
;
En
faisant un
clic
-
droit sur ces onglets, vous avez aussi un menu
contextuel qui propose des options intéressantes comme fermer toutes
les documents ouverts sauf celui en cours (utiles lorsqu’il y a tellement
de fichiers
ouverts qu’on est un peu perdu), ou comme ouvrir deux
documents en visualisation simultanée sur la zone de travail (utile pour
comparer et/ou copier
-
coller facilement du code).
Sur le formulaire
, faites un
clic
-
droit
et sélectionnez le menu
Propriétés
;
Dans la fenêtre
Propriétés
qui est apparu
e
sur la droite, vérifiez tout
d’abord que vous êtes bien sur le bon objet, dont le nom et le type
s’affiche dans la liste déroulante en haut
;
Visualisation simultanée
Fermeture des documents
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
10
sur
91
Si vous avez un formulaire complexe, cette liste déroulante est à utiliser
pour sélectionner le bon élément. D’une manière générale, c’est une
b
çnne=é牡瑩êue=èue=de=îéê楦楥爠汥
=
nçm=du=捯n瑲t汥ldçn琠îçu猠mçdif楥i=汥l=
é牯ê物é瓩s.
=
=
=
La barre d’outils de la fenêtre de
Propriétés
possède les boutons
suivant
:
-
Le bouton
affiche les éléments en les triant par catégorie
;
-
Le bouton
affich
e les éléments en les triant par
nom
;
-
Le bouton
définit que les éléments à afficher sont les propriétés
de l’objet sélectionné
=
X
=
J
=
ie= bçu瑯n=
=
déf楮楴i èue= 汥猠 é泩浥l瑳t à= a晦楣he爠 獯n琠 汥猠
événements de l’objet sélectionné
–
=
ce瑴e= îue= 獥牴ê à= a橯à瑥爠
晡捩cemen琠
de猠 mé瑨çde猠 de= 狩éçn獥猠 aux= éîénemen瑳
=
⡮Eu猠
îe牲çn猠捥污lé汵猠ta牤ê
=
X
=
J
=
ie=bçu瑯n=
=
a晦楣桥=une=éage=de=é牯é物é瓩s=捯mélémenta楲e猠de=
l’objet, s’il en existe une bien sûr.
=
=
=
䑡a猠 污l 晥nê瑲t= de=
Propriétés
, les propriétés affichées en
gras
sont
celles que vous avez modifiées. Les autres indiquent les valeurs par
défaut. Pour chacune des propriétés dont la valeur indiquée est différente
de la valeur par défaut,
Visual C# Express
va générer une (ou plusieurs)
ligne(s) dans le fichier
Main.Des
igner.cs
;
Dans la fenêtre
Propriétés
, sélectionnez la propriété
Text
et tapez la
valeur
Editeur du Coach C#
; Vous
remarquerez que le titre de la
fenêtre a changé
Dans Microsoft .net, la propriété
Text
référence toujours ce qui est affiché
par le contrôle à l’écran, même pour les label
s
=
çu=
s
=
bçu瑯n
s
.
=
=
Dans la fenêtre
Propriétés
, sélectionnez la propriété
Size
(dimension),
ouvrez la en cliquant sur
, et indiquez la valeur
727
pour
Width
(largeur) et
427
pour
Height
(hauteur)
;
Dans la barre d’outil
s
de Visual C# Express, cliquez le bouton
pour
sauvegarder toutes les modifications réalisées
;
List
e déroulante
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
11
sur
91
2.2
Définir les menus
L’objectif de cet exercice est d’ajouter à l’application deux types de menus
:
-
Une ba
rre de menu standard qui s’affiche sous le titre de la fenêtre
;
-
Un menu contextuel, qui va s’afficher quand l’utilisateur fera un
clic
droit sur
un icône s’affichant dans la zone de notification (en bas à droite de l’écran
)
Nous en profiterons pour
programmer
nos premières lignes de code dans
cette
application
afin de
connecter quelques sous menus (comme
Quitter
par exemple
).
Déroulement de l’exercice
:
1.
Ajoutez
la barre de menu standard
:
Visual Studio C# Express
propose beaucoup de contrôles pour vous aider
à construire vos écrans. Ces contrôles sont disponible
s
dans la
Boite à
outils
qui s’affiche en standard sur la gauche de votre écran. Si elle n’est
pas visible, vous pouvez l’afficher en cliquant le menu
Affic
hage > Boite
à outil
s
dans Visual C# Express.
Vous pouvez ajouter (ou retirer) des contrôles à la liste qui est proposée.
Pour ce faire, faites un
clic
-
droit
dans la
Boite à outil
s, et le menu
suivant s’affiche
=
W
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
12
sur
91
Sélectionner le menu
Choisir les éléments …
e琠污lbo楴ee楡汯gue
Choisir des éléments de boîte à outils
vous aide à sélectionner les
composants que vous
souhaitez
;
Le bouton
Parcourir
permet de sélectionner directement un assemblage
(.dll) qui contiendrait des contrôles
voulus.
Vous pouvez ajouter des composants issus de nombreuses sociétés
tierces à Microsoft, ou issus de sites communautaires comme
http://www.codeplex.com/
.
Sur la page d’accueil
=
de= 捥= de牮楥爬=
珩汥捴楯inez
=
污lga汥物e=de=捯n瑲t汥
s
=
e琠
îçu猠aîez=une=汩獴s=de=捯n瑲ô汥
s
=
et=
d’exemple
s
=
瓩泩捨a牧eab汥
s
.
=
=
=
䱡i
Boite à outils
affiche uniquement les compo
sants
qui sont disponible
s
compte tenu du contexte en cours.
Si vous êtes dans une page de code,
la
Boite à outils
sera donc vide.
Sélection directe de la dll
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
13
sur
91
Pour afficher le contenu de la
Boite à outils
, vérifier donc bien que vous
avez sélectionné le formulaire en mode
[Design]
.
Ouvrez le formulaire
Main.cs
en mode
[D
esign
]
en double
-
cliquant sur
le fichier
Main.cs
dans
l’
Explorateur de solution
s
;
Dans la boite à outils, ouvrez l’onglet
Menus et barr
e d’outils
en
cliquant sur
qui précède le nom de l’onglet
;
Faites un glisser
-
déplacer du contrôle
Menustrip
sur le formulaire
;
Vous devez voir apparaître deux choses sur votre formulaire
: une
barre de menu vide sous le titre et un contrôle de menu
(
menuStrip1
)
dans une nouvelle zone de dépôt de contrôle
s
en bas de la zone de
travail
;
Barre de menu (visuel)
Contrôle de menu
Zone de dépôt de contrôles
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
14
sur
91
Faites un
clic
-
droit
sur
le contrôle
menuStrip1
et sélectionnez le menu
Propriétés
;
Dans les propriétés du contrôle, change
z
son nom par
mainMenuStrip
en changeant la valeur de la propriété
(Name)
; Cette propriété
apparaît parmi les premières si vous êtes en classement alphabétique
(bouton
de la barre d’outils des propriétés)
;
Le langage
C# est sensible à la casse
des mots. Autrement dit
MainMenuStrip ne représente pas la même chose que mainMenuStrip.
Pensez donc à systématiquement faire attention à la façon dont vous
nommez vos variables et composants afin d’éviter les er
牥
u牳ê de=
捯mé楬a瑩tn⸠ie=me楬汥uê
=
mçyen=es琠de=su楶êe=un=é污l=de=nçmmage=e琠de=
nç瑡瑩tn=é狩捩献
=
=
=
mçu爠tçu琠saîç楲=獵爠汥猠bçnne猠é牡瑩êue猠e琠汥猠捯nîen瑩tn猠捯n捥牮ênt=
汥lnçmmageⰠîç楣i⁵n=en⁴狨猠in瓩牥獳ant
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⽭猲2VMM2⡖E⸸M⤮a獰x
=
=
=
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
clic
-
droit sur la
barre de menu que vous venez d’ajouter
;
Séle
ctionnez le menu
Insérer d
es éléments standard
; Magique
Non
?
Bon seuls les menus ont été ajoutés (c’est déjà bien), et il reste à
ajouter le code
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
15
sur
91
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
double
-
clique
sur
le menu
Fichier > Quitter
;
Une méthode
quitterToolStripMenuItem_Click
de réponse au menu
Quitter
a été ajoutée au code
du formulaire
Main.cs
;
Code C#
public
partial
class
Main
:
Form
{
public
Main()
{
InitializeComponent();
}
private
void
quitterToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
}
}
Dans la méthode
quitterToolStripMenuItem_Click
,
ajoutez le code
de
fermeture du formulaire
this
.Close();
Code C#
public
partial
class
Main
:
Form
{
public
Main()
{
InitializeComponent();
}
private
void
quitterToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Fermeture du formulaire
this
.Close();
}
}
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
sauvegarder toutes les modifications réalisées
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
16
sur
91
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de
débogage
;
L’Editeur du coach
C#
se lance, et en cliquant
son
menu
Fichier > Quitter
, il se fe
rme
!
Félicitation, vous venez de réussir la première ligne de code
(bon
certes, no
u
s n’avons pas encore affiché «
Hello World
», mais c’est un
bon début).
C’est quoi
this
?
Le mot clé
this
référence l’instance courante d’un objet. Dans notre cas il
s’agit donc de l’instance de la fenêtre
Main
qui sera créée lors de
l’exécution du programme.
=
=
=
mçu爠êçu琠saîç楲=爠êeçt泩=
this
, veuillez aller sur le lien
:
http://msdn2.microsoft.com/fr
-
fr/library/dk1507sz(VS.80).aspx
Mais comment fait le système pour retrouver la bonne méthode à exécuter
quand on clique sur
Quitter
?
C
e n’est
灡é
=
汥lnçm=de=污lméthçde=èu椠晡楴ifç椮ibn=晡楴Ⱐ污=fçn捴楯n=de=é物獥=en=
charge de l’événement (
潵ç
la méthode de réponse à l’événement,
èu椠獥=d楴
=
…
=
Event Handler
» en anglais)
a été dans notre cas automatiquement
paramétrée par Visual C# Express dans le fichier
Main.Designer.cs
lorsque
nous avons fait un double
clic
sur le menu
Quitter
. Nous allons aller voir la
définition
(faites attention de ne r
ien modifier
)
:
併v牥r 汥lf楣桩i爠
Main.Designer.cs
en double cliquant dessus dans
l’
Explorateur de solutions
;
-
Dans ce fichier, cherchez
la partie qui est automatiquement générée
par Visual C# Express
;
-
Cliquez sur le signe
pour visualiser les lignes de code
;
-
Avec la barre
de défilement vertical, survolez
le code et localisez la
définition du menu
quitterToolStripMenuItem
;
Nous reviendrons plus dans le détail sur ces fonctions de prise en
charge des événements (ou
«
Event Handler
»
), notamment sur le
formalism
e
à utiliser.
Ce qu’il faut retenir est qu’il n’y a aucun code
捡捨éI=e琠èue=nçu猠éçu牲楯i猠獩snçu猠汥=dé獩se物çn猠nç
mme爠捯mme=
nous le voudrions la fonction de réponse à l’événement (avec un
beau=
e琠 ç物g楮i氠
nçm= 捯mme= …
=
tç瑯
=
»= éa爠 exemé汥
=
!
=
ma楳i 捥污l ne=
晡捩c楴i⁰a猠s
a
=
ma楮瑥nan捥⁰a爠êa=楴e
⤮
=
J
=
䙥牭ez=汥lf楣桩i爠de=捯de=
Main.Designer.cs
en cliquant sur le bouton
de l’onglet du fichier
=
X
=
=
C’est ici qu’est
déf楮楥= 污l 牥污瑩tn=
entre l’événement
e琠 污l fçn捴楯n= de=
é物獥=a牧e.
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
17
sur
91
Comment
visualiser l’ensemble d
es= éîénemen瑳t d楳éçn楢ie
s
=
獵ê= 汥l menu=
Quitter
?
-
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
clic
-
droit
sur le
menu
Quitter
et sélectionnez le menu
Propriétés
;
-
Dans les
P
ropriétés
du menu
Quitter
, cliquez le bouton
de la barre
d’outil
s
=
pour afficher l’ensemble des événements
=
X
=
sçu猠deîez=癯楲=
que seul l’événement
Click
possède une méthode de réponse
;
-
Par la suite, pe
nsez à cliquer sur le bouton
de la barre d’outils des
Propriétés
pour revenir à la liste des propriétés
;
Pour ajouter une fonction de réponse à un événement, il suffit d’aller
î楳畡汩獥爠污l汩獴s=de猠éîénemen瑳td楳içn楢ie猠獵爠
汥l
捯n瑲t汥l珩汥捴楯iné=
⡣E⸠捩
J
de獳s猩se琠de=dçub汥
J
cliquer sur le nom de l’événement. Cela va
a橯àte爠 autçma瑩tuemen琠 污l 景n捴楯n= dans= îç瑲t= f楣桩i爠 de= 捯de= ⡰Eê=
exemé汥l
Main.cs
), et le paramétrage de l’événement dans le fichier
u瑩汩珩= éaê= 汥l de獩gne爠 de= s
楳畡氠 C#= bxé牥獳ê ⡰E爠 exemé汥l
Main.Designer.cs
).
Au lieu de double
-
cliquer, vous pourriez aussi
indiquer un nom quelconque pour la fonction de prise en charge («
toto
»
par exemple), et au moment ou vous allez taper
Entrée
, Visual C#
Express va tout créer
pour vous.
Si vous détruisez la fonction de réponse de votre fichier de code, il faudra
aussi
penser à retirer
le paramétrage de l’événement dans le fichier utilisé
éa爠汥lde獩sne爬ês楳ia氠䌣Cbxé牥獳êne=éçuîan琠l
e=fa楲e=éçu爠îçu猠捡爠楬=ne=
獡楴
=
éa猠獩s污ld
e獴牵捴cçn=⡯E=汥lchangemen琠de=nçm⤠es琠捯nsé捵瑩映à=une=
e牲eu爠çu=à=un=捨ç楸=dé捩擩=du=éêçg牡êmeu爮
=
䑥a瑯u瑥=man槨牥Ⱐ獩=îçu猠
ne= 汥l 晡楴i猠éa猬s îçus= çb瑩tnd牥ê= une=e牲eu爠de= 捯mé楬a瑩tn
=
⡥琠çu椬i 汥l
捯mé楬a瑥u爠ê#⁶é物f楥iun=max業ume=ç獥⤮
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
18
sur
91
2.
Ajouter u
n menu contextuel
:
Nous allons maintenant ajouter un menu contextuel, qui va s’afficher
quand l’utilisateur fera un
捬cc
=
droit sur un icône s’affichant dans la zone
de notification (en bas à droite de l’écran)
=
=
=
=
mçu爠捥=fa楲e=nçuseîçn猠獵楶牥ê
èua瑲t⃩瑡ées
=
W
=
J
=
Ajouter un icône s’affichant lors de l’exécution dans la zone de
nç瑩f楣慴içnⰠe琠汥⁰a牡mé瑲tê
=
X
=
J
=
A橯à瑥爠un=men
uçntex瑵e氬琠汥léa牡mé瑲eê
=
X
=
J
=
Lier l’icône de notification et le menu contextuel
=
X
=
J
=
A橯à瑥爠êe=de=牲eséçndantux
é瑩tn猠
du=nu
=
捯n瑥x瑵e氮
=
=
Ouvrez le formulaire
Main.cs
en mode
[Design]
en double
-
cliquant sur
le fichier
Main.cs
dans
l’
Explorateur de solution
s
;
Dans la boite à outils, ouvrez l’onglet
Contrôles communs
en cliquant
sur
qui précède le nom de l’objet
;
Faites un
glisser
-
déplacer
du contrôle
NotifyIcon
sur le formulaire
;
Vous devez voir apparaître le contrôle
notifyIcon1
dans la zone de
dépôt de contrôles en bas de la zone de travail
;
Faites un
clic
-
droit
sur
le contrôle
notifyIcon1
dans la zone de
dépôt
de contrôles, et sélectionnez le menu
Propriétés
;
Dans les
propriétés du contrôle, changez
son nom par
main
NotifyIcon
en changeant la valeur de la propriété
(Name)
; Cette propriété
apparaît parmi les premières si vous êtes en classement alphabétiqu
e
(bouton
de la barre d’outils des propriétés)
;
Dans les propriétés du contrôle, change
z
la propriété
Text
avec
Editeur du Coach C#
; Ce texte apparaîtra en aide rapide (
«
tooltip
»
)
lorsque le pointeur de souris sera au dessus de l’icône
;
Dans
l’
E
xplo
rateur de solutions
, f
aites un
clic
-
droit sur le projet
Coach
.Editeur
et sélectionnez le menu
Propriétés
;
Sélectionnez l’onglet
Ressources
;
Sur l’écran de gestion des ressources, cliquez le menu
Ajouter une
ressource > ajouter un fichier existant…
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
19
sur
91
Par rapport au premier atelier, nous n’avons pas à créer les ressources
a獳s捩猠 au= é牯橥琠 ca爠 e汬e猠 çn琠 é瓩= autçma瑩tuemen琠 捲e猠 éa爠 汥l
mçdè汥lèueçu猠sîçn猠s瑩汩珩⁰çu爠捲ée爠êe⁰牯橥琮
Dans la
boîte
de dialogue
Ajouter un fichier
existant
aux
ressources
, naviguez jusqu’au répertoire des
fichiers utiles de
l’exercice 01
de l’atelier 02
(par exemple
C:
\
Coach C#
\
Atelier
02
\
Fichiers Utiles
\
Exercice 0
1
)
;
Dans la boite de dialogue
Ajouter le fichier existant aux ressources
,
s
électionnez le fichier
lan_
connected
.ico
et cliquez le bouton
Ouvrir
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Fermez l’onglet des ressources du
Coach.Editeur
en cliquant sur
son
bouton de fermeture
;
Dans l’explorateur de solutions,
faites
un
clic
-
droit
sur le fichier
Main.cs
et sélectionnez le menu
Afficher le code
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
20
sur
91
Localisez
dans la définition de la classe Main la méthode
public
Main()
; Il s’agit du constructeur de la
classe
;
Code C#
namespace
Coach.Editeur
{
public
partial
class
Main
:
Form
{
public
Main()
{
InitializeComponent();
}
(…)
}
}
C’est quoi un constructeur ?
=
ie= =
constructeur est la méthode membre d’une classe que vous allez
aéée汥爠lhaèue=景楳ièue⁶çu猠楮獴sn捩ez⁵nçuîe氠lbàet
=
W
=
=
=
=
=
=
Main
main =
new
Main
();
L’objectif du
捯n獴牵c瑥u爠 e獴s de= 捲爠 捯nîenab汥men琠 une= 楮獴ance=
d’objet, en le configurant dans un état valide. En C#, le constructeur
狩êçndux=牡捴é物獴楱ue猠獵楶an瑥s
=
W
=
J
=
ie=nçm=du=捯n獴牵捴eu爠e獴s物gçu牥êsement=汥l même=èue=汥l nçm=
de==a獳s
=
X
=
J
=
ie= cçn獴牵捴euê
=
n’a aucun type de retour spécifié (pas même
void
).
Comme toute méthode membre, il est possible de passer des paramètres
au(x) constructeur(s) d’une classe. Il est ainsi possible de définir plusieurs
façons convenables de créer une instance d’objet.
C’est notamment
visible dans l’IntelliSense qui vous propose de sélectionner un des
d楦曩牥ê瑳t捯n獴牵捴cuê猠s楳灯n楢汥Ⱐ汥=猠échéant
=
W
=
=
=
=
䍯C獴牵捴cu爠êe=污s獥
=
䥬⁹捩⁴牯楳=晡nse狩e爠捥琠çb橥琠
=
Nom de variable
Méthode membre appelée pour l’instanciation
Type de variable
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
21
sur
91
Le constructeur qui ne possède aucun paramètre passé est appelé le
constructeur par défaut
.
Dans le constructeur de
Main
, ajoutez le code pour initialiser l’icône du
contrôle
mainNotifyIcon
avec celui chargé en ressource
; Bon, c’est le
même code que celui fait à l’atelier N°1
(exercice 4.2.2)
, mais on va se
répéter un peu
:
Code C#
namespace
Coach.Editeur
{
public
partial
class
Main
:
Form
{
public
Main()
{
InitializeComponent();
// Assignation de l'icone de mainNotifyIcon
mainNotifyIcon.Icon = Properties.
Resources
.
lan_connected
;
}
(…)
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs [Design]
de la zone de travail
;
Dans la boite à outils, ouv
rez l’onglet
Menus et barre d’outils
en
cliquant sur
qui précède le nom de l’onglet
;
Faites un
glisser
-
déplacer
du contrôle
ContextMenustrip
sur le
formulaire
; Vous devez voir apparaître deux choses sur votre
formulaire
: une barre de menu contextuel vide sous le menu standard
et un contrôle de menu (
contextM
enuStrip1
) dans la zone de dépôt de
contrôles en bas de la zone de travail
;
Un menu contextuel ne s’affichant pas hors de son
捯ntex瑥
=
(c’est une
Lapalissade), dès que le contrôle du menu contextuel n’est plus
珩汥捴楯iné=dan猠污l zçne=de=dééôt=de=捯nt狴汥
s
, il disparaît de l’écran.
Pour l’afficher de nouveau, il vous suffit de sél
e捴楯nne爠汥=捯n瑲t汥=dans=
污lzçneeééôte=n瑲t汥献
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
22
sur
91
Faites un
clic
-
droit
sur
le contrôle
contextM
enuStrip1
dans la zone de
dépôt de contrôles,
et sélectionnez le menu
Propriétés
;
Dans les
propriétés du contrôle, changez son nom
par
mainNotificatio
nIconContextMenuStrip
en changeant la valeur de la
propriété
(Name)
; Cette propriété apparaît parmi les premières si vous
êtes en classement alphabétique (bouton
de la barre d’outils des
propriétés)
;
Sur la fenêtre, juste en de
ssous des menus standards,
cliquez
sur la
boite de texte
«
Tapez ici
»
qui apparaît dans le
ContexMenuStrip
juste en dessous des menus standards du formulaire
;
Saisissez dans la
boite de texte
Maximiser la fenêtre
;
Recommencez l’opération avec les options
Restaurer la fenêtre
,
Minimiser la fenêtre
, et
Quitter l’application
;
Afin de sortir du mode de saisie des options du menu, faites un
simple
clic
sur une des options déjà saisie
;
Déplacez le poin
teur de souris
sur la dernière boite de texte
«
Tapez
ici
», et vous devez voir apparaître la flèche d’une liste déroulante sur la
droite du contrôle
;
TextBox «
Tapez ici
»
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
23
sur
91
La liste déroulante vous aide à insérer un autre type de ligne de menu
: le
MenuItem
correspond à une ligne de menu similaire à celles que vous
venez de saisir, une
ComboBox
ajoute une liste déroulante, et le
TextBox
vous permet de saisir directement une valeur de menu lors de
l’exécution de l’application. Il reste le
Se
parat
or
, que nous
allons utiliser,
et qui ajoute simplement une ligne grise horizontale dans la liste des
menus.
Cliquez
sur
Separator
pour insérer une ligne de séparation dans la
liste des menus
;
Faites un
glisser
-
déplacer
de la ligne de séparation afin de la
posit
ionner avant le menu
Quitter l’application
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Faites un
clic
-
droit
sur le contrôle
mainNotifyIcon
dans la zone de
dépôt de contrôles, et sélectionnez le menu
Propriétés
;
Liste déroulante
Séparateur positionné ici
par glisser
-
déplacer.
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
24
sur
91
Dans les propriétés du contrôle, changez la valeur de
ContextMenuStrip
en utilisant la liste déroulante proposée, et
selectionnez
mainNotificationIconContextMenuStrip
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
L’Editeur du coach
C
#
se lance, et vous devez voir votre icône dans la zone de notification
en bas à droite de votre écran. Si vous faites maintenant un clic
-
droit
sur votre icône, vous devez voir apparaître le menu contextuel. Reste
donc à programmer les options du menu.
Bon, si vous avez des erreurs de compilation, c’est probablement lié à la
捡獳s=ca爠䌣Ce獴sca獥
J
sensitive, ou encore à un ‘
=
;
’ qui manque en fin de
汩gne⸠pe牶ez
J
vous des messages d’erreurs de compilation renvoyés par
s楳畡氠䌣lbxé牥獳êéçu爠瑲潵îe爠êes
=
bçnne猠sç牲e捴楯n献
=
=
=
乯k猠 a汬çn猠 main瑥nan琠 déîe汯lée爠 汥猠 méthçde猠 de= 狩êçnse= aux=
éîénemen瑳t
Click
de chacun des menus.
Arrêtez le mode de débogage en cliquant le bouton
dans la
barre
d’outils
Déboguer
de
Visual C# Express
(vous auriez tout aussi bien
quitter l’application de
l’Editeur du Coach C#
en utilisant les menus
Fichier > Quitter
)
Faites un
clic
sur le contrôle
mainNotificationIconContextMenuStrip
dans la zone de dépôt de contrôles, afin de l’afficher sur le formula
ire
;
Faites un
double
-
clique
sur l’option du menu contextuel
Quitter
l’application
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
25
sur
91
Une méthode
quitterLapplicationToolStripMenuItem_Click
de
réponse au menu
Quitter
l’application
a été ajouté
e
au code du
formulaire
Main.cs
;
Dans cette méthode, ajo
utez
le code de fermeture
du formulaire
; C’est exactement la même ligne de code que celle que
nous avons ajouté précédemment pour répondre au menu
Fichier >
Quitter
du formulaire
Main.cs
(rien de
difficile donc)
;
Code C#
private
void
quitterLapplicationToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Fermeture du formulaire
this
.Close();
}
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs
[Design]
de la zone de travail
;
Faites un
double
-
clique
sur l’option du menu contextuel
Maximiser la
fenêtre
, pour ajouter la méthode de réponse à ce
menu
maximiserLaFenêtreToolStripMenuItem_Click
;
La propriété que nous allons utiliser est
WindowsState
de l’instance de
污lfenê瑲t=
Main
en cours (renvoyé
e
par
this
). Cette propriété, accessible
en lecture et en écriture obtient ou définit l’état de la fenêtre du formulaire.
=
=
=
=
ie=瑹ée
=
de=ce瑴e=é牯ê物é瓩=e獴s
FormWindowsState
, qui est en réalité une
énumération de
variables
à valeurs
constantes
(
enum
en C#)
;
Les trois valeurs possibles proposées par cette énumération de valeurs
sont
:
Maximized
,
Minimized
et
Normal
(en fait, chacune de ces valeurs
correspond à un entier unique dans la liste des valeurs, mais c’est bien
é汵猠汩獩扬sîe挠cne=énumé牡瑩ên
=
)
:
Typee⁰牯p物é瓩s
Type
enum
Logo d’une
enum
Liste des valeurs
disponibles dans
l’énumération
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
26
sur
91
C’est quoi un Type?
=
䱥i
Type
indique globalement la taille qu’un objet va utiliser en mémoire,
=
污lfançnt=çn=îa=ac揩de爠ê=捥t瑥émç楲eⰠ
e琠瑯u琠捥=èue=捥琠çbàe琠éeut=
晡楲e⸠䌣=et=un=污lgage=fç牴ement=瑹éé⸠Au瑲emen琠d楴Ⱐ瑯us=汥猠çbàe瑳tèue=
îçu猠
a汬ez=u瑩汩獥爠çu=èue=îçu猠a汬ez=捲爠en=䌣Cdç楶en琠aîç楲=un=瑹ée.
=
ie=
獹獴sme= de= 瑹ée猠 C#= 捯méç牴ê=
é物n捩ca汥men琠 de猠
瑹ée猠 îa汥uê
s
=
⡯E=
瑹ée
s
=
楮i物n珨èue
s
⤠
e琠de猠
瑹ée猠狩曩牥êce
s
⸠
ie猠îa物ab汥猠de=瑹ée
=
îa汥l爠
獴s捫cnt
=
d楲e捴ement
=
de猠dçnnées
=
⡣çmme=un=en瑩t爠çu=une=da瑥⤠捡爠汥=
獹獴sme=獡楴iexa捴cmen琠污lta楬汥là=a汬çue爠éçu爠捥猠dçnnée猠⡵n=楮iP2=fa楴=
瑯u橯u牳êP2=çc瑥瑳
=
℩Ⱐ
a汯牳l èue=汥猠îa物ab汥猠de=瑹ée
=
狩曩牥ê捥=stç捫cnt=
汥猠 狩fé牥n捥猠 aux= dçnnées
=
(en gros, l’adresse des données en
mémç楲
攩
Ⱐ捡爠汥l 獹獴sme=ne=獡楳i éa猠né捥s獡楲emen琠污l 瑡楬汥l à=al汯leê=
⡱uel
汥
=
est la taille d’une liste de clients
=
㼩
⸠ie猠瑹ée猠狩fé牥n捥
s
=
獯nt=
éga汥len琠cçn獩擩êé猠捯mme=de猠çb橥às
.
=
=
=
=
C’est quoi une variable
?
=
mçu爠汥猠éu物獴s猬sune⁶a物ab汥le獴sune=
instance d’un type par valeur (type
楮i物n珨èue⤮F BçnⰠ de= mçn= 捯téⰠ 橥à dé獩sne= ⡣潭Ee= 污l é汵la牴ê de猠
développeurs) une variable comme une instance d’un type quelconque,
éa爠îa汥l爠çu=éa爠狩féêen捥=⡶ç楲e=éa爠éç楮ieu爠獩sîçu猠deîez=楮iégêe爠de猠
汩b牡楲楥i ex
楳瑡n瑥= en= 䌫+
=
). Une variable est composée d’un type et
d’un identificateur (aussi dit
nom de la variable
)
:
int
counter;
Assigner une variable, c’est lui donner une valeur
=
en=mémç楲e
Ⱐsç楴=à=獡=
捲瑩tnⰠ sç楴i
ultérieurement lors de l’exécution du programme. Une
variable est donc fondamentalement en lecture/écriture (d’où son
捡牡捴è牥⁶a物ab汥l季x晤崩z
=
int
compteur = 5 ;
compteur = 6;
A la différence d’autres langages du marché,
l’assignation des variables
e獴sçb汩ga瑯楲e=en=䌣C⁁u瑲tmen琠d楴Ⱐîçu猠seîez=né捥獳s楲emen琠déf楮楲=污l
îa汥l爠éa爠dé晡u琠èue⁶a=aîç楲=îç瑲t=îa物ab汥l=汥l捯mé楬a瑥u爠ne=éçuîan琠汥=
dé捩摥爠êçu爠êçu猠
–
=
捥污léî楴i楥ie猠sçgue猠si晦楣i汥
s
=
à=dé瑥c瑥爠êç牳e=
l’exécution
.
=
=
=
=
C’est quoi une
捯n獴sn瑥=
?
=
啮r=捯n獴sn瑥=e獴sune=îa物ab汥l dçn琠污=îa汥lê
=
ne=éeu琠éa猠ê瑲e=捨angée=
汯牳e
=
l’exécution du programme (elle est en lecture uniquement).
=
啮r=捯n獴ante=
汩瑴é牡汥
=
e獴s橵獴e=une=îa汥lê
Ⱐ捯mme=
6
,
12
ou
"Coucou"
;
D’ailleurs, tapez
=
un=éç楮i=橵獴e=aé狨猠la=捯n獴snte=
汩瑴é牡êe
=
"Coucou"
, et
Identificateur
Type
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
27
sur
91
vous obtenez par l’IntelliSense tout ce qu’il est possible de faire sur une
捨a
înee=牡ê瓨牥
s
=
Emag楱ueⰠnçn
=
?⤮
=
=
=
啮r=捯n獴ante=
symbolique est l’assignation d’un nom à une valeur. La
déclaration d’une constante symbolique est réalisée par la ligne suivante
=
W
=
=
const
int
valeurMaximumDuCompteur = 42;
C’est quoi une énumération
?
=
啮r⃩numé牡瑩êns琠unnsemb汥ldeçn獴an瑥猠獹mbç汩èue
s
=
nçmmées⸠
=
Code C#
public
enum
FormWindowState
{
Normal,
Minimized,
Maximized
}
La valeur des constantes de la liste n’étant pas
é狩捩珩eⰠ汥l cçméi污leu爠
a晦e捴e=de猠îa汥l牳êen瑩t牥猠en=捯mmennt=à=M
=
㬠=汥l 捯de=捩
J
de獳u猠e獴s
dçn挠獩m楬a楲e⃠
=
W
=
Code C#
public
enum
FormWindowState
{
Normal
= 0
,
Minimized
= 1
,
Maximized = 2
}
Bon, revenons à nos moutons. En faisant le
double
-
clique
sur l’option
du menu contextuel
Maximiser la fenêtre
, nous venons d’ajouter la
méthode
maximiserLaFenêtreToolStripMenuItem_
Click
, qui est en fait
la méthode de réponse à l’événement
click
du menu co
ntextuel
;
Dans cette méthode, ajoutez
le code pour maximiser la fenêtre en
cours
;
Type
Identificateur
Assignation de la valeur
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
28
sur
91
Code C#
private
void
maximiserLaFenêtreToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Maximise la fenêtre en cours
this
.WindowState =
FormWindowState
.Maximized;
}
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs [Design]
de la zone de travail
;
Faites maintenant un
double
-
clique
sur l’option du menu contextuel
Minimiser la fenêtre
, pour ajouter la méthode de
réponse à ce menu,
dans laquelle vous indiquez que l’état de la fenêtre est minimisé
(
FormWindowState
.Minimized
)
;
Répétez
encore l’opération pour l’option du menu contextuel
Restaurez
la fenêtre
, et indiquez maintenant que l’état de la fenêtre est normal
(
FormWindowState
.
Normal
)
;
Le code de réponse des options du menu contextuel doit être le
suivant
:
Code C#
private
void
quitterLapplicationToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Fermeture du formulaire
this
.Close();
}
private
void
maximiserLaFenêtreToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Maximise la fenêtre en cours
this
.WindowState =
FormWindowState
.Maximized;
}
private
void
restaurerLaFenêtreToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Restaure la fenêtre en cours dans son état normal
this
.WindowState =
FormWindowState
.Normal;
}
private
void
minimiserLaFenêtreToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Minimise la fenêtre en cours
this
.WindowState =
FormWindowState
.Minimized ;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
L’Editeur du coach
C#
se lance, et vous devez voir votre icône dans la zone de notification
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
29
sur
91
en bas à droite de votre écran. Si vous faites maintenant un clic
-
droit
sur votre icône, vous devez voir appa
raître le menu contextuel, que
vous pouvez tester
complètement
. Magnifique, non
?
Un truc sympathique à faire serait
de griser les menus context
uels qui
sont inutiles en fonction du contexte de la fenêtre. Par exemple, le menu
Maximiser la fenêtre
pourrait être
grisé
quand la fenêtre est en état
maximisé.
La propriété que nous allons utiliser est
Enabled
sur chacun des menus
contextuel, en indiquant une valeur booléenne
t
rue
ou
f
alse
, pour
respectivement le rendre actif ou
le griser
;
Où faut
-
il connecter le code
? Si on regarde le besoin fonctionnel, on a
:
le menu
Maximiser la fenêtre
doit être grisé
quand
la fen
être est en état
maximisé
;
Bon, on va faire un peu d’analyse …
=
=
=
L’utilisation de la conjonction
quand
dans l’expression fonctionnelle
indique l’utilisation d’un événement déclencheur
=
㨠
quand
la fenêtre est en
état maximisé (mais depuis quand les
analyste
s
-
programmeurs
doivent
connaître la grammaire française
–
=
瑯u琠fçut=汥l 捡mésⰠ晦晦
=
℩⸠乯ks=a汬çn猠
摯湣
=
u瑩汩獥爠 une= fçn捴楯n= de= 狩êçn獥= à= un= éîénemen琠 ⢫
=
eîen琠
hand汥l
=
묩
=
X
=
=
=
ia=捯nàçn捴楯n=
quand
dans l’expression fonctionnelle est généralement
suivi de l’objet sur lequel l’événement va porter
=
㨠
èuand
=
la fenêtre
est en
état maximisé. L
a
fonction de réponse à l’événement va donc porter sur
la fenêtre en cours (i.e. sur l’objet
Main
)
;
L’auxiliaire de l’expression fonctionnelle est généralement (
dans=汥l 捡s=
de猠éîénemen瑳
) suivi du nom francisé (au sens large) de l’événement
=
㨠
èuand
=
污
=
fenê瑲t
=
e獴s
en état maximisé
.
C’est utile lorsqu’on ne connaît
pas, à priori, le nom de l’événement à utiliser.
=
=
=
俹=faut
J
楬=捯nne捴e爠汥l 捯deⰠdçnc
=
?=䑡a猠nç瑲t=捡猬snçu猠a汬çn猠dçnc=
chercher s’il existe, sur
l’
çb橥à=晥nê瑲e=⢫
=
Form
») un événement co
mme
«
StateMaximized
», ou «
Maximized
», ou encore un autre en relation
avec la dimension de la fenêtre («
Size
» en anglais), car maximiser une
fenêtre revient à en changer la taille
; Et c’est là que nous allons
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
30
sur
91
connecter le code
!
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs [Design]
de la zone de travail
;
Faites un
clic
-
droit
à l’intérieur de la fenêtre (en dehors de tout autre
contrôle, sur la zone grise de la fenêtre par exemple)
et sélect
ionnez le
menu
Propriétés
;
Dans la
barre d’outils de la
fenêtre de
P
r
opriétés
, cliquez le bouton
pour afficher la liste des événements disponibles sur l’objet
Main
;
Pensez à vérifier que vous êtes bien sur le bon objet, dont le nom et le
type s’affiche dans la liste déroulante en haut
;
Dans la liste des événements disponibles, cherchez l’événement qui
pourrait correspondre à notre besoin
; a
idez
-
vous de l’aide succincte de
chaque événement qui apparaît en bas de la fenêtre de propriétés
quand vous faites un simple
clic
sur un événement
; Bon, malgré le
nombre d’événements disponibles, il n’y en a aucun avec «
State
»
-
nous allons donc nous r
abattre sur
SizeChanged
…
Lorsqu’un événement est au prétérit (c'est
J
à
J
d楲e=aîe挠
ed
à la fin), alors il
est déclenché
après
que l’action ait eu lieu. Par exemple,
SizeChang
ed
est déclenché
après
le changement de taille de la fenêtre
, ou encore
FormClosed
est déclenché après la fermeture de la fenêtre
. Si
l’événement est au présent progressif (c'est
J
à
J
d楲e= aîe挠
ing
à la fin),
l’événement est déclenché
en tout début
d’action, et il est généralement
possible d’interagir avec cette action. Par exemp
汥l=
FormClosing
est
déclenché en début de processus de fermeture de la fenêtre et il est
possible d’annuler ce processus en laissant la fenêtre ouverte (ce qui est
pratique si vous avez des données non sauvegardées …)
=
X
=
=
Faites un
double
-
clique
sur l’évén
ement
SizeChanged
dans la fenêtre
de propriétés
;
Vous venez d’ajouter
la
méthode
de prise en charge de
l’événement
Main_SizeChanged
au code de l’application
;
L’idée de cette méthode est de configurer la propriété
Enabled
de chacun
des menus contextuels à vrai (
true
) ou faux (
false
), en fonction de l’état
de==晥nê瑲t.
=
=
Dans la méthode
Main_SizeChanged
,
ajoutez le code
suivant
;
Code C#
private
void
Main_SizeChanged(
object
sender,
EventArgs
e)
{
// Grise les menus
en fonction de l'état de la fenêtre
this
.maximiserLaFenêtreToolStripMenuItem.Enabled =
Liste déroulante
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
31
sur
91
!(
this
.WindowState ==
FormWindowState
.Maximized);
this
.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(
this
.WindowState ==
FormWindowSta
te
.Minimized);
this
.restaurerLaFenêtreToolStripMenuItem.Enabled =
!(
this
.WindowState ==
FormWindowState
.Normal);
}
Le code
this
.WindowState ==
FormWindowState
.Minimized
utili
s
e
l’
çéé牡瑥u爠d
’égalité
==
.
Pour les types valeur
s
, l'opérateur d'égalité
==
retourne
true
si les valeurs des opérandes sont égales et false dans le
cas contraire. Pour les types référence
s
autres que string,
==
retourne
true
si ses deux opérandes font référence
au même
objet. Pour le type
string,
==
comp
are les valeurs des chaînes.
Le code
this
.WindowState ==
FormWindowState
.Minimized
retourne
donc
true
dans le cas où l’état de la fen
êt牥ê e獴s m楮im楳=ja楳i nçus=
a業e物çns=èue=汥l menu=捯n瑥x瑵e氠
Minimiser la fenêtre
soit grisé quand
l’état de la fenêtre est minimisé. Nous allons donc utiliser un autre
çéé牡êeu爬e汵椠leéga瑩tn
=
lçg楱ue.
=
=
=
i❯ééêa瑥u爠 de= néga瑩çn= 汯l楱ue=
!
est un opérateur qui
applique une
négation sur l’opérande
⸠䥬fe獴sdéfin椠éçuê
=
un=çéé牡nde=de=瑹ée
=
bççléen
=
et=
牥瑯u牮e=
true
si, et seulement si
, l'opérande est
false
, et inversement.
Le code
!(
this
.WindowState ==
FormWindowState
.Minimized)
retourne
donc
false
dans le cas où l’état de la fen
être est minimisé, et c’est
橵獴emen琠ce=èue=nçu猠a業e物çn猠af楮ièue=汥lmenu=捯n瑥x瑵e氠
Minimiser
la fenêtre
soit grisé quand l’état de la fenêtre est minimisé. Il nous reste
dçn挠à= a獳楧ne爠污l éêçé物é瓩=
Enabled
du contrôle correspondant avec
cette valeur,
en utilisant l’opérateur d’assignation
=
;
L'opérateur d'assignation
=
stocke la valeur de l'opérande de droite dans
l'emplacement de stockage, la propriété
(
ou l'indexeur
, mais cette notion
est pour plus tard dans le coach)
stipulé par l'opérande de gauche
,
et
retourne la valeur comme résultat.
Les opérandes doivent être de
même type (ou l'opérande de droite doit
être implicitement convertible au type de l'opérande de gauche).
Et voilà, la ligne de code
:
this
.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(
this
.WindowState ==
FormWindowState
.Minimized);
g
rise donc le menu contextuel
Minimiser la fenêtre
quand la fenêtre est
en état minimisé
!
A la différence d’autres langages du marché, en C# l’opérateur
d’assignation
=
est différencié de l’opérateur d’égalité
==
, ce qui réduit
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
32
sur
91
fortement les risques de mauvaise interprétation des expressions.
C# propose un large éventail d'opérateurs. Ces d
erniers sont des
symboles qui spécifient les opérations à effectuer dans une expression.
C# prédéfinit les opérateurs arithmétiques et logiques habituels, ainsi
que de nombreux autres, comme illustré
à l’adresse suivante
=
W
=
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⼶aTN昴Rd⡖E.UM⤮Fséx
=
=
=
Reste maintenant à griser le menu
Restaurez la fenêtre
au lancement
de l’application car la fenêtre est alors dans un état normal
; Pour ce
faire
, nous avons au moins deux moyens
: changer
la valeur par défaut
d
e
la propriété
Enabled
du menu contextuel
Restaurer la fenêtre
, ou
le faire en une ligne de code (bon, on
est là pout
coder
?)
;
Dans le constructeur de
Main
, ajoutez le code pour griser le
menu
contextuel
:
Code C#
public
Main()
{
InitializeComponent();
// Assignation de l'icone de mainNotifyIcon
mainNotifyIcon.Icon = Properties.
Resources
.lan_connected ;
// Griser le menu Restaurer la fenêtre
this
.minimiserLaFenêtreToolStripMenuItem.Enabled =
false
;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
; Testez le tout pour
voir comment cela fonctionne bien.
Good job guy
s
!
2.3
Positionner les contrôles de données
Il s’agit dans cette exercice de positionner sur le formulaire les différents contrôles de
do
nnées que nous allons alimenter pour manipuler les données
.
Mais avant de
déposer les contrôles de données, nous allons
tout d’abord
structurer le formulaire à
l’aide de tableaux.
Si on regarde le document d’analyse fonctionnel, on peut (avec de
l’imagination, certes, mais nous sommes des créatifs
=
⤠ vo楲 une
獴牵捴c牥rde⁴ab汥aux b物qués
:
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
33
sur
91
Le premier tableau contie
nt une colonne et deux lignes
; la première
ligne
de ce tableau contient un
deuxième tableau d’une seule ligne mais avec
瑲t楳
=
捯汯lne献s B牥fⰠtçu琠捥= beau= mçnde= e獴s 業b物èué= éçu爠s瑲t捴c牥ê=
l’interface utilisateur et proposer un ensemble de cellules desti
née猠à=
捯n
tenir les contrôles d’interface
=
⡧物汬e
Ⱐbç楴i=de=瑥x瑥Ⱐ汩be汬éⰠba牲e=de=
naî楧a瑩tnⰠe瑣tF
=
=
=
Pour structurer l’interface, nous allons utiliser le contrôle
TableLayoutPanel
dont l’objectif est de manipuler la disposition des
捯méç獡n瑳te琠de=猠ç牧an楳敲utçma瑩tuemen琠獯u猠fçême=de=瑡b汥lu.
=
=
=
mçu爠êçu琠saîç楲=爠êe=n瑲t汥l
TableLayoutPanel
, voici le lien
:
http://msdn2.microsoft.com/fr
-
fr/library/3a1tbfwd(VS.80).aspx
Déroulement de l’exercice
:
1.
Structurez
le formulaire sous forme de
tableaux
:
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fichier
Main.cs
dans l’
Explorateur de solutions
)
;
Dans la boite à outils, ouvrez l’onglet
Conteneurs
en cliquant sur
qui
précède le n
om de l’onglet
;
Premier tableau,
en rouge
Deuxième tableau,
en violet
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
34
sur
91
Faites un
glisser
-
déplacer
du contrôle
TableLayoutPanel
sur le
formulaire
;
un tableau apparaît à la surface du formulaire
;
Affichez
la fenêtre de propriété du contrôle que vous venez d’insérer
,
dont le nom doit être
tableLayoutPanel1
;
Dans la
fenêtre de propriétés, configure
z
la propriété
Dock
de façon à
ce que le contrôle remplisse toute la surface disponible du formulaire
(
F
ill
).
L’éditeur
de propriété affiche une boite de dialogue de sélection
visuelle des différents choix possibles.
En fait, la mise en forme de base comporte deux fonctions : l'ancrage
(
Anchor
) et le docking (
Dock
). Par exemple, le contrôle
TableLayoutPanel
a u n e p r op r i é t é
An c h o r
q u i e s t u n t y p e é n u mé r é
d o n t l e s v a l e u r s
( qu i p e u v e n t ê t r e t r a i t é e s p a r u n
ou
logique) indique
nt
de
quel(s) bord(s) du contrôle parent le contrôle
TableLayoutPanel
gardera
une distance constante
. Par exemple, en configurant la propriété
Anchor
à
AnchorStyles
.Bottom
, le tableau restera toujours à
la même distance
du bord inférieur du formulaire, lorsque ce dernier sera redimensionné.
Le docking n'est en fait qu'un cas spécial de l'ancrage. La propriété
Dock
décrit à quel bord du contrôle parent un contrôle doit se relier. Il y a le
docking Haut (
Top
), Gauche (
Left
), Droit
(
Right
), Bas
(
Bottom
), ou Plein
(
Fill
). Dans chaque cas, le contrôle est déplacé aussi près que possible
du bord spécifié et dimensionné de manière à remplir ce bord, où il reste
lorsque le parent est redimensionné. Le docking es
t une sorte d’ancrage
aîe挠cne=d楳瑡ncee⁺é牯⁰a爠êaééç牴ê
慵
=
bçêd.
=
=
ie猠deux=é牯ê物é瓩猠
Anchor
et
Dock
possèdent un
éditeur
de propriété
s
visuel.
Dans la fenêtre de propriété
s
du contrôle
tableLayoutPanel1
,
s
électionnez la propriété
Columns
, qui permet de travailler avec la
collection de colonnes et de lignes du tableau
; Un bouton
s’affiche
en face de la propriété afin d’ouvrir l’éditeur de propriété
s
correspondant
;
Point d’ancrage
éçu爠dééla捥爠汥=
捯n瑲t汥l aîe挠污l
獯u
物献
=
pma牴呡g= é牯êç獡nt=
汥猠 a捴楯n猠 汥猠 é汵l=
捯u牡êtes
=
剥oé汩獳sge=de=瑯ut=
l’espace disponible.
=
䍬楱uez= 污l 汩獴s=
dé牯ê污n瑥= éçu爠
a晦楣桥爠êes=ç楸.
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
35
sur
91
Cliquez sur le bouton
pour afficher l’éditeur de propriétés
;
Sélectionnez
la colonne
Column2
, et cliquez le bouton
Supprimer
de
l’éditeur de propriétés ;
Sélectionnez la colonne
Column1
, et indiquez que sa dimension est
automatique
ment calculée
en cliquant
le radio
-
bouton
Redimensionner Automatiquement
;
Dans l
a liste déroulante
Afficher
, sélectionnez le choix
Lignes
;
Pour la première ligne, dont le nom est
Row1
, indiquez une taille de
type
Absolu
et de
35 pixels
;
Pour la deuxième ligne, dont le nom est
Row
2
, indiquez une taille de
type Pourcentage et de
100 %
, afin d’occuper tout l’espace restant
disponible
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
36
sur
91
Cliquez
maintenant le bouton
Ok
afin de fermer la boite de dialogue
Styles de ligne et de colonne
;
Faites un
glisser
-
déplacer
d’un deuxième contrôle
TableLayoutPanel
à l’intérieur de la première ligne du tableau précédemment ajouté
;
Affichez la fenêtre de propriété
s
du contrôle que vous venez d’insérer,
dont le nom doit être
tableLayoutPanel
2
;
Dans la fenêtre de propriétés, co
nfigurez la propriété
Dock
de façon à
ce que le contrôle remplisse toute la surface disponible de la ligne qui
le contient (
Fill
)
;
Sélectionnez le contrôle
tableLayoutPanel2
que vous venez d’insérer
sur la surface du formulaire, et vous devez remarquer u
ne petite flèche
en haut à droite du contrôle
;
Cliquez
sur cette flèche
; Elle
vous propose les
tâches
les plus
courantes à faire sur
ce
contr
ôle
(cela marche pour la plupart des
contrôles .Net 2.0);
Sélectionnez la tâche
Modifier les lignes
et le
s
colonnes…
et la boite
de dialogue
Styles de ligne et de colonne
s’affiche à l’écran. C’est
exactement la même que celle de l’éditeur de propriété
Columns
que
nous venons juste d’utiliser
;
Dans la liste déroulante
Afficher
, sélectionnez
Lignes
;
Dét
ruisez
la ligne
Row2
;
Indiquez
un redimensionnement automatique pour le ligne
Row1
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
37
sur
91
Dans la liste déroulante
Afficher
, sélectionnez
Colonnes
;
Ajoutez une nouvelle colonne an cliquant sur le bouton
Ajouter
;
Indiquez une taille absolue de
350 pixels
pour la colonne
Column1
;
Indiquez une taille absolue de
1
50 pixels
pour la colonne
Column
2
;
Indiquez un redimensionnement automatique pour la colonne
Column
3
;
Cliquez
maintenant le bouton
Ok
afin de fermer la boite de dialogue
Styles de ligne et de
colonne
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
; Testez le tout
pour
vérifier que tout continue de bien fonctionner.
Vous constatez
notamment que les contrôles de tableau n’o
nt aucun impact visuel
(bordure
,
etc.
) sur le formulaire (circulez, il n’y a rien à voir
!).
Visual C# Express est livré avec de nombreux
contrôles. La description
et l’utilisation de chacun d’entre eux est sur le lien suivant
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⼳xdhe礷w⡖E⸸M⤮F獰x
=
=
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
38
sur
91
Pour les développeur
s qui viendraient de Visual Basic 6.0, de la
programmation MFC ou encore de FoxPro, le lient suivant explique les
correspondance
s
entre les anciens contrôles et les contrôles .Net
:
http://msdn2.microsoft.com/fr
-
fr/library/0061wezk(VS.80).aspx
Pour tout ce qui concerne l’utilisation des contrôles, de la boite à outils
ou encore de l’ajout de contrôles ActiveX à une application .Net
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⼳dea獣Me⡖E.UM⤮Fséx
=
=
=
=
b琠enfinⰠun=汩en=éçu爠tçu琠獡îç楲=獵爠污ld楳iç獩瑩潮=de猠cçn瑲ô汥猠dan猠un=
景牭ula楲e= tindçw猬s nç瑡mmen琠 éçu爠éî
楴i爠 de= éa獳e爠 des= heuêe猠 à=
essayer d’aligner deux boutons et une boite de texte
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⽴y2SaMSU⡖E.UM⤮Fséx
=
=
=
㈮
=
A橯à瑥z
=
汥猠捯n瑲t汥猠deçnné
敳
=
W
=
=
=
=
BçnI=nçu猠aîçn猠ma楮瑥nan琠une=獴牵捴u牥êde=瑡b汥lu=aîe挠4=捥汬u汥献=A=
é物ç物Ⱐnçu猠a汬çn猠dçn挠ma楮瑥nan琠aàçute爠4= 捯n瑲t汥猬= un= éa爠捥汬u汥l
E
䍱fd
=
!). En regardant le document d’analyse fonctionnelle (comme quoi,
捥污l獥牴êun=éeu=de=晡楲e=de猠
documents d’analyse), l’interface utilisateur
e獴sc
çméç珩ees=
捯n瑲t汥猠獵楶an瑳
=
W
=
J
=
r
nea牲ee=naî楧a瑩tnI
=
=
J
=
Une grille d’affichage des données,
=
=
J
=
Une boite de texte d’affichage de résultat,
=
=
J
=
啮r汩be汬é
=
X
=
=
=
=
併瑲t=汥=汩be汬é=e琠污lbç楴i=de=瑥x瑥
=
èu椠獯n琠de猠捯n瑲t汥猠de=ba獥=de=tçut=
bçn=çu瑩氠de=déîe汯léement
Ⱐs楳畡氠䌣=bxé牥獳êé牯êçse=deux=捯n瑲t汥l=
de= dçnnée猠 狩êçndan瑳t à= nç猠 be獯楮i
=
㨠 汥l
DataGridView
et le
BindingNavigator
.
C
e son
t ces contrôles
que nous allons utiliser
:
-
Le contrôle
DataGridView
offre un moyen puissant et flexible pour
afficher des données sous forme de tableau. Il est possible
d’étendre le contrôle
DataGridView
afin de générer des
comportements personnalisés. Par exemple, vous pouvez spécifier
par programme vos propres algorithmes de tri, et vous pouvez
créer vos propres types
de cellules
;
Barre de navigation
Grille de données
Libellé
Boite de
texte
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
39
sur
91
-
Le contrôle
BindingNavigator
propose
une
façon
standardisée
pour parcour
ir et manipuler des données sur un formulaire.
C’est
en fait une barre d’outil
s
=
èui=a=é瓩=捯mélé瓩
e
=
éa爠汥猠éèu楰i猠de=
déîe汯léemen琠 de= j楣iç獯f琠 afin= de= gé牥爠 au瑯ma瑩tuemen琠 la=
naî楧a瑩tnans=猠sçnnées
=
X
=
=
=
Pour tout ce qui concerne l’utilisation du contrôle
DataGridView
:
http://msdn2.microsoft.com/fr
-
fr/library/e0ywh3cz(VS.80).aspx
Pour tout ce qui concerne l’utilisation du contrôle
BindingNavigator
:
http://msdn2.microsoft.com/fr
-
fr/library/ms158105(VS.80).aspx
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fichier
Main.cs
dans l’
Explorateur de solutions
)
;
Dans la boite à outils, ouvrez l’onglet
Données
en cliquant sur
qui
précède le nom de l’ongl
et
;
Faites un
glisser
-
déplacer
du contrôle
DataGridView
sur le formulaire,
dans la plus grande cellule du tableau (la dernière)
; une grille (vide
bien sûr) apparaît à la surface du formulaire
;
Faites un
glisser
-
déplacer
du contrôle
BindingNavigator
sur le
formulaire, dans la première cellule du tableau ;
Dans la boite à outils, ouvrez l’onglet
Contrôles communs
en cliquant
sur
qui précède le nom de l’onglet
;
Faites un
glisser
-
déplacer
du contrôle
Label
sur le formulaire, dans la
deuxième
cellule du tableau ;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
40
sur
91
Enfin, faites un
glisser
-
déplacer
du contrôle
TextBox
sur le formulaire,
dans la troisième cellule du tableau
; Vous obtenez un formulaire
comme ci
-
dessous
. I
l reste maintenant à personnaliser les propriétés
de chacun des con
trôles
;
Appuyez
sur la touche
Shift
et maintenez la enfoncée
;
Avec la souris, faites un
clic
sur chacun des quatre contrôles que vous
venez d’ajouter, tout en maintenant la touche
Shift
appuyée, afin de
faire une sélection multiple de contrôle
s
;
L
âchez
maintenant la touche
Shift
;
Affichez la fenêtre de propriété
s
de la sélection, qui vous propose
toutes les propriétés communes des contrôles de votre sélection
;
Dans la fenêtre de propriétés, configurez la propriété
Dock
de façon à
ce que le
s
cont
rôle
s
remplisse
nt
toute la surface disponible
de la cellule
dans lesquels ils sont
(
F
ill
)
;
Sélectionnez
maintenant uniquement la g
r
ille de données
dataGrigView1
(désélectionnez l’ensemble des contrôles en cliquant
sur la barre de titre du formulaire, par exemple, puis cliquez sur la grille
pour la sélectionner)
;
Dans la fenêtre de
Propriétés
, configurez le nom du contrôle en
changeant la propriété
(Name)
avec
ma
inDataGridView
(avec C#,
attention à la casse des noms
!)
;
Sélectionnez
maintenant uniquement la barre d’outils de navigation
bindingNavigator1
;
Dans la fenêtre de
Propriétés
, configurez le nom du contrôle en
changeant la propriété
(Name)
avec
mainBindi
ngNavigator
;
Ensuite, s
électionnez
uniquement le libellé
label1
;
Dans la fenêtre de
Propriétés
, configurez le nom de ce contrôle en
changeant la propriété
(Name)
avec
lblOperation
;
Dans la fenêtre de
Propriétés
, configurez la façon dont le texte va être
positionné dans le libellé, en changeant la propriété
TextAlign
avec
MiddleRight
(a
lignement du contenu à droite du libellé, avec un
centrage vertical)
;
Utilisez au besoin l’éditeur de propriété
s
proposé en
cliquant sur la liste déroulante de la propriété
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
41
sur
91
Toujours dans la fenêtre de
Propriétés
, configurez le texte à afficher
en changeant la propriété
Text
avec
Total :
;
Pour finir, s
électionnez
uniquement la boite de texte
TextBox1
;
Dans la fenêtre de
Propriétés
, configurez le nom de ce contrôle en
changeant la propriété
(Name)
avec
txtOperation
;
Enfin, dans la fenêtre de
Propriétés
, indiquez que cette boite de texte
va être en lecture uniqueme
nt, en changeant la propriété
ReadOnly
avec
True
(
valeur booléenne Vrai)
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
; Testez le tout pour
vérifier que tout fonctionne encore bien.
La fenêtre suivante apparaît
:
Aucune donnée n’est affichée, mais tout fonctionne correctement.
C’est
super (surtout si vous n’avez aucun
bogue de compilation à résoudre).
2.4
Localiser l’application
L’objectif de cet exercice est de rendre disponible l’interface utilisateur de
l’application dans une autre langue que le français, par exemple l’anglais.
Liste déroulante
Valeur à sélectionner
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
42
sur
91
Si vous envisagez de distribuer votre
application à un public international,
vous devrez garder à l'esprit certaines considérations lors des phases de
design et de développement. Et, même si vous ne pensez pas
immédiatement distribuer votre application à un public international, de
simples pré
paratifs pourront vous faciliter considérablement la tâche dans
l'éventualité où les versions ultérieures de votre application aient des
objectifs différents
.
La localisation est le processus de personnalisation de votre application
pour une culture ou
des paramètres régionaux donnés. La localisation
consiste principalement à traduire l'interface utilisateur.
La globalisation est le processus de conception et de développement d'un
produit logiciel adapté à plusieurs cultures.
Pour tout savoir
sur la localisation et la globalisation
:
http://msdn2.microsoft.com/fr
-
fr/library/1021kkz0(VS.80).aspx
C’est quoi une ressource
=
?
=
Lorsque vous localisez une application, l’
en獥mb汥l de猠
dçnnées
=
汯捡汩珩e猬
=
捯mme= de猠 捨aîne猠 e琠 de猠 image猠 èui
=
獯n琠 adaé瓩e猠 à=
捨aèue=捵汴u牥ê
=
獯n琠s瑯捫ces
=
aîe挠s楳畡氠C#=bxé牥獳
=
dan猠de猠fi捨楥牳i
珩éa狩ê
=
d’extension
.resx
;
Ces différentes données qui vont être
chargées au moment de l’exécution
en= 景n捴楯n= de= la= 捵汴l牥= 獯nt=
appelées les ressources de l’application.
=
=
=
䑡a猠s楳畡氠p瑵d楯i=汥猠牥獳êu牣敳ê汯捡汩珩e猠⡤E猠dçnnée猠捯mme=des=
捨aîne猠e琠des=業ages=èu椠獯nt=adaé瓩es=à=chaèue=cu汴l牥⤠sçnt=獴s捫ces=
dan猠de猠f楣桩i牳ê珩éa狩猠e琠捨a牧ée猠en=fçn捴楯n=de=污l 捯nf楧u牡ê楯i=de=
污l 捵汴l牥ê de= 氧楮ie牦ê捥= u瑩汩獡teu爮ê mçu
ê= 捯mé牥êd牥= 捯mmen琠 汥l=
牥獳êu牣敳ê 獯n琠 捨a牧ée猬s 業ag楮iz= èu❥汬e猠 獯n琠 ç牧an楳猠 sçu猠 污=
景牭e❵ne=h槩牡牣桩ê.=
=
J
=
bn= haut= de= 污l hié牡牣桩ê= 獥= 瑲tuîen琠le猠牥獳su牣敳ê éa爠défau琬=
挧c獴
J
à
J
d楲e=捥汬e猠捯牲e獰çndan琠à=污l污lgue=de=déîe汯lé
emen琠de=
l’applic
a瑩tn⸠ 䑡a猠 nç瑲t
=
cas, il s’agit du français. Ce sont les
獥u汥猠牥獳êu牣敳êèu椠n❯n琠éa猠汥l爠é牯ê牥êfi捨楥爮i=Au=mçmen琠de=
la compilation, elles sont stockées dans l’assemblage principal
=
de=
l’application
=
⡰E爠êxemé汥l
nom.exe
)
;
-
Sous ces ressources par
défaut se trouvent les ressources des
cultures neutres. Une culture neutre est associée à une langue,
mais pas à une région. Par exemple, Français («
fr
») ou l’anglais
⢫
=
敮
=
»⤠獯n琠de猠捵汴u牥
s
=
neu瑲t
s
.
=
iç牳ê de= 污l 捯mé楬a瑩tnⰠe汬es=
獯n琠獴ç捫ce猠dan猠un
=
a獳smb污le=sa瑥汬楴i
=
汵l
J
même=
s瑯捫c=dans=
un=獯u猠狩ée牴ç楲e=
ayan琠un
=
nçm=狩fé牥nnt
=
污l捵汴l牥êneu瑲t=⡰a爠
exemé汥l
fr
)
;
-
En dessous de ces ressources de cultures neutres se trouvent les
ressources des cultures spécifiques. Une culture spécifique est
ass
ociée à une langue et à une région. Par exemple, Français
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
43
sur
91
(Canada) ("fr
-
CA") est une culture spécifique
. Lors de la
compilation, elles sont stockées dans un assemblage satellite
lui
-
même
stockée
dans un sous répertoire ayant un nom référençant
la culture s
pécifique (par exemple
fr
-
CH
)
;
Si une application essaie de charger une ressource localisée, telle qu'une
chaîne, et ne la trouve pas, elle remontera dans la hiérarchie jusqu'à ce
qu'elle trouve un fichier de ressources contenant la
ressource demandée.
Déroulement de l’exercice
:
1.
Configurez la localisation de votre formulaire
:
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fi
chier
Main.cs
dans l’
Explorateur de solutions
)
;
Dans la fenêtre de
Propriétés
du formulaire
Main
, indiquez que ce
dernier supporte la localisation en configurant la propriété
Localizable
à
T
rue
(V
rai)
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
2.
Localisez votre application en anglais
:
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fichier
Main.cs
dans l’
Explorateur de solutions
)
;
Dans la fenêtre de
Propriétés
du formulaire
Main
, indiquez que ce
dernier est maintenant affiché par le designer Visual C# Express en
localisation Ang
lais (Etats
-
Unis), en configurant la propriété
L
anguage
à
Anglais (Etats
-
Unis)
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
44
sur
91
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Affichez maintenant
l’
Explorateur de solutions
; Un nouveau
fichier
Main.en
-
US.resx
a été ajouté à la solution, en dépendance de
Main.cs
;
Ce fichier contient les ressources de l’application pour la
nouvelle langue ajoutée
;
Revenez sur le formulaire
Main.cs
en mode
[Design]
;
Pour chacun des contrôles (formulaire, libellé, menus, etc.), changez la
propriété
Text
par un contenu en Anglais
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Vis
ual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
; L’application
fonctionne (normalement) mais est toujours en français
! C’est normal,
votre poste étant configuré avec un système d’exploitation français, la
culture q
ui est lu est donc celle par défaut.
3.
Définissez la culture de l’interface utilisateur
:
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
, et en sélectionnant le menu
Afficher le code
;
Dans le constructeur de la fenêtre
Main.cs
,
ajoutez le code
pour
changer la culture du processus exécutant l’application
;
Code C#
public
Main()
{
// Configure la culture à Anglais (Etats
-
Unis)
System.Threading.
Thread
.CurrentThread.CurrentCulture
=
new
System.Globalization.
CultureInfo
(
"en
-
US"
);
// Configure la culture de l'interface à Anglais (Etats
-
Unis)
System.Threading.
Thread
.CurrentThread.CurrentUICulture =
new
System.Globalization.
CultureInfo
(
"en
-
US"
);
InitializeComponent();
// Assignation de l'icone de mainNotifyIcon
mainNotifyIcon.Icon = Properties.
Resources
.lan_connected ;
// Griser le menu Restaurer la fenêtre
this
.minimiserLaFenêtreToolStripMenuItem.Enabled =
false
;
}
Pensez à configurer la culture d’exécution avant l’appel à
InitializeComponent()
; en effet, cette méthode va configurer les
différents contrôles du formulaire, dont leur
s
propriété
s
T
ext
, et donc elle
va charger les ressources dont elle a besoin ; si la c
ulture du processus
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
45
sur
91
est configuré
e
après l’appel de cette méthode, ce sera trop tard car les
fichiers de ressources auront déjà été lus …
=
=
=
C’est quoi CultureInfo
=
?
=
ia=捬慳ce=
CultureInfo
rend des informations spécifiques à une culture,
par exemple la lan
gue, la sous
-
langue, le pays et/ou la région ou le
calendrier associés à la culture, ainsi que les conventions applicables à
cette dernière.
Elle spécifie un nom unique pour chaque culture, basé sur
la norme RFC 3066 pour Windows Vista et les versions ulté
rieures, et sur
la norme RFC 1766 pour les systèmes d'exploitation antérieurs à
Windows Vista. Le nom est une combinaison d'un code de culture à deux
lettres minuscules ISO 639 associé à une langue et d'un code de sous
-
culture à deux lettres majuscules ISO
3166 associé à un pays ou une
région. Le format du nom de culture est <languagecode2>
-
<country/regioncode2>, où <languagecode2> est le code de langue et
<country/regioncode2> est le code de sous
-
culture.
Pour tout savoir sur la classe
CultureInfo
,
notamment les codes de
chacune des cultures disponibles
:
http://msdn2.microsoft.com/fr
-
fr/library/kx54z3k7(VS.80).aspx
Quelle est la différence entre
CurrentThread.CurrentC
ulture
et
CurrentThread.CurrentUICulture
?
-
CurrentCulture
o
btient ou définit la culture du thread en cours
,
c'est
-
à
-
dire la façon dont l’application va traiter en interne le format
de猠 nçmbêes
Ⱐ
de猠 da瑥s
=
çu= de= 捨a楮e猠 de= 捡牡捴è牥猠 éaê=
exemé汥
=
X
=
J
=
CurrentUIC
ulture
o
btient ou définit la culture actuelle utilisée
par
le g
estionnaire de ressources
pour rechercher des ressources
spécifiques à la culture au moment de l'exécution
;
C’est
=
pour cette raison qu’il faut changer les deux propriétés dans l
e
=
捯de.
=
=
=
mçu爠 瑯u琠 saîç楲= 獵爠 污l 捬慳獥=
Thread
, qui fournit plein de
renseignement
s
sur le processus en cours notamment au travers de la
propriété
Thread
.CurrentThread
:
http://msdn2.micr
osoft.com/fr
-
fr/library/h158zycw(VS.80).aspx
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application
en mode de débogage
; L’application
fonctionne maintenant en anglais
;
Allez voir dans le répertoire de compilation de l’application (par exemple
C:
\
Coach C#
\
Atelier 02
\
Code
\
Coach.Editeur
\
Coach.Editeur
\
bin
\
Debug
), et
vous verrez que le compilateur a généré automatiquement un sous
répertoire contenant l’assemblage satellite des ressources en anglais.
Lors de la distribution de l’application, il faudra penser à distribuer
l’assemblage principal, mais aussi tous ses
=
a獳smb污le猠獡te汬楴i猠de=
A獳smb污le=
獡瑥汬楴i= de=
汯捡汩獡瑩tn
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
46
sur
91
localisation.
Pour tout savoir sur la classe la gestion des ressources dans les
application Windows
:
http://msdn2.microsoft.com/fr
-
fr/library/f45fce5x(VS.80).aspx
Pour les traducteurs qui localise
nt
les applications, il existe un
outil
spécifique dans le SDK de .Net 2.0
:
Winres.exe
.
Winres.exe
est une
application graphique qui recrée une version
en mode WYSIWYG
d'un
formulaire Windows simplement à partir du fichier de ressources, sans
devoir accéder au code source.
Winres.exe
héberge le c
oncepteur de
formulaires Windows
et
s
a fenêtre Propriétés. Ces fonctionnalités
permettent une modification visuelle d'un fichier
.resources
ou
.resx
contenant un formulaire Windows Forms.
Pour tout savoir sur
Winres.exe
:
http://msdn2.microsoft.com/fr
-
fr/library/8bxdx003(VS.80).aspx
Pour télécharger le SDK .Net 2.0
:
http://www.microsoft.com/downloads/details.aspx?FamilyID=fe6f2099
-
b7b4
-
4f47
-
a244
-
c96d69c35dec&displaylang=fr
Les développeurs utilisent généralement aussi des ressources
directement codées «
en dur
» d
ans
le code, comme par exemple l
es
chaines de caractères de messages.
La création et l'utilisation de fichiers
de ressources
pour ces chaînes de caractères est
une tâche plutôt
délicate
, si elle est réalisée à la fin de la programmation car elle nécessite
une
relecture complète du code
.
Il existe un outil,
l
e
Resource
Refactoring Tool
, qui
peut aider à résoudre ce problème
.
Pour télécharger le
l
e
Resource Refactoring Tool
,
:
http://visualstudiogallery.msdn.microsoft.com/39ae29d3
-
81e1
-
43d4
-
9c48
-
fc9644869d84
4.
Configurez de nouveau la culture de l’interface utilisateur en français
:
Sous répertoire de
culture contenant la
localisation pour une
culture donnée
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
47
sur
91
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
, et en sélectionnant le menu
Afficher le code
;
Dans le constructeur de la fenêtre
Main.cs
,
mettez en commentaire
le
code pour changer la culture du processus exécutant l’application
;
Code C#
public
Main()
{
// Configure la culture à Anglais (Etats
-
Unis)
//
System.Threading.Thread.CurrentThread.CurrentCulture =
//
new
System.Globalization.CultureInfo("fr
-
FR");
// Configure la culture de l'interface à Anglais (Etats
-
Unis)
//
System.Threading.Thread.CurrentThread.CurrentUICulture =
//
new System.Globalization.CultureInfo("fr
-
FR");
InitializeComponent();
// Assignation de l'icone de mainNotifyIcon
mainNotifyIcon.Icon = Properties.
Resources
.lan_connected ;
// Griser le menu Restaurer la fenêtre
this
.minimiserLaFenêtreToolStripMenuItem.Enabled =
false
;
}
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fichier
Main.cs
dans l’
Explorateur de solutions
)
;
Dans la fenêtre de
Propriétés
du formulaire
Main
, indiquez que ce
dernier est maintenant affiché par le designer Visual C# Express en
localisation par
défaut
, en configurant la propriété
L
anguage
à
(Par
défaut)
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modif
ications réalisées
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
; L’application
fonctionne maintenant en français, qui est not
r
e langue par défaut
;
Félicitations, vous venez de
passer un
e première étape importante du
C
oach
C#
(nous venons de finaliser l’essentiel de l’interface utilisateur que
nous allons utiliser tout au long des différents ateliers)
, et il nous reste
maintenant à alimenter cet écran avec des données.
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
48
sur
91
3
Alimenter
la grille avec le contenu d’un fichier CSV
Dans cet exercice, vous allez apprendre à
:
-
L
ire un fichier au format CSV (Texte délimité)
;
-
U
tiliser les principales boucles du langage C#
;
-
A
limenter les contrôles de données avec les informations lues
;
Objectif
L’objectif de cet exercice est de
manipuler des données au format CSV, tout en
abordant la structuration d’un programme et les ordres de boucles et de tests du
langage C#
.
Contexte fonctionnel
Nous allons implémenter un accès aux données
à l’anci
enne
, c'est
-
à
-
dire que nous
allons
utiliser d
es données
stockées
au format CSV, en les transformant (pour
faciliter l’alimentation de la grille de donnée
s) en un objet table en mémoire. Bon,
c’est pas exactement ce qu’il faudrait faire de nos jours
(c’est
beaucoup de lignes de
code pour pas grand chose)
, mais cela va nous aider dans notre démarche
progressive de découverte de C#
Le fichier de données que
nous allons utiliser est le fichier
Clients.c
oach
situé dans
les fichiers utile
s
de l’exercice
Il est
possible de l’ouvrir avec le bloc
-
notes de
Windows, car c’est juste un fichier au format texte.
Le principe
à implémenter est le suivant
Let’s go
, folks
!
Le Framework .Net propose en standard de nombreuses classe
s
à utiliser
dans vos développement
s
. Ces classes sont regroupées en
espaces de
nom
mage
(
Namespace
, cf.
ci
-
dessous). Nous allons donc créer un objet
de type
DataTable
, qui représente une table de données, se trouvant
dans l’espace de nommage
System.Data
.
C’est quoi un
espace de nommage
(
Namespace
)
?
Les espaces de nommages aident à organiser logiquement et clairement
les types et autres membres fournis par le Framework .Net (notamment),
ou par tout autre application et/ou assemblage .Net, et ce
indépenda
mment
du nom
de l’assemblage
=
.net
=
景u牮楳獡n琠捥猠瑹ée猠çu=
捥猠
memb牥ê
⸠ 䍥éendan琬= 獯uîen琠 汥猠 nçms= de猠 a獳smb污ge猠 du=
Framework .Net réfèrent à l’espace de nommage princi
éa汥men琠en物捨楥=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
49
sur
91
par l’assemblage
=
W=éaê=exemé汥l
system.xml.dll
enrichie principaleme
nt
l’espace de nom
System.Xml
(manipulation de données XML), mais pas
seulement
.
L
’espace de nommage
System.Data
contient tous les types
requis pour manipuler des données
; De la même manière,
System.Configuration
contient tous les types pour gérer la configuration
d’une application. Nous reviendrons durant le troisième atelier sur
l’organisation des espaces de nommages.
=
=
=
C’est quoi une
DataTable
?
Une
DataTable
r
eprésente une table de données en mémoire.
C’est
exactement ce que l’on souhaite faire
=
℠⡬ea獡牤a楴楥i=汥猠chçse猩⸠ia=
structure globale d’une
DataTable
est la suivante
:
-
La propriété
Columns
réfère à
la collection des colonnes qui
appartiennent à
la
table
; les objets de cette collection sont de type
DataColumn
;
-
La propriété Rows
réfère
à la collection des lignes qui
appartiennent à cette table
; les objets de cette collection sont de
type
DataRow
;
Autrement dit, nous allons définir la structure de la t
able en mémoire en
utilisant la collection
Columns
, puis nous manipulerons les données à
l’aide de la collection
Rows
.
Pour tout savoir sur l’espace de nom
System.Data
:
http://msdn2.microsoft.com/fr
-
fr/library/ax3wd0k9(VS.80).aspx
Pour tout savoir sur des
DataTable
:
http://msdn2.microsoft.com/fr
-
fr/library/9186hy08(VS.80).aspx
3.1
Créer
et utiliser la table en mémoire
Dans ce premier exercice
, vous allez développer le code pour créer une table vide en
mémoire, et connecter cette table vide aux contrôles de données présents sur le
formulaire.
La structure de la table à créer, dont le nom v
a être
Coach
, est
composée de douze champ
s
dont la description est la suivante
:
Nom
Description
Type
Id
Code d’indentification du client
=
獴物ng
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
50
sur
91
Entreprise
Raison sociale de l’entreprise
=
獴物ng
=
䍯C瑡捴
=
乯ku=n瑡c琠é物n捩ca氠lu汩=nt
=
獴物ng
=
q楴牥
=
䙯n捴楯nu=n瑡捴cé物n捩灡氠lu汩敮t
=
獴物ng
=
Ad牥獳ê
=
Adresse de l’entreprise
=
獴物ng
=
s楬汥
=
Ville de résidence de l’entreprise
=
獴物ng
=
剥o楯i
=
Région de résidence de l’entreprise
=
獴物ng
=
䍯Cemç獴sl
=
䍯Ce=éç獴sl
=
du=bu牥au⁰ç獴a氠l楳瑲ibuteuê
=
獴物ng
=
mays
=
Pays de résidence de l’entreprise
=
獴物ng
=
qe汥éhçne
=
Numéro de téléphone du standard de l’entreprise
=
獴物ng
=
q
e汥lçé楥
=
Numéro de la télécopie principale de l’entreprise
=
獴物ng
=
䍁
=
Chiffre d’affaire arrondi, en millier d’euros, que vous
狩ê汩獥zîe挠捥瑴e
nt牥ê物獥
=
楮i
=
=
BçnⰠéçu爠汥猠éu物獴s猠de=污l瑲t楳ième=fçême=nç牭a汥l=c
e n’
’est pas très intègre, mais
cela devrait suffire pour notre besoin.
Pour ceux qui souhaite comprendre la troisième forme normale
:
http://msdn2.microsoft.com/fr
-
fr/library/aa200276(office.11).aspx
Déroulement de l’exercice
:
1.
Créez une
fonction
de création d’une table vide
:
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
, et en sélectionnant le menu
Afficher le code
;
Positionnez
le curseur juste après l’accolade
}
fermante du constructeur
de la classe
Main
;
Ajoute
z deux lignes vides
en tapant sur la touche
Entrée
;
Créez une fonction
CreerTable
en ajoutant le code suivant
:
Code C#
private
DataTable
CreerTable()
{
}
C’est quoi une fonction
=
?
=
啮r= fçnc瑩tn=
en捡é獵汥l une= 珩èuence= de=
捯de= défin楳獡n琠 un=
捯méç牴êmen琠 de= 污l 捬慳獥Ⱐ e琠 en= 牥êçu牮an琠 une= îa汥lê
⽲L曩牥n捥
=
de=
牥瑯u爮
=
=
=
=
䍥C瑥=景nc瑩tn=
CreerTable
renvoi
e
une valeur de type
DataTable
, et
est
indiqué
e
privé
e
(
private
) car elle ne sera utilisé
e
que dans le cadre de la
classe
M
ain
;
l’objectif de cette fonction est donc de créer une nouvelle
table et d’en retourner la
狩fé牥n捥
.
=
=
=
啮r= bçnne= é牡瑩tue= éçu爠 éî楴i爠 汥猠 bçgue猠 e獴s de= 獹獴sma瑩tuement=
獡uîega牤ê爠îç瑲t=瑲t癡楬=e琠de=污n捥爠une=捯mé楬a瑩tn=à=捨aèue=fçi猠èue=
vous travaillez sur la structure d’une classe, ou encore, à chaque fois que
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
51
sur
91
vous ajoutez un bloc de code dans le cont
enu d’un membre de classe
=
!
=
=
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Une erreur de
compilation est affichée dans la
Liste
d’erreurs
;
Si la fenêtre
Liste d’erreurs
ne s’affiche pas, sélectionnez le menu de
s楳畡氠䌣lbxé牥獳
Affichage >
Liste d’erreurs
;
Pour compiler l’application, il est aussi possible de sélectionner le menu
de⁖楳ia氠䌣lbxé牥獳ê
Générer > Générer la solution
;
Pour compiler l’application, il est encore possible de faire un
clic
-
droit
sur
le projet
Coach.Editeur
dans
l’
Explorateur de solutions
et de
sélectionner le menu
Générer
;
Pour localiser une erreur dans le code, c’est simple
=
: c’est le(s) mot(s) qui
aééa牡ê琨獳tn琩n=ul楧né=
…
=
=
=
mçu爠a汬e爠獵爠污l 汩gne=de=捯de=ayan琠généêé=une=e牲eu爠dan猠污l
Liste
d’erreurs
, c’est simple
=
㨠fa楴e猠snçub汥
J
捬cèue
=
sur l’erreur de la liste ...
=
=
=
Elle vient d’où cette erreur
=
㼠
=
bn=fa楴i 汥l 捯mé楬ateuê=ana汹獥=捨a捵n=de猠memb牥猠de=污l 捬慳獥=e琠îa=
ma牱ue爠tçute猠汥猠景n捴楯n猠èu
i
=
ne=牥瑯u牮en琠au捵ne=îa汥l爠a獳楧néeⰠ
îç楲e=èu椠ne=牥瑯u牮ê=ê楥i=du=瑯ut
=
! Cela évite d’avoir des bouts de code
pour lesquels le développeur à oublié d’indiquer la valeur de retour. Le
compilateur va d’ailleurs aussi marque
爠汥猠捯de猠èu椠ne=se牯ê琠àama楳=
exécuté (si, si cela arrive souvent d’ailleurs) en analysant les chemins
possibles pour parcourir le code à l’exécution.
=
=
䵯琠獯u汩gné=en=e牲euê
=
Message de l’erreur, en positionnant
le curseur sur l’erreur
=
Erreur dans la liste des erreurs
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
52
sur
91
Dans notre cas,
pour corriger l’erreur
楬au琠dçn挠c橯àte爠êe=dee=牥êîç椠
de==景nc瑩tn.
=
=
=
啮r=狨ê汥l de=bçnne=é牯ê牡êma瑩tn=es琠de=獹獴sma瑩tuemen琠a橯u瑥爠汥=
捯de=de=牥nîç椠de=景n捴楯n=aîe挠污l捲ca瑩tn=de=污l景n捴cçn⸠mçu爠ma=éa牴ê=
j’utilise toujours une variable nommée
result
.
A
j
outez à la fonction
CreerTable
les lignes de création d’une nou
velle
table de nom
Coach
, et de retour de cette nouvelle table
;
Code C#
private
DataTable
CreerTable()
{
// Création d'une table vide avec le nom Coach
DataTable
result =
new
DataTable
(
"Coach"
);
// retour de la valeur
return
result;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout se
compile correctement maintenant.
Nous allons maintenant créer une colonne
pour chacune de
s colonnes à
ajouter à la table
en précisant le type, et l’ajouter à la liste des colonnes
de= 污= 瑡b汥l=ie=瑹ée=èue= nçu猠a汬çn猠u瑩汩獥爠éçu爠捲爠污= 捯汯nne=e獴=
DataColumn
;
A
j
outez à la fonction
CreerTable
les lignes de création d’une n
ouvelle
colonne, juste avant la directive
return
;
Code C#
private
DataTable
CreerTable()
{
…
// Création de la colonne ID
DataColumn
idColumn =
new
DataColumn
();
…
}
Définissez maintenant le nom et le type de cette colonne, en
ajoutant
les lignes suivantes juste après la création de la colonne
;
Code C#
private
DataTable
CreerTable()
{
…
// Création de la colonne ID
DataColumn
idColumn =
new
DataColumn
();
idColumn.ColumnName =
"Id"
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
53
sur
91
idColumn.DataType =
typeof
(
string
);
…
}
Pensez à utiliser l’IntelliSense pour aller plus vite dans le codage.
=
=
=
C’est quoi
typeof
?
L’opérateur
typeof
est utilisé pour obtenir l’
çb橥à=捯牲e獰çndan琠à⁵n
=
瑹ée⸠
bn=晡楴Ⱐ污=é牯ê物été=
DataType
doit référencer une instance de
quelque
chose
qui définisse le type, mais pas le type en lui
-
même qui n’est pas
une= 楮獴an捥
I
=
mais juste le type de l’instance
. C’est pour cela qu’en
éa獳sn琠éa爠
typeof
(string)
, on obtient directement l’objet correspondant
au=瑹ée=
string
. Cqfd
bonⰠ獯uvenez vou猠que 獩svou猠ave稠un 瑹pe à
indiquer en paramètre d’une fonction, utiliser l’opérateur
typeof
…
=
=
=
Pour tout savoir sur l’opérateur
typeof
:
http://msdn2.microsoft.com/fr
-
fr/library/58918ffs(VS.80).aspx
Pour tout savoir sur les autres opérateurs par mot clé de C#
:
http://msdn2.microsoft.com/fr
-
fr/library/bewds7kc(VS.80).aspx
Ajoutez maintenant la colonne nouvellement créée
idColumn
à la liste
des colonnes de la table
result
, en ajoutant les lignes suivantes
;
Code C#
private
DataTable
CreerTable()
{
…
// Création de la colonne ID
DataColumn
idColumn =
new
DataColumn
();
idColumn.ColumnName =
"Id"
;
idColumn.DataType =
typeof
(
string
);
result.Columns.Add(idColumn);
…
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout se
compile correctement.
Bon, on a du taper quatre lignes de code et une ligne de commentaire
juste pour créer une colonne, ainsi que créer une variable par référence
qui n’est utilisée que pour faire un ajout à la liste. Avec C#, il est possible
de créer une nouvelle instance d’o
bjet en utilisant l’opérateur
new
à tout
endroit où le code attend une instance. C’est d’ailleurs pour cette raison
que les types d’objets proposent généralement différents constructeurs
af楮i de= 晡捩c楴i爠 污l cçn獴牵捴楯n= de猠 楮獴ance献s A楮獩= nçs= èua瑲t= 汩g
nes=
peuvent être remplacées par une seule (ce que je préfère d’ailleurs).
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
54
sur
91
Dans la fonction
CreerTable
, remplacez
les quatre lignes de création
de la colonne
idColumn
par la ligne suivante
;
Code C#
private
DataTable
CreerTable()
{
…
//
Création de la colonne ID
DataColumn
idColumn =
new
DataColumn
();
idColumn.ColumnName =
"Id"
;
idColumn.DataType =
typeof
(
string
);
result.Columns.Add(idColumn);
result.Columns.Add(
new
DataColumn
(
"Id"
,
typeof
(
string
)));
…
}
Dans la fonction
CreerTable
, ajoutez
maintenant
le code de création
des onze autres colonnes
;
Code C#
private
DataTable
CreerTable()
{
…
// Création de la colonne ID
result.Columns.Add(
new
DataColumn
(
"Id"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Entreprise"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Contact"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Titre"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Adresse"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Ville"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Region"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"CodePostal"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Pays"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Telephone"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"Telecopie"
,
typeof
(
string
)));
result.Columns.Add(
new
DataColumn
(
"CA"
,
typeof
(
int
)));
…
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compile
r
correctement.
2.
Liez la table aux contrôles de données
:
L’idée est de lier la table nouvellement créée aux différents contrôles de
données du formulaire lorsque l’utilisateur va cliquer sur le menu
Fichier
> Nouveau
de l’
Editeur du Coach C#
; La liaison des données aux
contrôle
s
est ce que l’on appelle le
DataBinding
.
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
55
sur
91
C’est quoi le DataBinding
=
?
=
䱥i
䑡aaB楮i楮i
=
e獴sle=mé捡n楳ie=éa爠汥lue氠污lîa汥l爠⡤Ennée=
J
=
…
=
da瑡
=
»F=
d’une propriété d’un contrôle est automatiquement maintenue à jour (liée
–
=
…
=
b楮i楮i
=
») à la valeur d’une propriété d’un objet fournissan
琠 des=
dçnnées=⢫
=
da瑡sçu牣e
=
»⤮
=
L’originalité du DataBinding est que n’importe
èue氠çb橥à=éeu琠景uên楲=une=çu=de猠dçnnéesI=e琠楬=e獴sdçnc
=
éa爠exeméle
=
éç獳楢汥Ⱐaîe挠汥l 䑡aaB楮i楮i
I
=
de=汩e爠autçma瑩tuemen琠污l îa汥l爠de=污l
é牯ê物é瓩=
Text
ou
Tag
d’un bouton a
îe挠污l é牯ê物é瓩=
Text
d’une boite de
瑥x瑥
TextBox
).
Comment ça marche, le
DataBinding
?
Le fonctionnement du
DataBinding
peut être schématisé comme suit
:
Un objet intervient comme un gestionnaire de liaison, et il va
automatiquement refléter et maintenir à jour les valeurs des propriétés qui
sont préalablement définies comme étant en liaison. Dans notre cas,
nous allons utiliser un objet
BindingSource
pour accéder au gest
ionnaire
de liaisons et gérer la
source de toutes les liaisons (
B
indings
) dont nous
allons avoir besoin.
Vous trouverez
sur
ce lien une vidéo d’introduction au DataBinding
=
W
=
h瑴éW⼯睷w楣iç獯f琮cçmLfêan捥⽶楳içnLtebca獴䵳摮.a獰x?b䥄fTVT2bUbd
J
R2MU
J
4SNe
J
a挳e
J
V4Va捦cVUdT4
=
=
=
=
Et sur ce lien une vidéo d’anthologie à ne pas manquer sur le DataBinding
=
W
=
h瑴éW⼯睷w楣iç獯f琮cçmLfêan捥⽶楳içnLtebca獴䵳摮.a獰x?b䥄fRcV2RRNb
J
S捥e
J
4Ve2
J
UV挳
J
NSM4dNRNNUU2
=
=
=
p椠îçu猠déîe汯léez
=
de猠aéé汩捡瑩tn猠èu椠man楰i汥n琠de猠dçnnée猬sîçu猠
deîez=
absolument
comprendre et utiliser le DataBinding (c’est plus rapide
aîe挠
beau捯ué= mç楮s
=
de= 汩gne猠 de= 捯de⤬F = en= 汩eu= e琠 élace= de猠
mé捡n楳ie猠èue=nçus=u瑩汩獩潮猠瑯u猠auéa牡îan琬=e獳sn瑩t汬emen琠ba珩s=
獵爠汥l déîe汯léement= 獰é捩f楱ue= de= 捯de= de= 汩a楳潮
=
éçu爠捨a捵n= des
=
捯n瑲t汥献
=
=
Revenez sur le formulaire
Main.cs
en mode
[Design]
(soit en cliquant
sur l’onglet
Main.cs [Design]
de la zone de travail, soit en double
-
cliquant sur le fichier
Main.cs
dans l’
Explorateur de solutions
)
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
56
sur
91
Dans la boite à outils, ouvrez l’onglet
Données
, s’il est fermé, en
cliquant sur
qui précède le nom de l’onglet
;
Faites un
glisser
-
déplacer
du contrôle
BindingSource
sur la zone de
dépôt de contrôles du formulaire. Un contrôle
bindingSource1
apparaît
da
ns cette zone
de dépôt
;
S
électionnez
le contrôle de source de données
bindingSource1
;
Dans la fenêtre de
Propriétés
, configurez le nom de ce contrôle en
changeant la propriété
(Name)
avec
mainBindingSource
;
Dans la barre d’outils de Visual C# Expre
ss, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compile
r
correctement.
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
double
-
clique
sur le menu
Fichier >
Nouveau
;
Une méthode
nouveau
ToolStripMenuItem_Click
de réponse au menu
Nouveau
a été ajoutée au code
du formulaire
Main.cs
;
Dans la méthode
nouveau
ToolStripMenuItem _Click
,
ajoutez le code
configurant la source de données (
DataSource
) des liaisons
(
mainBindingSource
)
avec une nouvelle table
;
Code C#
private
void
nouveauToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Charge une table vide dans la source des bindings
mainBindingSource.DataSource = CreerTable();
}
Dans la méthode
nouveau
ToolStripMenuItem _Click
,
ajoutez le code
indiquant que le barre de navigation (
mainBindingNavigator
) navigue
(
logique
!
) dans la source de liaisons tout juste définie
;
Code C#
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
57
sur
91
private
void
nouveauToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Charge une table vide dans la source des bindings
mainBindingSource.DataSource = CreerTable();
// Configure la navigation
mainBindingNavigator.BindingSource = mainBindingSource;
}
Enfin, dans la méthode
nouveau
ToolStripMenuItem _Click
,
ajoutez le
code
liant la grille de données (
mainDataGridView
) avec la source de
données de la source des liaisons (
BindingSource
) dans laquelle
navigue la barre de navigation (
mainBindingNavigator
)
;
Code C#
private
void
nouveauToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Charge une table vide dans la source des bindings
mainBindingSource.DataSource = CreerTable();
// Configure la navigation
mainBindingNavigator.BindingSource = mainBindingSourc
e;
// Configure la grille de données sur la même source que la source de
// navigation
mainDataGridView.DataSource =
mainBindingNavigator.BindingSource;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement.
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
Dans l’
Editeur du Coach C#
, cliquez le menu
Fichier > Nouveau
;
Une nouvelle ligne de donnée
apparaît dans le formulaire
;
A l’aide des boutons de la barre de navigation,
ajoutez
(
) et
détruisez
(
)
quelques lignes de données
; Amusez
-
vous à saisir des
informations
: la grille fonctionne
! Franchement, vous êtes des As.
Pour tout savoir sur
l’objet
=
BindingSource
:
http
://msdn2.microsoft.com/fr
-
fr/library/h974h4y2(VS.80).aspx
Pour tout savoir sur l’objet
BindingNavigator
:
http://msdn2.microsoft.com/fr
-
fr/library/b9y7cz6d(VS.80).aspx
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
58
sur
91
Pour tout savoir sur l’objet
DataGridView
:
http://msdn2.microsoft.com/fr
-
fr/library/e0ywh3cz(VS.80).aspx
3.2
Alimenter la table en mémoire avec le fichier CSV
L’objectif de ce de
uxième exercice est de lire les données de la grille à partir d’un
fichier au format CSV (texte délimité), et bien sur de sauvegarder de nouveau ces
données, après modification, dans le même fichier CSV (ou un autre d’ailleurs)
!
Il va
nous donner l’opport
unité d’aborder certains mot
s
clés de test, de boucle et de bloc.
Déroulement de l’exercice
:
1.
Développez le code de lecture du fichier CSV
:
Un fichier CSV est composé de ligne
s
de valeurs, séparé
es
par un
séparateur qui dans notre cas est le
«
;
»
,
et dont l’ordre des valeurs est
toujours le même d’une ligne à l’autre. Chaque ligne est finie par un
牥瑯uê
J
捨a物ç琠E
CR
).
L’algorithme à développer est composé de deux étapes
=
W
=
ㄮ
=
i楲e==f楣桩i爠êps楧ne楧ne
=
X
=
㈮
=
A=éa牴ê爠de=污l 汩gne=
de=
瑥x瑥=汵eⰠ
géné牥爠un=en牥ê楳瑲imen琠dan猠污l
瑡b汥l de=dçnnées
=
X
=
䑡n猠污l 汩gne=汵lⰠcha捵ne=de猠îa汥l牳êà=汩牥êe獴=
珩éa狩e= éa爠 un= …
=
;
»
; le premier par
amètre est l’
ID
, le deuxième
l’
E
ntreprise
, etc. jusqu’au douzième qui est le
Chiffre d’affaire
狩r汩珩
;
Af楮i de
géné牥
爠un nouve氠en牥r楳瑲敭en琠v楤i
Ⱐnou猠a汬on猠u瑩汩獥爠污l
méthode
NewRow()
de notre table de données. Cette méthode est
fournie par la classe
DataTable
, qui est le type de notre objet de table de
données en mémoire.
Une bonne pratique de
développement est de créer une méthode ou
fonction par étape d’algorithme, et ce afin d’augmenter la maintenabilité
e琠 污l 汩獩扩汩瓩= du= 捯de⸠ Au瑲tmen琠 d楴Ⱐ nçu猠 a汬çn猠 déîe汯léeê= deu砠
méthçdes
=
㨠une=éçu爠ê楲e==f楣桩i爠ê楧ne⃠楧neⰠe琠une⁰çu爠êàçu瑥爠
à=nç瑲t=
table de données une nouvelle ligne. C’est par cette dernière que nous
a汬çn猠捯mmenceê
=
!
=
=
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit
sur
Main.cs
dans
l’
Explorateur de solutions
, et en sélectionnant le menu
Afficher le code
;
Positionner le curseur juste après l’accolade
}
fermante du constructeur
de la classe Main
;
Ajoutez deux lignes vides
en tapant sur la touche
Entrée
;
Créez une fonction
AjouterLigneATable
en ajoutant le code suivant
:
Code C#
private
void
AjouteLigneA
Table(
string
LigneLue
,
DataTable
TableDeDonnees
)
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
59
sur
91
{
}
C’est quoi
void
?
void
indique au compilateur que la méthode est une fonction qui ne
retourne aucune valeur.
C’est quoi
(
string
LigneLue,
DataTable
TableDeDonnees)
?
En fait, une fonction peut
avoir zéro ou plusieurs paramètres, qui
indique
(nt)
généralement à la fonction le contexte d’exécution de celle
J
捩⸠
ma爠exeméleⰠ汥lé牥êie爠éa牡mè瑲t=
string
LigneLue
est la ligne qui a été
lue dans le fichier CSV, alors que le deuxième
DataTable
TableDeDon
nees
est la table de données dans laquelle ajouter un nouvel enregistrement.
Le type précède le nom du paramètre.
LigneLue
et
TableDeDonnees
:
-
LigneLue
correspond à ligne de donnée au format texte délimité
avec un «
;
» qu’il faut couper pour ajouter une nouvelle ligne de
dçnnées
=
X
=
J
=
TableDeDonnees
est la table de données sur laquelle il faut ajouter
une nouvelle ligne
;
Passage par valeur
ou
passage
par référence
?
En C#, les paramètres sont passés par défaut par valeur, c'est
-
à
-
dire que
la valeur est copié
e
sur la pile et que tous les changements
de
cette
valeur sont détruits lorsque la méthode est quittée. Néanmoins, C# utilise
communément deux type
s
: les types par valeur
et les types par
référence (cf. page 26). Dans le cas de passage de paramètre d’un type
éa爠îa汥l爠⡰E爠exemé汥l
int
ou
double
), le paramètre est donc copié et
les changements réalisés sur la valeur de ces paramètres sont détruits
l
ors du retour de fonction. Un paramètre ayant un type par référence
(tout
objet)
est aussi passé par valeur, mais dans ce cas c’est une copie de la
référence (qui représente la localisation de l’objet en mémoire) qui est
a橯àtée=à=la=é楬e⸠ia=mé瑨çde=u瑩汩
se donc un alias sur l’objet, qui va être
u瑩汩珩=éçu爠mçdif楥爠
捥琠
çb橥à
=
(c’est un peu comme si, lors de l’appel de la
fonction, on ajoutait sur une pièce une deuxième porte d’accès)
⸠兵and=污=
景n捴楯n= îa= 獥= 瑥êm楮e爬ê 污l 狩fé牥n捥= u瑩汩珩
e
=
éa爠 污l fçn捴楯n
=
îa= ê瑲t=
dé瑲t楴i
=
E
污ldeux槨ie=éç牴ê
=
e獴sdé瑲t楴iF
=
mai猠汥猠mçdif楣慴içn猠aééç牴ê猠à=
l’objet seront gardées
=
⡥E=g牯猬=汥l=meuble猠èue=îçu猠au牥ê=a橯u瓩=en=
éa獳sn琠éa爠污l éç牴e=橵獴s=dé瑲t楴i=牥獴e
湴
=
dan猠污l é槨ieF
. C’est pour cela
èue=汥l éa牡mè瑲t=
DataTabl
e
TableDeDonnees
est passé par valeur, mais
tous les ajouts d’enregistremen
t
s
=
èu椠 se牯ê琠 晡楴i dan猠 污= fçn捴楯n
=
AjouteLigneATable
seront préservés lors de la fin de
cette
fonction.
Pour tout savoir sur le passage de paramètres
:
http://msdn2.microsoft.com/fr
-
fr/library/0f66670z(VS.80).aspx
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
60
sur
91
Ajoutez à la fonction
AjouterLigneATable
la ligne de création de
l’index
e
que nous utiliserons pour indiquer la val
eur lue dans l
a
ligne
(Id, Entreprise, etc.)
;
Code C#
private
void
Ajoute
r
LigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
// Definition de l'index de la position de lecture
int
index = 0;
}
Ajoutez à la fonction
AjouterLigneATable
le code pour découper l
a
ligne de texte lue en un tableau de chaines de caractères, en fonction
du séparateur «
;
»
;
La
méthode à utiliser est fournie par la classe
string
qui est le type de la variable
LigneLue
;
Code C#
private
void
AjouterLigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
// Definition de l'index de la position de lecture
int
index = 0;
// Découper la ligne en fonction du caractère de séparation
string
[] valeursLues = LigneLue.Split(
new
char
[] {
';'
});
}
Ajoutez à la fonction
AjouterLigneATable
le code pour générer une
nouvelle ligne de données vide
;
La méthode à utiliser est fournie par la
classe
DataTable
qui est le type de la variable
TableDeDonnees
;
Code C#
private
void
AjouterLigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
// Definition de l'index de la position de lecture
int
index = 0;
// Découper la ligne en fonction du caractère de séparation
string
[]
valeursLues
= LigneLue.Split(
new
char
[] {
';'
});
// Crée une nouvelle ligne de données
DataRow
ligneDeDonnees = TableDeDonnees.NewRow();
}
Ajoutez à la fonction
AjouterLigneATable
le code pour balayer
l’ensemble des valeurs contenues dans le tableau
valeursLues
(Pensez à utiliser
un extrait de code pour le faire)
;
Code C#
private
void
AjouterLigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
// Definition de l'index de la position de lecture
int
index = 0;
// Découper la ligne en fonction du caractère de
séparation
string
[]
valeursLues
= LigneLue.Split(
new
char
[] {
';'
});
// Crée une nouvelle ligne de données
DataRow
ligneDeDonnees = TableDeDonnees.NewRow();
// Pour toute les valeurs, met à jour le ligne de données
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
61
sur
91
foreach
(
string
valeur
in
valeursLues)
{
}
}
Au fait, comment utiliser les extraits de code
?
Bon, on l’a déjà vu, mais on va se répéter
=
!
=
ㄮ
=
ia=é牥m槨牥=獯汵liçn=e獴sde=晡楲e=un=
捬cc
J
droit à l’endroit où vous
îçu汥l=楮珩牥爠un=ex瑲a楴ide=捯deⰠe琠珩汥捴楯nnez=汥lmenu=
Insérer
un extrait…
;
Dans notre cas, sélectionnez ensuite l’extrait
C
ollections and
arrays > Iterate through a collection
;
Il
vous reste ensuite à paramétrer l’extrait et à ajouter le
捯mmen瑡楲e
=
X
=
=
㈮
=
ia=deux槨ie=獯汵liçn=e獴sde=瑡ée爠
foreach
dans le code
; L’éditeur
de= s楳ia氠 䌣C bxé牥獳ê îçu猠 é牯éçs
e
=
l’IntelliSense, en
é狩珩汥捴楯nnant
=
foreach
;
Tapez alors deux fois sur la touche
TAB
(tabulation)
;
C’est quoi
foreach
?
foreach
est
une instruction
à
utiliser pour itérer automatiquement tous les
éléments d’une collection ou d’un tableau.
=
=
=
mçu爠êçu琠saîç楲=爠
foreach
:
http://msdn2.microsoft.com/fr
-
fr/library/ttw7t8t6(VS.80).aspx
Ajoutez à la fonction
AjouterLigneATable
le code de mise à jour de la
colonne de la ligne à ajouter, en fonction de la valeur lue
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
62
sur
91
Code C#
private
void
AjouterLigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
…
// Pour toute les valeurs, met à jour le ligne de données
foreach
(
string
valeur
in
valeursLues)
{
switch
(index++)
{
case
0:
ligneDeDonnees[
"Id"
] = valeur.Trim();
break
;
case
1:
ligneDeDonnees[
"Entreprise"
] =
valeur.Trim();
break
;
case
2:
ligneDeDonnees[
"Contact"
] = valeur.Trim();
break
;
case
3:
ligneDeDonnees[
"Titre"
] = valeur.Trim();
break
;
case
4:
ligneDeDonnees[
"Adresse"
] = valeur.Trim();
break
;
case
5:
ligneDeDonnees[
"Ville"
] = valeur.Trim();
break
;
case
6:
ligneDeDonnees[
"Region"
] =
valeur.Trim();
break
;
case
7:
ligneDeDonnees[
"CodePostal"
] = valeur.Trim();
break
;
case
8:
ligneDeDonnees[
"Pays"
] = valeur.Trim();
break
;
case
9:
ligneDeDonnees[
"Telephone"
] = valeur.Trim();
break
;
case
10:
ligneDeDonnees[
"Telecopie"
] = valeur.Trim();
break
;
case
11:
ligneDeDonnees[
"CA"
] =
valeur.Trim();
break
;
default
:
ligneDeDonnees[
string
.Format(
"Colonne {0}"
, index)]
= valeur.Trim();
break
;
}
}
}
C’est quoi
switch
?
switch
est un
e instruction
de sélection afin d’évaluer une expression et
摥d
déte牭
楮e爠 汥l b汯挠 de= 捯de= à= exé捵瑥ê
=
X
=
switch
saute
automatiquement à un libellé qui correspond à l’expression, pour exécuter
汥lb汯挠de=de=fin楳獡n琠né捥獳s楲emen琠éa爠
break
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
63
sur
91
Pour tout savoir sur
sw
itch
:
http://msdn2.microsoft.com/fr
-
fr/library/06tc147t(VS.80).aspx
Enfin, juste avant
}
fermante de la méthode, ajoutez à la fonction
AjouterLigneATable
le code d’ajout de la ligne de données
nouvellement crée
;
Code C#
private
void
AjouterLigneATable(
string
LigneLue,
DataTable
TableDeDonnees)
{
…
// Pour toute les valeurs, met à jour le ligne de données
foreach
(
string
valeur
in
valeursLues)
{
switch
(index++)
{
…
}
}
// Ajoute la nouvelle ligne de données à la table
TableDeDonnees.Rows.Add(ligneDeDonnees);
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement.
Bon, maintenant que nous savons ajouter une nouvelle ligne de données
à partir de la ligne de texte lue, il faut
lire le fichier texte ligne à ligne et
appeler la fonction
AjouterLigneATable
pour chacune des lignes de
texte
!
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
, et en sélectionnant le menu
Afficher le code
;
Positionnez
le curseur juste après l’accolade
}
fermante du constructeur
de la classe
Main
;
Ajoutez deux lignes vides
en tapant sur la touche
Entrée
;
Créez une fonction
OuvrirFichier
en ajoutant le code suivant
:
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
}
La fonction
OuvrirFichier
possède un seul paramètre,
NomDuFichier
qui
est le nom complet du fichier à ouvrir et re
n
voie une table de données
complète de type
DataTable
,
contenant tous les enregistrements lus;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
64
sur
91
Encore une fois, une règle de bonne programmation est de
systématiquement ajouter le code de renvoi de fonction avec la création
de la fonction. Pour ma part, j’utilise toujours une variable nommée
result
(bon, je radote un peu mais cela évite des bogues). Et comme
l’assignation est obligatoire, assignez à
null
vos variables de retour de
type objet, si vous n’avez pas d’autres valeurs à donner (logique).
=
=
Ajoutez à la fonction
OuvrirFichier
le code de déf
inition et de renvoi de
la valeur de retour
;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
// definition de la variable de retour
DataTable
result =
null
;
// renvoi de la valeur
return
result;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
; La structure de la fonction est correcte.
N
ous
avons besoin de définir deux variables
:
1.
ligneLu
, de type
string
,
qui correspond à la ligne de fichier lu
e
et
qui est passé
e
en paramètre à la fonction
AjouterLigneATable
;
2.
estPremièreLigne
, de type
booléen
, qui indiquera si nous lisons
la première ligne, car dans ce cas il faudra
assigner
la DataTable
devant recevoir les enregistrements
qui est passé
e
en paramètre
de
la méthode
AjouterLigneATable
;
Ajoutez à la fonction
OuvrirFichier
le code de définition
des variables
ligneLu
et
estPremièreLigne
;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
// definition de la variable de retour
DataTable
result =
null
;
// Definition et assignation des variables
string
ligneLu =
string
.Empty;
Boolean
estPremiereLigne =
true
;
// renvoi de la valeur
return
result;
}
Sous la
dernière ligne insérée, faites un
clic
-
droit
et sélectionnez le
menu
Insérer un extrait…
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
65
sur
91
Sélectionnez l’extrait de code
filesystem >
Read Text From a File
;
Le code suivant est ajouté à la fonction
:
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
…
Boolean
estPremiereLigne =
true
;
string
fileContents;
using
(System.IO.
StreamReader
sr =
new
System.IO.
StreamReader
(
@"C:
\
Test.txt"
))
{
fileContents = sr.ReadToEnd();
}
// renvoi de la valeur
return
result;
}
Dans l’extrait de code ajouté apparaît des parties en vert
=
㬠捥=sçn琠汥l=
éléments à paramétrer de l’extrait
=
X
=
=
=
Dans notre cas, il s’agit de définir le nom du fichier à ouvrir
;
C’est quoi
@
devant la chaîne de caractère ?
Le caractère
@
devant une chaine de caractère indique qu’il faut traiter
汥猠 捡牡捴è牥猠 獰é捩aux= ⢫
=
\
» dans notre cas) comme un caractère
normal.
Elément à définir pour l’extrait
=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
66
sur
91
C’est quoi
using
?
using
définie la portée d’une variable en dehors de laquelle
=
e汬e= 獥牡ê
supprimée. Bon, si ce n’est p
a猠瑲t猠捬慩c
, voici l’explication de la portée et
de=污=î楳ib楬楴i=de猠îa物ab汥献
=
ia=éç牴êe
=
d’une variable définie l’étendue de
code durant laquelle le nom d’une vari
ab汥lne=éeu琠éa猠ê瑲t=êéu瑩汩珩
=
éçuê=
nçmme爠 une= se捯nde= îa物ab汥l
=
ia= î楳ibi汩瓩
=
d’une variable définie
l’étendue de code durant laquelle le contenu de la variable peut être
a捣cdé=en=u瑩汩獡n琠sçn=nçm=⡯E=a汩a猩s
=
ie=ée瑩琠獣séma=su楶an琠楬汵獴牥=污l
d楦曩牥êcen瑲t=⁰ç牴ée琠污lî楳ib楬楴i
=
W
=
=
=
=
䑯a挬c 汥l g牡êd=
楮ié狪ê
=
摥d
using
est de limi
ter la portée
des variables
unique
ment à un bloc de code déterminé
.
Pour tout savoir sur
using
:
http://msdn2.microsoft.com/fr
-
fr/library/yh598w02
(VS.80).aspx
C’est quoi un
StreamReader
?
C’est un objet qui lit d
e猠ca牡捴è牥ê=à=éa牴ê爠d❵n=f汵l=d❯捴e瑳t dan猠un=
捯dage⁰a牴ê捵汩e爮
=
C’est l’objet à utiliser
éçu爠汩牥e猠汩sne猠s❩n景牭a瑩tns=
à=éa牴ê爠d❵n=f楣桩i爠瑥x瑥=獴snda牤ê
=
Il appartient à l’espace de nommage
System.IO
, qui fourni tous les objets nécessaires pour réaliser tout type
d’Entrées/Sorties avec le système.
=
ia=méthçde=du=
StreamReader
que
nous allons utiliser pour lire une ligne de donnée texte est
ReadLine()
;
P
our tout savoir sur
StreamReader
:
http://msdn2.microsoft.com/fr
-
fr/library/6aetdk20(VS.80).aspx
Dans la fonction
OuvrirFichier
,
retirez
le code de l’extrait qui nous est
inut
ile
, et indiquez que le nom du fichier à ouvrir est le paramètre
NomDuFichier
;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
…
Boolean
estPremiereLigne =
true
;
string
fileContents;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
67
sur
91
using
(System.IO.
StreamReader
sr =
new
System.IO.
StreamReader
(
NomDuFichier
))
{
fileContents = sr.ReadToEnd();
}
// renvoi de la valeur
return
result;
}
Reste maintenant à lire ligne à ligne le fichier texte délimité, en utilisant
une instruction de boucle
;
C# propose différentes instruction
s
de boucle
dont l’objectif commun est
d’exécuter d’une manière itérative un bloc de code
=
W
=
ㄮ
=
for
, qui est à utiliser dans le cas où un numéro de compteur est
disponible
;
2.
while
, qui est à utiliser dans le cas où une
itération est à exécuter
tant que («
while
» en anglais) une expression est vrai, ce qui veut
dire que la boucle peut ne pas être exécutée si l’expression est
晡u獳s
=
X
=
㌮
=
do
, c’est un peu comme un
while
, mais elle est à utiliser dans le
cas ou l’expression es
琠 à= éîa汵l爠 aé狨猠 èue= 污l bçu捬c= a
楴
=
é瓩=
exé捵瓩
e
=
au=mç楮猠une=景楳
=
㬠佮=e獴sa汯牳l珻爠de=éa獳s爠au=mçin猠
une=景楳an猠汥汯挠de=de
=
X
=
㐮
=
foreach
, qui est à utiliser pour itérer automatiquement les
éléments d’une collection ou d’une liste
=
X
=
=
=
=
mçu爠êçu琠s
avoir sur les instructions d’itération
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⼳2db晴by⡖E⸸M⤮F獰x
=
=
=
=
䑡a猠nç瑲t=捡猬=nçu猠a汬çn猠u瑩汩獥爠un=
do
, car durant la première
boucle
nous devons assigner
la table de données à une nouvelle valeur.
Puis
nous ajouterons une nouvelle ligne à la table de données,
tout ceci
si la
valeur lue n’est pas nulle bien sûr
=
!
=
=
Ajoutez à la fonction
OuvrirFichier
le code de lecture de chacune
des
lignes ;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
…
using
(System.IO.
StreamReader
sr
=
new
System.IO.
StreamReader
(NomDuFichier))
{
do
{
// Pour chaque ligne lu
ligneLu = sr.ReadLine();
}
while
(ligneLu !=
null
);
}
…
}
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
68
sur
91
If faut maintenant tester la valeur de la ligne lu
e
et vérifier si cette ligne
est la première ligne lu
e
. Nous allons utiliser l’instruction de sélection
if
-
else
;
C’est quoi
if
-
else
?
L'instruction
if
permet
de sélectionner une instruction à exécuter en
fonction de la valeur d'une expression
Booléen
ne
.
Pour tout savoir sur
if
-
else
:
http://msdn2.microsoft.com/fr
-
fr/library/5011f09h(VS.80).aspx
Sous la lecture de la ligne, ajoutez à la fonction
OuvrirFichier
le code
de test
créant la table de données et ajoutant une nouvelle ligne à
celle
-
ci
;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
…
using
(System.IO.
StreamReader
sr
=
new
System.IO.
StreamReader
(NomDuFichier))
{
do
{
// Pour chaque ligne lu
ligneLu = sr.ReadLine();
// si c'est la
première ligne lue,
// alors créé la table de donnée
if
(estPremiereLigne && ligneLu !=
null
)
{
result = CreerTable();
estPremiereLigne =
false
;
}
// Si la ligne
de données n'est pas nulle,
// alors ajoute la ligne à la table de données
if
(ligneLu !=
null
)
Ajoute
r
LigneATable(ligneLu, result);
}
while
(ligneLu !=
null
);
}
…
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compi
ler correctement
;
La dernière étape reste la sélection et l’ouverture du fichier sur le disque.
ie=䙲amewç牫ê⹎.琠é牯êçse=de猠bç楴is=de=d楡汯gue=捯mmune猠à=tçu
瑥s=
汥猠 aéé汩捡瑩tn猠 éçuê= 汥猠 瓢
捨e猠 汥猠 é汵猠 捯u牡êtes
=
: l’ouverture et la
獡uîega牤ê= de=f楣桩e爬ê 污l 珩汥捴楯n= de=
cçuleu牳ê çu=de=
éç汩捥猨景n琩
Ⱐçu=
en捯牥ê污l 珩汥捴içn=de=狩êe牴ê楲e献s 䍥猠bçi瑥猠de=d楡汯gue猠捯mmunes=
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
69
sur
91
sont disponibles soit au travers de contrôles d’écran sous la section
Boite
de dialogues
dans la
Boite à outils
, ou directement à partir de classe
s
pour i
nstancier vos propres objets.
Pour ouvrir un fichier sur le disque, nous allons utiliser un objet de type
OpenFileDialog
; Les principales propriétés et méthodes que nous allons
utiliser sont
:
1.
Filter
: Cette propriété sert à filt
r
er les fichiers en se
basant
notamment sur l’extension
=
㬠 nçu猠 f楬瑲t牯n猠 瑯u猠 汥猠 f楣桩i牳=
d’extension
*.coach
;
2.
Initial
Directory
: Cette propriété configure le répertoire affiché lors
de l’ouverture de la fenêtre
=
X
=
㌮
=
FileName
: Ce
tte propriété obtient ou définit
le nom complet
du
fichier sélectionné dans la liste des fichiers proposés
;
4.
ShowDialog
: Cette méthode affiche la boite de dialogue, et
retourne une valeur de type
DialogResult
indiquant notamment le
bouton que l’utilisateur a cliqué pour sortir de la fenêtre
=
X
=
乯ks=
瑥獴
erons ici que l’utilisateur a bien cliqué le bouton
OK
;
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
double
-
clique
sur le menu
Fichier >
Ouvrir
;
Une méthode
ouvrirToolStripMenuItem
_Click
de réponse au menu
Ouvrir
a été ajoutée au code
du formulaire
Main.cs
;
Dans la méthode
ouvrirToolStripMenuItem
_Click
,
ajoutez le code
de
création et d’affichage de la boite de dialogue d’ouverture de fichier
;
Code C#
private
void
ouvrirToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
OpenFileDialog
fileOpen =
new
System.Windows.Forms.
OpenFileDialog
())
{
fileOpen.Filter =
"Fichiers coach|*.coach"
;
fileOpen.InitialDirectory =
@"c:
\
"
;
if
(fileOpen.ShowDialog() ==
DialogResult
.OK)
{
}
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Vous pouvez d’ailleurs aussi tester le bon
fonctionnement de la boite de dialogue en lançant l’application
(ça
ne
coûte rien et c’est visuel …)
;
Dans la méthode
ouvrirToolStripMenuItem
_Click
,
ajoutez le code
d’ouverture du fichier et
de configuration de
s sources de données
;
C’est exactement le même code que celui écrit dans la méthode
nouveauToolStripMenuItem_Click
(cf.
page 58), à l’exception que la
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
70
sur
91
table de donnée
s
est la valeur de retour de l’appel de le fonction
OuvrirFichier
;
Code C#
private
void
ouvrirToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
OpenFileDialog
fileOpen =
new
System.Windows.Forms.
OpenFileDialog
())
{
fileOpen.Filter =
"Fichiers coach|*.coach"
;
fileOpen.InitialDirectory =
@"c:
\
"
;
if
(fileOpen.ShowDialog() ==
DialogResult
.OK)
{
// Charge le fichier de données dans la source des bindings
mainBindingSource.DataSource =
OuvrirFichier(
fileOpen.FileName
);
// Configure la navigation
mainBindingNavigator.BindingSource = mainBindingSource;
// Configure la grille de données sur la même source
// que la source de navigation
mainDataGridView.DataSource
= mainBindingNavigator.BindingSource;
}
}
}
Il faut maintenant mémoriser le nom du fichier sélectionn
é
pour l’utiliser
汯牳l de= 污l 獡uîega牤ê⸠ mçu爠 捥= fa楲eⰠ îçu猠 a汬ez= a橯à瑥爠 une= 癡物ab汥=
nomFichier
, de type
string
, et dont la portée va être la totalité de la
classe
Main
(pour la voir de partout dans la classe)
;
Positionnez
le curseur
juste avant
la définition du constructeur de la
classe
Main
;
Ajoutez deux lignes vides
en tapant sur la touche
Entrée
;
Ajoutez
le code suiva
nt pour définir un membre privé
(variable) de
portée sur la totalité de la classe pour stocker le nom du fichier
;
Code C#
p
ublic
partial
class
Main
:
Form
{
// Membres privés
private
string
nomFichier =
string
.Empty;
public
Main()
{
…
Revenez maintenant dans le code de la méthode d’ouverture de fichier
ouvrirToolStripMenuItem
_Click
;
Dans la méthode
ouvrirToolStripMenuItem
_Click
,
ajoutez le code
de
sauvegarde du nom du fichier
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
71
sur
91
Code C#
private
void
ouvrirToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
OpenFileDialog
fileOpen =
new
System.Windows.Forms.
OpenFileDialog
())
{
fileOpen.Filter =
"Fichiers coach|*.coach"
;
fileOpen.InitialDirectory =
@"c:
\
"
;
if
(fileOpen.ShowDialog() ==
DialogResult
.OK)
{
// Charge le fichier de données dans la source des bindings
mainBindingSource.DataSource =
OuvrirFichier(
fileOpen.FileName
);
// Configure la navigation
mainBindingNavigator.BindingSource = mainBindingSource;
// Configure la grille de données sur la même source
// que la source de navigation
mainDataGridView.DataSource
= mainBindingNavigator.BindingSource.DataSource;
// Mémorise le nom du fichier
nomFichier = fileOpen.FileName;
}
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
Dans l’
Editeur du Coach C#
, cliquez le menu
Fichier >
Ouvrir
; La
boite de dialogue
Ouvrir
d’ouverture de fichier apparaît
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
72
sur
91
Sélectionnez le fichier d’exemple
Clients.coach
situé dans les fichiers
utiles de l’exercice 02 (par exemple
C:
\
Coach
C#
\
Atelier 02
\
Fichiers
Utiles
\
Exercice 02
\
Clients.coach
)
;
Dans la boite de dialogue
Ouvrir
, cliquez le bouton
OK
; l’éditeur du
coach s’affiche maintenant avec l’ensemble des lignes lues
;
Bon, il n’y a pas à dire, bien que la programmation soit «
à l
’ancienne
», ça le
fait tout de même
!
2.
Développez le code d’écriture du fichier CSV
:
Ici, on va programmer l’inverse de l’exercice précédent, c'est
J
à
J
d楲e=èue=
nçus=a汬çns=é牯ê牡浭e爠污l 獡uîega牤ê=de猠楮fçêma瑩tn猠de=污=g物汬e=au=
景牭a琠䍓Cu爠êe=
d楳iue.
=
=
=
Nous allons tout d’abord faire une fonction de sauvegarde des
楮iç牭a瑩tns= de= 污l g物汬e= dans= un= f楣桩i爠 dçnt= 汥l nçm= e獴s 景u牮椠 en=
éa牡mè瑲t
=
X
=
=
Affichez le code du formulaire
Main.cs
, en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de
solutions
, et en sélectionnant le menu
Afficher le code
;
Positionner le curseur juste après l’accolade
}
fermante du constructeur
de la classe
Main
;
Ajoutez deux lignes vides
en tapant sur la touche
Entrée
;
Créez une fonction
sauverFichier
en ajoutant l
e code suivant
:
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
}
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
73
sur
91
La fonction
SauverFichier
ne
possède
qu’
un= 獥u氠 éaêamè瑲tⰠ
NomDuFichier
qui est le nom complet du fichier à sauvegarder, et ne
re
n
voie aucune valeur de retour (d’où
void
)
Pour lire un fichier, nous avions utilisé un
StreamReader
. Pour l’écrire,
nçu猠a汬çn猠u瑩汩獥爠ên
=
㼿?
StreamWriter
, bien sûr
!
C’est quoi un
Stream
Writer
?
C’est un objet qui écrit d
es=捡牡捴è牥猠à=éaê瑩爠d❵n=f汵l=d❯捴e瑳tdan猠un=
捯dage=éa牴ê捵汩e
爮
=
C’est l’objet à utiliser
éçu爠
é捲c牥êdan猠un=f楣桩e爠瑥x瑥=
de猠 汩gne猠 de= 瑥x瑥.= qçu琠 捯mme= 汥l
StreamReader
, il appartient à
l’espace de nommage
System.IO
, qui fourni
t
tous les objets nécessaires
pour réaliser tout type d’Entrées/Sorties avec le système. La méthode du
Stream
Writer
que nous allons utiliser pour écrire une ligne de donnée
s
texte est
Write
Line()
(bien sûr);
Pour tout savoir sur
Stream
Writer
:
http://msdn2.microsoft.com/fr
-
fr/library/3ssew6tk(VS.80).aspx
Il va aussi falloir itérer dans la collection de lignes de la table de données.
Bon, si l’instruction
foreach
ser
ait plus indiquée dans le cas présent
(
foreach
est toujours à préférer à
for
dans une liste ou une collection)
,
nous allons utiliser un
for
, histoire de l’avoir fait au moins une fois
=
!
=
=
Ajoutez à la méthode
SauverFichier
le code d’utilisation du
StreamWr
iter
pour écrire le fichier
;
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
// Utilisation d'un écrivain public !
using
(System.IO.
StreamWriter
streamWriter
=
new
System.IO.
StreamWriter
(NomDuFichier,
false
))
{
}
}
Au fait, elle est où la collection de lignes de la table de données
?
ça c’est une bonne question
=
℠b汬e=es琠dans=污l é牯ê物é瓩=
DataSource
de
notre objet de gestion de la source des liaisons
mainBindingSource
,
bien sur
!
En effet, aussi bien lors de la création d’un nouveau fichier que
de l’ouverture d’un fichier existant, nous avons respectivement les lignes
=
W
=
// Charge une table vide dans la source des bindings
mainBindingSource.DataSource
= CreerTable();
ou
// Charge
le fichier de données dans la source des bindings
mainBindingSource.DataSource =
OuvrirFichier(
fileOpen.FileName
);
DataSource
contient donc un objet de type
DataTable
, qui a une
propriété
Rows
pointant sur la collection de ligne
s
de la table de
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
74
sur
91
données.
Au passage, s
i dans l’une des
=
deux=景n捴楯n猠îçu猠éç獩瑩潮nez
=
汥l捵牳敵爠
獵爠污l é牯ê物é瓩=
DataSource
, une aide rapide apparaît vous indiquant
entre autre
le type de la propriété
DataSource
:
DataSource
est de type objet, ce qui est normal car cette propriété
est
destinée à configurer ou obtenir non seulement des tables de données
(
DataTable
), mais aussi tout objet pouvant fournir des données (
DataSet
,
etc.)
, donc le Framework ne
connait
pas
à
priori le type à stocker.
A l’intérieur du bloc
using
, ajoutez à la méthode
SauverFichier
le code
pour i
térer l’ensemble des lignes de l
a table de données
, en utilisant la
boucle
for
;
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
// Utilisation d'un écrivain public !
using
(System.IO.
StreamWriter
streamWriter
=
new
System.IO.
StreamWriter
(NomDuFichier,
false
))
{
// Balayage de l'ensemble des lignes de la table
for
(
int
i = 0;
i < mainBindingSource.DataSource.Rows.Count;
i++)
{
}
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Vous devez
obtenir une erreur (bon, au moins une, quoi
!)
C’est normal, l
e
=
捯mé楬a瑥u爠ne=éeu琠éa猠獡îç楲=èue=
DataSource
contient
un objet de type
DataTable
. Et comme un objet de base n’a pas de
=
é牯ê物é瓩=
Rows
, une erreur est générée
!
Type de DataSource
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
75
sur
91
Mais comment indiquer qu’un objet a un type précis
=
?
=
䌣Cé牯êç獥=des=楮獴牵捴楯n猠e琠de猠mé瑨çde猠de=捯nîe牳êçn=E
cast
) d’un
瑹ée=en=un=au瑲e⸠p椠污l 捯nîe牳êçn=e獴séç獳楢汥l=a汯牳l污l îa汥l
爠牥瑯u牮êe=
e獴s du= 瑹ée= a瑴endu=
㬠 iç牳êue= 汥l 捯mé楬a瑥u爠 éeu琠 au瑯ma瑩tuement=
捯nîe牴ê爠une= îa汥l爠dan猠un= au瑲t= 瑹éeⰠa汯牳l çn= éa牬e= de= 捯nîe牳êçn=
implicite
; Si le compilateur nécessite une information pour pouvoir
convertir une valeur, alors on parle de conversion
explicite
;
Comment indiquer une conversion (
cast
) explicite
?
C# propose deux formalismes pour préciser des conversion
s
explicite
s
:
1.
La vale
ur à convertir est précédée du type de conversion entre
parenthèse
:
(
(
DataTable
)
mainBindingSource.DataSource).Rows
D
ans
l
e
cas où la conversion n’est pas possible, ce formalisme
génère une exception à l’exécution
=
X
=
㈮
=
ia=îa汥l爠à=捯nîe牴ê爠e獴s 獵楶i
e
=
de l’in
獴牵捴楯i=
as
et du type
de
conversion
:
(mainBindingSource.DataSource
as
DataTable
).Rows
D
ans
le
cas où la conversion n’est pas possible, ce formalisme
génè牥êune=îa汥l爠nu汬e=E
null
)
à
l’exécution
=
: c’est pour cette raison
èue=⁰狩曨牥ê
as
!
Dans les deux cas, un jeu de parenthèses
( )
isole la valeur à
convertir du reste de l’expression.
=
=
=
mçu爠êçu琠saîç楲=
獵爠êa=nîe牳êçn
(
cast
)
:
http://msdn2.microsoft.com/fr
-
fr/library/ms173105(VS.80).aspx
Pour tout savoir
sur l
’instruction
as
:
http://msdn2.microsoft.com/fr
-
fr/library/cscsdfbt(VS.80).aspx
Modifiez la méthode
SauverFichier
afin de faire une conversion de
DataSource
en utilisant
as
;
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
// Utilisation d'un écrivain public !
using
(System.IO.
StreamWriter
streamWriter
=
new
System.IO.
StreamWriter
(NomDuFichier,
false
))
{
// Balayage de l'ensemble des lignes de la table
for
(
int
i = 0;
i <
(
mainBindingSource.DataSource
as
DataTable
)
.Rows.Count;
i++)
{
}
}
}
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
76
sur
91
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout compile
!
Reste maintenant à concaténer la
valeur de chacun des champs de
chaque ligne de la table de données.
Comment
concaténer des chaî
nes de caractère
s
?
Pour concaténer les chaî
nes, le plus simple est d’utiliser la méthode
Concat
de la classe
string
. Cette méthode concatène
n
cha
î
nes
de
caractères précisées en paramètre.
Pour tout savoir
sur
l’utilisation des chaî
nese=牡捴è牥ê
=
W
=
h瑴éW⼯m獤n2.m楣iç獯f琮捯mLfê
J
f爯ê楢牡特⽭猲2UPS2⡶献sM⤮F獰x
=
=
=
=
mçu爠êçu琠saîç楲=
獵爠
污l捬慳獥=
string
:
http://msdn2.microsoft.com/fr
-
fr/library/s1wwdcbf(VS.80).aspx
Comment accéder à la valeur d’un champ d’une ligne de donnée
s
=
?
=
ia= é牯é
物é瓩=
Rows
du type
DataTable
est une collection de ligne
s
de
données (
DataRow
). Comme toutes les collections, nous pouvons
accéder à une
ligne déterminée en donnant son
numéro
d’ordre
=
en瑲t=
捲潣cet
s
=
⡥E=捯mmençan琠à=M=éçu爠污lé牥m槨牥⤮êma爠exemé汥l=污l汩g
ne=de=
捯de
=
(mainBindingSource.DataSource
as
DataTable
).Rows[2]
renvoi
e
la
troisième ligne du tableau de données.
Pour
accéder à la valeur d’un champ
Ⱐ楬=晡u琠en獵楴i=楮i楱ue爬ê
瑯u橯à牳ê
en瑲t= 捲潣het
s
Ⱐ汥l nçm= du= 捨amé= de= dçnnée
s
=
îçu汵⸠ma爠exemé汥l= 污=
汩gne=
=
(mainBindingSource.DataSource
as
DataTable
).Rows[2][
"Id"
]
renvoi
e
la valeur de l’ID de la troisième ligne du tableau de données.
=
=
Fort de tout cela, ajoutez à la méthode
SauverFichier
la
ligne de
code
de concaténation d’une ligne au format texte
(l’indentation de départ
des ligne
s a ici été retirée
pour plus de lisibilité)
;
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
// Utilisation d'un écrivain public !
using
(System.IO.
StreamWriter
streamWriter
=
new
System.IO.
StreamWriter
(NomDuFichier,
false
))
{
// Balayage de l'ensemble des lignes de la table
for
(
int
i = 0;
i <
(
mainBindingSource.DataSource
as
DataTable
).
Rows.Count;
i++)
{
// Concaténation de la ligne de texte
streamWriter.WriteLine(
string
.Concat(
(
mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Id"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Entreprise"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Contact"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Titre"
],
";"
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
77
sur
91
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Adresse"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Ro
ws[i][
"Ville"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Region"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"CodePostal"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Pays"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Telephone"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"Telecopie"
],
";"
,(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"CA"
]
== System.
DBNull
.Value ?
"0"
:
(mainBindingSource.DataSource
as
DataTable
).Rows[i][
"CA"
].ToString()
));
}
}
}
Si, si, c’est bien une seule ligne de code
(compter bien les «
;
» et vous
verrez, il n’y en a qu’un seul
qui appartient à la ligne
!)
. Bon, pour
écrire
ce genre de code, utilisez l’alignement des lignes et le copier
-
coller.
Vous verrez, c’est très rapide.
Tiens, c’est quoi l’
exé牥獳楯ê
?:
?
L'opérateur conditionnel (
?:
) retourne l'une de deux valeurs selon la
valeur d'une expression booléenne.
C’est très utile pour
exé物meê
=
de=
maniè牥ê 捯n捩獥c e琠élégan瑥=
d
e猠捡汣u汳l èu椠éçu牲a楥i琠né捥獳楴e爠une=
捯n獴牵捴楯n=
if
-
else
;
Dans notre cas, si la valeur du
CA
est nulle dans la grille de données
(
System.DBNull.Value
), alors l
a valeur 0 est ajoutée
à la chaî
ne, sinon
on écrit le
CA
indiqué
;
Pourquoi utilise
-
t
-
on
System.DBNull.Value
?
System.DBNull.Value
e
st la valeur nulle d’une donnée
Ⱐ
楮iééendamment=de=sçn=瑹ée.=bn=e晦e琬=dan猠nç瑲t=捡猬=nçu猠aîçn猠un=
捨amée⁴yée=
int
, qui ne supporte donc pa
s la valeur
null
;
Pour indiquer
qu’aucune valeur de donnée n’a été saisie, la valeur
System.DBNull.Value
est utilisée
;
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout compile
normalement encore correctement.
La dernière chose à faire maintenant est d’appeler cette méthode
SauverFichier
à tous les endroit
s
où l’on peut déclencher la sauvegarde
d’un fichier, c'est
J
à
J
dire lorsque l’utilisateur clique dans l’éditeur du coach
獵爠êe=nu=
Fichier > Enregistrer
ou
Fichier > Enregistrer
sous
;
Pour sauvegarder un fichier sur le disque, nous allons utiliser un
objet de
type
Save
FileDialog
; Les principales propriétés et méthodes que nous
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
78
sur
91
allons utiliser sont
:
1.
Filter
: Cette propriété sert à filtrer les fichiers en se basant
notamment sur l’extension
=
㬠 nçu猠 f楬瑲t牯n猠 瑯u猠 汥猠 f楣桩i牳=
d’extension
*.coach
;
2.
Init
ial
Directory
: Cette propriété configure le répertoire affiché lors
de l’ouverture de la fenêtre
=
X
=
㌮
=
FileName
: Cette propriété obtient ou défini
t
le nom complet du
fichier à sauvegarder dans la liste des fichiers proposés
;
4.
ShowDialog
: Cette méthode affiche la boite de dialogue, et
retourne une valeur de type
DialogResult
indiquant notamment le
bouton que l’utilisateur a cliqué pour sortir de la fenêtre
=
㬠乯ks=
testerons ici que l’utilisateur a bien cliqué le bouton
OK
avant de
lancer
la sauvegarde ;
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
double
-
clique
sur
le menu
Fichier >
Enregistrer sous
;
Une méthode
enregistrersousToolStripMenuItem_Click
de réponse
au menu
Enregistrer sous
a été ajoutée au code
du formulaire
Main.cs
;
Dans la méthode
enregistrersousToolStripMenuItem
_Click
,
ajoutez le
code
de création et d’affichage de la boite de dialogue de sauvegarde
du fichier
;
Code C#
private
void
enregistrersousToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
SaveFileDialog
fileSave =
new
SaveFileDialog
())
{
fileSave.Filter =
"Fichiers coach|*.coach"
;
fileSave.InitialDirectory =
@"c:
\
"
;
if
(fileSave.ShowDialog() ==
DialogResult
.OK)
{
}
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
; Vous pouvez d’ailleurs aussi tester le bon
fonction
nement de la boite de dialogue en lançant l’application
(ça
ne
coûte rien et c’est
toujours
visuel …) ;
Dans la méthode
enregistrersousToolStripMenuItem
_Click
,
ajoutez le
code
de sauvegarde par app
e
l de la méthode
SauverFichier
;
Code C#
private
void
enregistrersousToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
SaveFileDialog
fileSave =
new
SaveFileDialog
())
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
79
sur
91
{
fileSave.Filter =
"Fichiers coach|*.coach"
;
fileSave.InitialDirectory =
@"c:
\
"
;
if
(fileSave.ShowDialog() ==
DialogResult
.OK)
{
// Mémorise le nom du fichier
nomFichier = fileSave.FileName;
// Sauvegarde les informations
SauverFichier(nomFichier);
}
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Dans la fenêtre
Main.cs
en mode
[Design]
, faites un
double
-
clique
sur
le menu
Fichier >
Enregistrer
;
Une méthode
enregistrerToolStripMenuItem_Click
de réponse au
menu
Enregistrer sous
a été ajoutée au code
du formulaire
Main.cs
;
Cette méthode de réponse au menu
Enregistrer
va tester si le
fichier a
déjà été sauvegardé (c'est
-
à
-
dire si le nom du fichier n’est pas vide) pour
u瑩汩獥爠汥lbçn=nçm=de楣桩iê
=
㬠p楮inⰠe汬e=îa=牯ê瑥爠汥l捯de=獵爠污lmé瑨çde=
捯牲e獰çndan琠au=menu=
Enregistrer sous
;
Dans la méthode
enregistrer
ToolStripMenuItem
_Click
,
ajoutez le
code
de sauvegarde du fichier, si le nom de fichier existe
;
Code C#
private
void
enregistrerToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
// Si le nom du fichier est n'existe pas (i.e. est vide)
if
(nomFichier ==
string
.Empty)
{
// route l'appel vers la sauvegarde avec selection du nom
this
.enregistrersousToolStripMenuItem_Click(sender, e);
}
else
{
// Sauvegarde les informations
SauverFichier(nomFichier);
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
80
sur
91
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
Testez maintenant votre application en créant un nouveau fichier (menu
Nouveau
), ajoutez quelques enregistrement, sauvegardez le tout, r
é
ouvrez le fichier, etc. C’est magnifique
!
C’est presque pro (hum
??).
3.3
Finaliser
le comportement de la fenêtre
Pour faire vraiment professionnel, on va ajouter à la fenêtre des
comportements bien utiles, comme
:
-
Protéger la fenêtre contre les fermetures
intempestives lorsque
des modifications non encore sauvegardées ont été apportées à la
liste des données
;
-
Indiquer le nom du fichier dans la barre de titre de la fenêtre
;
-
Modifier l’icône de la fenêtre
;
-
Ou encore, trapper les erreurs qui pourraient surv
enir sur la grille
de données
;
Déroulement de l’exercice
:
1.
Protégez contre les fermetures intempestives de fenêtre
:
Il s’agit ici d’ajouter une boite de dialogue de confirmation de sortie
lorsque l’utilisateur quitte l’application sans sauvegarder
=
汥猠 dçnnées=
mçdifiée猬se琠ceⁱue汱ue=楴==mçyene=牴êe
=
X
=
=
=
=
mçu爠捥=fa楲eⰠnçu猠
a汬çn猠
aàçu瑥爠au=景牭u污楲e=une=景nc瑩tn=de=é物獥=en=
charge d’un événement
=
㨠
FormClosing
;
C’est quoi
FormClosing
?
L'événement
FormClosing
se produit avant la fermeture du formulaire.
Lorsqu'un formulaire est fermé, il est supprimé et libère de ce fait toutes
les ressources associées au formulaire. Si vous annulez cet événement,
le formulaire reste ouvert. Pour annuler la fermeture d'un form
ulaire,
affectez
true
à la propriété
Cancel
du
FormClosingEventArgs
pas
sé
au gestionnaire d'événements
,
en param
ètre de la méthode de prise en
charge de l’événement.
=
=
=
mçu爠êçu琠saîç楲=爠
FormClosing
:
http://msdn2.microsoft.com/fr
-
fr/library/ddy1d5sa(VS.80).aspx
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs [Design]
de la zone de travail
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
81
sur
91
Faites un
clic
-
droit
à l’intérieur de la fenêtre (en dehors de tout autre
contrôle, sur la zone grise de la fenêtre par exemple)
et sélectionnez le
menu
Propriétés
;
Dans la barre d’outils de la fenêtre de propriétés, cliquez le bouton
pour afficher la liste des événements disponibles sur l’objet
Main
;
Pensez à vérifier que vous êtes bien sur le bon objet, dont le nom et le
type s’affiche dans la liste déroulante en haut
;
Dans la liste des événements disponibl
es, localisez l’événement
FormClosing
;
Faites un
double
-
clique
sur l’événement
FormClosing
dans la fenêtre
de
Propriétés
; Vous venez d’ajouter
la méthode de prise en charge de
l’événement
Main_FormClosing
au code de l’application
;
Maintenant, dans
le cas o
ù
des modifications ont été réalisées, il faut
afficher la boite de dialogue
; Nous allons donc ajouter et tester
une
variable de type booléen
dont la portée sera la totalité de la classe
Main
;
Dès qu’une modification va être apportée à une ligne
de=dçnnée猬snçus=
a獳楧ne牯ê猠 捥瑴e= îa物ab汥l
à= î
牡椠 E
t
rue
). Q
uand l’utilisateur fera une
獡uîega牤êⰠn
ous l’assignerons de nouveau à f
aux=E
f
alse
)
. Et le tour est
joué
!
Si ce n’est plus le cas, a
ffichez le code du formulaire
Main.cs
,
soit
en
faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
et en
sélectionnant le menu
Afficher le code
,
soit en cliquant sur l’onglet
Main.cs
de la zone de travail
;
Localisez le code où nous avions défini préalablement le membre privé
(variable)
nomFichier
;
il est normalement
juste avant
la définition du
constructeur de la classe
Main
;
Ajoutez le code
suivant pour définir un membre privé (variable) de
portée sur la totalité de la classe pour
indiquer
si des modifications ont
été apportées à
la liste de donn
ées
;
Code C#
p
ublic
partial
class
Main
:
Form
{
// Membres privés
private
string
nomFichier =
string
.Empty;
private
bool
desModificationsOntEteRealisees =
false
;
public
Main()
{
…
Liste déroulante
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
82
sur
91
Revenez maintenant à la méthode
Main_FormClosing
et ajoute
z
le
code suivant pour afficher une boite de dialogue dans le cas où des
modifications ont été apportées à la liste
;
Code C#
private
void
Main_FormClosing(
object
sender,
FormClosingEventArgs
e)
{
// Test si des modification
ont été apportées
if
(desModificationsOntEteRealisees)
{
if
(
MessageBox
.Show(
"Des modifications ont été réalisées. Voulez
-
vous quitter sans les sauvegarder ?"
,
"Confirmation"
,
MessageBoxButtons
.OKCancel,
MessageBoxIcon
.Q
uestion)
==
DialogResult
.Cancel)
// Annulation de la sortie
e.Cancel =
true
;
}
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Ensuite, il faut déterminer quand une donnée
a changé
: cette dernière
aura changé
quand une ligne
de la table de données a
changé (tiens
, on
utilise
quand
–
=
c’est don
c
=
un=éîénement
=
!
=
c昮=éage=PM
⤮
=
䑡as=污lmé瑨çde=
CreerTable
, nous allons donc connecter une méthode de réponse à
l’événement
RowChanged
sur notre objet
result
qui représente la table
de données
;
Comment connecter en code une méthode de répons
e à un événement
?
C’est vrai
I
=
橵獱u⟠= ma楮ienan琠nçu猠獯mme猠
éa獳ss
=
éa爠污l fenêt牥ê de=
é牯ê物é瓩猠su爠un=捯nt狴汥=éçu爠捯nne捴e爠de猠mé瑨çdes=de=êééçn獥猠à=
un=éîénemen琮=ja楳i 楬=e獴s éç獳楢汥=de=汥l 晡楲e=éa爠汥l 捯de=en=u瑩汩獡nt=
l’opérateur d’assignation po
u爠汥l=éîénemen瑳t
+=
, aussi appelé dans la
littérature
operateur de concaténation de délégué
(on verra cela plus en
détail dans le prochain atelier).
Localisez la méthode de création d’une nouvelle table de données
CreerTable
;
Positionnez vous juste
avant le retour de la valeur et ajoutez la ligne de
commentaire
;
Code C#
private
DataTable
CreerTable()
{
…
result
.Columns.Add(
new
DataColumn
(
"CA"
,
typeof
(
int
)));
// Définition de la méthode de réponse en cas de changement
// retour
de la valeur
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
83
sur
91
return
tableDeDonnees;
}
Commencez à taper la ligne
result.r
et aidez vous de l’IntelliSense
pour localiser l’évenement
RowChanged
;
Tapez maintenant l’opérateur +=
; L’IntelliSense vous propose
d’appuyer sur
TAB
pour insérer la bonne écriture de connexion de
l’événement (super, non
?)
Appuyez donc une première fois sur la touche TAB pour écrire la ligne
;
L’IntelliSense vous propose d’appuyer une deuxième
fois
sur
TAB
pour
générer la méthode de prise en charge de l’événement (là, c’est
carrément génial
!)
;
Appuyez donc une deuxième fois sur la touche
TAB
pour générer la
méthode de prise en charge de l’événement
; La méthode est
automatiquement générée
;
Code C#
void
result_RowChanged(
object
sender,
DataRowChangeEventArgs
e)
{
throw
new
Exception
(
"The method or operation is not implemented."
);
}
Détruisez la seule ligne de cette méthode (qui indique qu’elle n’a pas
encore été implémentée) et ajoutez le
code pour indiquer que des
modifications ont été apportées à la liste de données
;
Code C#
void
result_RowChanged(
object
sender,
DataRowChangeEventArgs
e)
{
throw new
Exception
(
"The method or operation is not implemented."
);
// Indique que des
modfications ont été apportées
desModificationsOntEteRealisees =
true
;
}
Reste à repasser la variable
desModificationsOntEteRealisees
à
f
aux
(
false
) quand la sauvegarde est réalisée, cette dernière opération étant
réalisée dans la méthode
SauverFichier
;
Il faudra aussi le faire lors de
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
84
sur
91
l’ouverture d’un fichier CSV (méthode
OuvrirFichier
) car
lors de la
lecture du fichier CSV, on ajoute les enregistrements et
l’événement
RowChanged
est déclenché !
Localisez la méthode de
sauvegarde
de
s
données
SauverFichier
;
Positionnez en tout début de méthode et ajoutez le code pour assigner
false
à la variable
desModificationsOntEteRealisees
;
Code C#
private
void
SauverFichier(
string
NomDuFichier)
{
// Indique que tout est sauvegardé (s'il
n'y a pas un bogue ...)
desModificationsOntEteRealisees =
false
;
// Utilisation d'un écrivain public !
using
(System.IO.
StreamWriter
streamWriter
…
Localisez la méthode
d’ouverture d’un fichier
de données
Ouvrir
Fichier
;
Positionnez
vous
en fin de méthode, avant le retour de valeur
,
et
ajoutez le même code que ci
-
dessus
;
Code C#
private
DataTable
OuvrirFichier(
string
NomDuFichier)
{
…
// Indique que tout est sauvegardé
desModificationsOntEteRealisees =
false
;
// renvoi de la valeur
return
result;
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Dans la barre d’outil de Visual C# Express, cliquez le bouton
pour
démarrer votre application en mode de débogage
;
Testez maintenant votre application en modifiant une ou deux lignes et
en sortant
: tout marche bien
!
2.
Indiquez l’icône et le nom du fich
ier
:
Bon, là il n’y a
灡é
=
î牡業en琠de=nçu
îeauté猬sma楳i捥污lme=捨ag物na楴
=
èue=
l’icône soit faux et que la barre de titre n’indique pas le nom du fichier
=
⡵E=
éeu=éeêfe捴楯nn楳瑥Ⱐ捥牴ê楮imen琩
⸠bn=捨a汬engeⰠîçu猠éçuîez=瑥n瑥爠de=
捯牲楧e爠捥猠éç楮i
s
=
îçus
J
淪
me= en= 狩flé捨楳獡n琠au= me楬汥lê
=
moyen d’y
a牲楶eê
=
.
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
85
sur
91
Affichez le code du formulaire
Main.cs
,
soit
en faisant
un
clic
-
droit sur
Main.cs
dans
l’
Explorateur de solutions
et en sélectionnant le menu
Afficher le code
,
soit en cliquant sur l’onglet
M
ain.cs
de la zone de
travail
;
Localisez la méthode
enregistrersousToolStripMenuItem_Click
;
Indiquez que la propriété
Text
du formulaire (
this
) est la concaténation
de son titre et du nom du fichier
;
Code C#
private
void
enregistrersousToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
SaveFileDialog
fileSave =
new
SaveFileDialog
())
{
…
if
(fileSave.ShowDialog() ==
DialogResult
.OK)
{
…
// Sauvegarde les
informations
SauverFichier(nomFichier);
// Indique le nom du fichier dans le titre
this
.Text
=
string
.Concat(
"Editeur du Coach C#"
,
"
-
"
, nomFichier);
}
}
}
Répétez la même opération pour la méthode d’ouverture de fichier
ouvrirToolStripMenuItem_Click
;
Code C#
private
void
ouvrirToolStripMenuItem_Click(
object
sender,
EventArgs
e)
{
using
(
OpenFileDialog
fileOpen =
new
OpenFileDialog
())
{
…
if
(fileOpen.ShowDialog() ==
DialogResult
.OK)
{
…
// Mémorise le nom du fichier
nomFichier = fileOpen.FileName;
// Indique le nom du fichier dans le titre
this
.Text
=
string
.Concat(
"Editeur du Coach C#"
,
"
-
"
, nomFichier);
}
}
}
Localisez le constructeur de la classe
Main
;
Juste en dessous de l’appel à
InitializeComponent()
, i
ndiquez que la
propriété
Icon
du formulaire (
this
) pointe
sur l’icône sauvegardé en
ressources ;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
86
sur
91
Code C#
public
Main()
{
…
InitializeComponent();
// Paramétrage de l'icone de la fenêtre
this
.Icon = Properties.
Resources
.lan_connected;
…
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Dans la barre d’outil de Visual C# Express, cliquez
le bouton
pour
démarrer votre application en mode de débogage
; On obtient bien
l’icône et le titre de la fenêtre avec le nom du fichier.
3.
Trappez les erreurs de la grille
:
Lorsqu’une erreur survient sur la grille, la boite suivante s’affiche
=
W
=
=
=
=
乯k猠s汬çns==mé污le爠êa爠êne=bç楴i⁰汵猠é牯ê牥êmme=汬e
J
捩
=
W
=
=
=
=
=
b琠au獳s
=
⡰çu爠汥l晵nF
=
ajouter une entrée dans le journal d’événement de
la machine, pour améliorer la maintenabilité de l’application.
=
=
Revenez sur le formulaire
Main.cs
en mode
[Design]
en cliquant sur
l’onglet
Main.cs [Design]
de la zone de travail
;
Faites un
clic
-
droit
sur la grille de données
et sélectionnez le menu
Propriétés
;
Dans la barre d’outils de la fenêtre de propriétés, cliquez le bouton
pour aff
icher la liste des événements disponibles sur l’objet
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
87
sur
91
mainDataFridView
; Pensez à vérifier que vous êtes bien sur le bon
objet, dont le nom et le type s’affiche dans la liste déroulante en haut
;
Dans la liste des événements disponibles, localisez l’événem
ent
DataError
;
Faites un
double
-
clique
sur l’événement
DataError
dans la fenêtre de
Propriétés
; Vous venez d’ajouter
la méthode de prise en charge de
l’événement
mainDataGridView_DataError
au code de l’application
;
Ajoutez à cette méthode le code pour
afficher le message d’erreur
;
Code C#
private
void
mainDataGridView_DataError(
object
sender,
DataGridViewDataErrorEventArgs
e)
{
// Affiche le message d'erreur
MessageBox
.Show(e.Exception.Message);
}
Sous la
dernière ligne insérée, faites un
clic
-
droit
et sélectionnez le
menu
Insérer un extrait…
;
Sélectionnez l’extrait de code
application
>
Write a message to the
Application Event Log
;
Remplacez
"ApplicationName"
par
"Coach C#"
;
Remplacez
"Action complete."
par
e.Exception.Message
;
Code C#
private
void
mainDataGridView_DataError(
object
sender,
DataGridViewDataErrorEventArgs
e)
{
// Affiche le message d'erreur
MessageBox
.Show(e.Exception.Message);
// Create the source, if it
does not already exist.
if
(!System.Diagnostics.
EventLog
.SourceExists(
"Coach C#"
))
{
System.Diagnostics.
EventLog
.CreateEventSource(
"Coach C#"
,
"Application"
);
}
// Create an EventLog instance and assign its source.
System.Diagnostics.
EventLog
myLog =
new
System.Diagnostics.
EventLog
();
myLog.Source =
"Coach C#"
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
88
sur
91
// Write an informational entry to the event log.
myLog.WriteEntry(e.Exception.Message);
}
Dans la barre d’outils de Visual C# Express, cliquez le bouton
pour
sauvegarder les modifications réalisées
;
Tapez la touche
F6
pour lancer la compilation du code
; Tout doit se
compiler correctement
;
Dans la barre d’outil de Visual C# Express, cliquez
le bouton
pour
démarrer votre application en mode de débogage
;
Dans l’
Editeur du Coach C#
, sélectionnez le menu
Fichier >
Nouveau
;
Déplacez le curseur sur le champ
CA
de la première ligne, et saisissez
une chaine de caractère
s
quelconque
, sans signifi
cation dans notre
contexte
;
Cliquez sur la deuxième ligne de la grille pour valider la saisie
; Le
message d’erreur apparaît
;
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
89
sur
91
Cliquez le bouton «
Ok
», puis la touche
Echappement
(
ESC
) pour
sortir de la saisie
; Fermez la fenêtre
de l’éditeur ;
Dans Windows XP, sélectionnez le menu
Démarrer > Panneau de
configuration > Outils d’administration > Observateur
d’événements
;
Sélectionnez les événements de type
Application
et
double
-
cliquez
sur celui
dont la source est
Coach C#
; Votre événement appar
aît
;
Fermez maintenant l’observateur d
’événement
; Et voilà, vous avez
ce
que l’on peut appeler une première application en C#.
Plutôt que d’écrire le message d’erreur uniquement, vous pouvez en
é牯f楴i爠éçu爠捯n捡téne爠d楦曩牥ête猠楮fçêma瑩
çn猠
捯mme=污l méthçde=èu椠
é污lte
, le nom de l’utilisateur, etc. enfin tout ce qui sera utile pour vous
a楤i爠êan猠sç瑲t⁴牡êa楬e=ma楮瑥nance.
=
=
=
=
BçnⰠe琠b楥n=îç楬àⰠnçu猠獯mme猠a牲楶é
s
=
à=污l f楮i de=捥=deux槨ie=a瑥汩e爮=
sçu猠aîez⃩瓩=fç牭idab汥l⡳EⰠ獩Ⱐsçu猠
avez tenu jusqu’à cette ligne
=
!⤮
=
=
Et l’air de rien, nous avons vu les types et les structures de base du C#,
瑯u琠en=déîe汯léan琠nç瑲t=楮ieê晡捥=u瑩汩獡瑥u爮êja楳i ne=îçu猠a牲
êtez=éa猠
泠l= 捯n瑩tuez
=
汥l 捯a捨Ⱐ 捡爠 ma楮瑥nan琠 nçu猠 a汬çn猠 îç楲= 捯mment=
mçdé汩獥
爠汥猠çb橥às
⸠bn=g牯猬=nçu猠a汬çn猠ma楮ienan琠捨ange爠汥l mçde=
de fonctionnement interne de l’application, sans impact sur l’interface
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
90
sur
91
utilisateur, et vous allez comprendre la puissance du C#
!
INSIA
2011
Prendre en main les applications winforms
Cours de C#
Page
91
sur
91
4
Pour aller plus loin…
4.1
Le
s
liens utiles
Pour avoir plus
d’informati
on concernant les bonnes règles à suivre pour le
développement
, voici
un lien intéressant
:
-
http://msdn2.microsoft.com/fr
-
fr/library/bb278146.aspx
, qui explique comment
révi
ser un code
;
4.2
Idée/ressourc
e
Si vous souhaitez
apprendre la programmation d’application Web avec C#, il existe le
Coach ASP.Net
:
http://www.microsoft.com/france/msdn/aspnet/coac
h/coach.mspx
Et pour bien gérer vos projets de développement, suivez le coach Visual Studio
Team System
:
http://www.microsoft.com/france/msdn/vstudio/teamsystem/evaluez/CoachVSTS.mspx
Comments 0
Log in to post a comment