LPIIICSharp 2022
LPIIICSharp 2022
LPIIICSharp 2022
LIKASI
Intitulé : Langage de programmation C#
Promotion : Troisième année de Graduat informatique de Gestion
Année : 2021-2022
Academique
Volume horaire : 45 Heures
Titulaire : POYO RAMAZANI Trésor
[email protected]
+243 99 378 58 97
Disponible sur rendez-vous
But : Ce cours de langage de programmation III, conçu pour l’apprentissage sur le
développement des applications informatiques en langage C#, est destiné
aux étudiants et étudiantes de Troisième graduat en informatique de gestion ;
il a pour objectif de fournir les connaissances approfondies sur la
programmation d’une manière générale mais aussi d’enrichir les niveaux de
connaissances sur la technologie de développement de Microsoft appelé
DotNet (.Net Framework) en particulier.
Objectifs : Ce présent cours préconise qu’à la fin de ces enseignements, chaque étudiant
spécifiques
devra être capable :
De comprendre et expliquer les préalables pour développer une
application DotNet ;
De développer une application console ou graphique (IHM) ;
De concevoir une application Orientée Objet par l’application des
principes des approches objet selon le consortium OMG ;
De manipuler ou Exploiter les données d’une base de données en
utilisant la technologie d’accès aux données ADO.net de Microsoft
au sein d’une application
I. Notions de base
a. Définition des variables
b. Conversion des types
c. Opérateurs usuels
d. Les Entrées/Sorties
e. Structure d’un Programme Csharp
II. Les Structures de contrôle
a. Les Structures Conditionnelles
b. Les Structures répétitives
III. Les Structures de données (Les tableaux)
a. Les vecteurs
b. Les Matrices
c. Les tableaux déchiquetés
Chapitre II les interfaces graphiques
I. Introduction
II. Description des contrôles de base
a. Introduction
b. Les contrôles
III. La boite de dialogue
IV. Le Formulaire
a. Les méthodes d’un formulaire
b. Les propriétés d’un formulaire
V. Le Formulaire MDI
VI. Lancer des Applications Externes
Chapitre III accès aux bases de données
I. Ado.net
a. Le Pilote
b. Accès à la BDD
II. Manipulation de données
a. Créer une Connexion
b. Etude de cas
Ressources : • Matérielles
◦ PC,
◦ Smartphone
• Logicielles
◦ OS : Windows 7 ,Windows 8, Windows10, Andoid
◦ Ms office Access
◦ Visual Studio 2015
INTRODUCTION
Le langage star de la nouvelle version de Visual Studio et de l’architecture .NET
est C#, un langage dérivé du C++. Il reprend certaines caractéristiques des langages apparus
ces dernières années et en particulier de Java (qui reprenait déjà à son compte des concepts
introduits par Smalltalk quinze ans plus tôt) mais très rapidement, C# a innové et les concepts
ainsi introduits sont aujourd’hui communément repris dans les autres langages.
C# est un langage récent. Il a été disponible en version beta successives depuis
l’année 2000 avant d’être officiellement disponible en février 2002 en même temps que la
plate-forme .NET 1.0 de Microsoft à laquelle il est lié. C# ne peut fonctionner qu’avec cet
environnement d’exécution. Celui-ci rend disponible aux programmes qui s’exécutent en son
sein, un ensemble très important de classes. En première approximation, on peut dire que la
plate-forme .NET est un environnement d’exécution analogue à une machine virtuelle Java.
On peut noter cependant deux différences :
En 2002, la plate-forme .NET ne s'exécutait que sur les machines Windows depuis
quelques années le langage permet d'utiliser la plate-forme .NET sur des OS tels
que Unix et Linux. La version actuelle de Mono (février 2008) supporte .NET 1.1
et des éléments de .NET 2.0 ;
La plate-forme .NET permet l'exécution de programmes écrits en différents
langages. Il suffit que le compilateur de ceux-ci sache produire du code IL
(Intermediate Language), code exécuté par la machine virtuelle .NET. Toutes les
classes de .NET sont disponibles aux langages compatibles .NET ce qui tend à
gommer les différences entre langages dans la mesure où les programmes utilisent
largement ces classes. Le choix d'un langage .NET devient affaire de goût plus que
de performances.
Pourquoi ce nom de C# ? Le C évidemment pour attester de l’appartenance au
monde C et C++. Et le # (croisillon) ? En notation musicale américaine, # indique « un ton au-
dessus ». On peut aussi voir dans # quatre + disposés en carré, ce qui évoque C++++, à la
signification évidente pour les programmeurs.
a. Le Framework
I. NOTIONS DE BASE
1. Types
En C#, il y a une nette distinction entre les types primitifs (int, char, boolean ...) et
les types construits (de sorte classe ou tableau) : seuls les types primitifs ont la notion de
“valeur” offerte par le langage, alors que les types construits n’offrent que des objets,
nécessairement manipulés par référence.
string : chaîne de caractères
char : caractères (Unicode, sur 16 bits, surensemble des char ASCII)
byte, short, int, long : nombres entiers 8, 16, 32 et 64 bits
boolean : booléen (valeurs true et false)
float, double : nombres flottants, simple et double précision
2. Déclaration :
La syntaxe pour déclarer une variable est la suivante :
Type identificateur ;
Exemple :
int Valeur ;
char Code ;
float Nombre ;
B. CONVERSION DE TYPES
Dans le tableau ci-dessus, on découvre qu'il y a deux types possibles pour un
entier sur 32 bits : int et Int32. Le type int est un type simple dont on ne manipule que la
valeur. Int32 est une classe. Un objet de ce type est complexe et possède des attributs et
méthodes. C# est amené à faire des conversion implicites entre ces deux types. Ainsi si une
fonction attend comme paramètre un objet de type Int32, on pourra lui passer une donnée de
type int. Le compilateur fera implicitement la conversion int -->Int32. On appelle cela le
"boxing" c.a.d. littéralement la mise en boîte d'une valeur dans un objet. L'inverse est
également vrai. Là où une fonction attend une valeur de type int, on pourra lui passer une
donnée de type Int32. La conversion se fera là encore automatiquement et s'appelle le
"unboxing". Les opérations implicites de boxing/unboxing se font sur les types suivants :
d=double.Parse(k);//String to double
f=float.Parse(k);//String to float
String a, b;
int c;
c= Int32.Parse(a) + Int32.Parse(b);
- Math.Max() : Fonction qui nous donne la possibilité d’évaluer la plus grande valeur
parmi deux passées en paramètre. Math.Max(decimal1,decimal2);
- Math.Min() : Fonction qui nous donne la possibilité d’évaluer la plus petite valeur
parmi deux passées en paramètre. Math.Min(decimal1,decimal2) ;
- Math.Log10() : Fonction qui retourne le logarithme d’un nombre en base 10.
Math.Log10(double) ;
- Math.pow() : Fonction qui retourne la puissance d’une valeur quelconque.
Math.pow(double1,double2) ;
- Math.sqrt() : Fonction qui retourne la racine carré d’une valeur passée en paramètre.
Math.sqrt(double) ;
1. Les sorties
Ici il s’agit de l’instruction qui nous permet d’écrire à l’écran; il s’agit içi d’une
chaine de caractère, de la valeur d’une variable ou de tous les trois éléments.
Sur ce, l’instruction qui nous permet d’écrire à l’écran est « Console ». La classe
System.Console donne accès aux opérations d'écriture écran à (Write, WriteLine). La classe
Console a deux propriétés Out et Error qui sont des flux d'écriture de type TextWriter :
Exemple :
1. Afficher le message Bonjour SISABIDIMBO ;
Console.Out.WriteLine("Bonjour SISABIDIMBO?");
2. Les Entrées
Un programme est développé pour être utilisé par les utilisateurs (la personne
autre que celle qui l’a créée), dans cette sémantique les données qu’il utilise proviennent de
son environnement extérieur (périphériques d’entrées).
De ce fait, le programmeur a tout intérêt de développer un programme demandant
les données à l’utilisateur d’autant plus qu’il ne connaît la sorte de données ce dernier aura à
utiliser.
L’instruction qui nous permet de recevoir les données provenant des périphériques
d’entrées est la suivante :
Console.in.ReadLine() ;
Le flux de données provenant du clavier est désigné par l'objet Console.In de type
TextReader. Ce type d'objets permet de lire une ligne de texte avec la méthode ReadLine
Console.ReadLine();
La classe Console offre une méthode ReadLine associée par défaut au flux In.
NB :
Tandis que la couleur de la police d’écriture, nous utilisons l’instruction suivante :
Console.ForegroundColor = ConsoleColor.Red;
b. Le Titre de l’application
Par défaut, l’application prend le nom du projet. Juste après l’exécution de
l’application, nous constatons dans la barre de titre le nom du projet apparaître. Pour changer
le nom de l’application, nous utilisons la méthode title de la console comme nous montre
l’exemple suivant :
Console.Title = "G3Info/USCV";
4. Le beep System
.NET version 2 a amélioré les affichages en mode console, mais il a aussi
introduit des effets sonores dans la classe Console. Ces effets peuvent également être produits
dans les programmes Windows. Il ne s’agit cependant pas ici de jouer des fichiers de musique
aux formats wav ou mp3.
Pour réaliser cette opération, nous faisons recours à la méthode beep, de la même
classe ; dont la syntaxe est la suivante :
Console.Beep();
Remarque : Il peut arriver que nous voulions spécifier la fréquence du beep ainsi que la
durée de ce beep. Dans ce cas, la méthode prend alors deux arguments dont la première c’est
la fréquence et le second c’est la durée de la fréquence.
Console.Beep(1000,900);
3. La méthode principale :
Cette méthode est la méthode principale (main in english) de votre programme, c’est
ici que vous placerez les actions à faire exécuter à C#. Le mot clé static indique au
compilateur que la méthode Main est globale et que, par conséquent, il est inutile
d’instancier la classe qui contient cette méthode pour pouvoir appeler la méthode.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
static void Main(string[] args)
{
Int a, b, c;
Console.WriteLine ("Entre le nombre1");
a =int.Parse (Console.In.ReadLine());
Console.WriteLine ("Entre le nombre2");
b=int.Parse (Console.In.ReadLine());
c=a+b;
Console.WriteLine ("la somme est "+c);
Console.ReadLine ();
}
}
}
a. If Sans Alternative
Syntaxe :
If (condition)
{
Instruction ;}
Exemple 1:
Concevez un petit programme qui saisit un entier au clavier vérifie si l’entier saisi
est positif et confirme le texte « L’entier est positif ».
class Program
{
static void Main(string[] args)
{
Exemple 2. :
Concevons une application CSharp qui demande à l’utilisateur une chaîne de
caractère qui doit être équivalente à « LOL » si la chaîne saisie est différente de cette dernière
le programme doit afficher le message « mdp incorrect ».
class Program
{
static void Main(string[] args)
{
string mdp;
Console.Write("La Première valeur SVP: ");
mdp=Console.In.ReadLine();
if (mdp != "LOL")
{
Console.Write("Le mdp est incorrect");
}
Console.ReadLine();
b. If Avec Alternative
Syntaxe :
if (condition)
{
une ou plusieurs instructions;
}
Else
{
Une autre Instruction ;
}
Exemple
En considérant l’exemple sur l’entier positif ; concevons une application qui
exerce la même tâche mais qui affiche le message « L’entier est négatif » dans le sens où il
n’est pas positif.
class Program
{
static void Main(string[] args)
{
int a;
Console.Write("Introduisez l'entier SVP: ");
a=int.Parse(Console.In.ReadLine());
if (a > 0)
{
Console.Write("L'entier saisi est positif ");
}
else
{
Console.Out.WriteLine("L'entier est negatif");
}
Console.ReadLine();
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
static void Main(string[] args)
{
int a;
Console.WriteLine("Entre le nombre1");
a = int.Parse(Console.In.ReadLine());
if (a < 0)
{
Console.WriteLine(a + "Est negatif");
}
else
{
Console.WriteLine(a + " Est positif");
}
Console.In.ReadLine();
}
}
}
2. Le Switch
Le Switch est une instruction permettant de sélectionner un cas selon la valeur
d'une variable entrée. La syntaxe est la suivante :
Syntaxe :
Switch (valeur)
{
Exemple :
Soit à demander une valeur à l’utilisateur de 1 à 12 ; d’afficher « Janvier » si la
valeur saisie est 1, « Février » si la valeur saisie est 2, « Mars » si c’est 3, « Avril » si c’est
4,… « Décembre » si c’est 12 dans le cas contraire le programme doit afficher le message
« Le numéro ne correspond à aucun mois ».
class Program
{
static void Main(string[] args)
{
int m;
Console.Out.Write("Saisissez votre Numéro :");
m = int.Parse(Console.In.ReadLine());
switch (m)
{
case 1: Console.Out.WriteLine("Janvier"); break;
case 2: Console.Out.WriteLine("Février"); break;
case 3: Console.Out.WriteLine("Mars"); break;
case 4: Console.Out.WriteLine("Avril"); break;
case 5: Console.Out.WriteLine("Mai"); break;
case 6: Console.Out.WriteLine("Juin"); break;
case 7: Console.Out.WriteLine("Juillet"); break;
case 8: Console.Out.WriteLine("Août"); break;
case 9: Console.Out.WriteLine("Septembre"); break;
case 10: Console.Out.WriteLine("Octobre"); break;
case 11: Console.Out.WriteLine("Novembre"); break;
case 12: Console.Out.WriteLine("Décembre"); break;
1. While
Exemple
Développez une application Csharp permettant d’afficher les entiers contenus
entre 1 et 50, tout en utilisant la structure répétitive WHILE.
class Program
{
static void Main(string[] args)
{
int rmz;
rmz = 1;
while (rmz <=50)
{
Console.Write(rmz +"; ");
rmz ++;
}
Console.ReadLine();
}
}
Exemple2
Proposez un algorithme permettant de demander la saisie d’une chaine
quelconque. Tant que la chaine saisie n’est pas correcte que le programme continue à en
demander.
class Program
{
static void Main(string[] args)
{
bool v = false;
string p;
while(v==false)
{
Console.Write("Saisir un entier");
p=Console.ReadLine();
v=p.Equals("bonjour");
}
Console.WriteLine("vous avez réussi");
Console.ReadLine();
}
}
Using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
static void Main(string[] args)
{
int i,n,som;
Console.WriteLine("Entre le nombre1");
n = int.Parse(Console.In.ReadLine());
som=0;
i = 1;
while (i <= n)
{
som = som + i;
i++;
}
Console.WriteLine("le 10 nombres suivant sont" + som);
Console.In.ReadLine();
}
}
}
2. do ... while
do
{
<instructions >
}
while (< condition >);
Le fonctionnement est analogue à celui de la boucle tant que à quelques détails
près :
La condition est évaluée après chaque passage dans la boucle.
On exécute le corps de la boucle tant que la condition est vérifiée.
En C, la boucle répéter ... jusqu'à est en fait une boucle répéter ... tant que, c'est-à-
dire une boucle tant que dans laquelle la condition est évaluée à la fin. Une boucle do ... while
est donc exécutée donc au moins une fois.
Exemple : soit à faire un programme qui demande un nombre de depart et calculi la somme
des entiers jusqu’à ce nombre
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int i, n, som;
Console.WriteLine("Entre le nombre1");
n = int.Parse(Console.In.ReadLine());
som = 0;
i = 1;
do
{
som = som + i;
i++;
}
while (i <= n);
}
}
}
3. For
Cette boucle est quelque peu délicate. Commençons par donner sa syntaxe :
for (< initialisation > ; <condition > ; <pas >)
{
<instructions >
}
Instructions ici
}
Exemple :
Prenons en compte l’exemple précèdent (qui affiche les entiers impaires) ; cette
fois concevons celui qui affiche les entiers paires contenus dans le même intervalle d’entiers.
Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers
jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
static void Main(string[] args)
{
int i, n,som;
Console.WriteLine ("Entre le nombre1");
n = int.Parse (Console.In.ReadLine ());
som=0;
for (i = 1; i <= n; i++)
{
som = som + i;
}
Console.WriteLine("le 10 nombres suivant sont" + som);
Console.In.ReadLine();
}
}
}
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres
de 18 à 27.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
static void Main(string[] args)
{
int i,n;
Console.WriteLine("Entre le nombre1");
n = int.Parse(Console.In.ReadLine());
Console.WriteLine("le 10 nombres suivant sont");
for (i = n + 1; i <= n + 10; i++)
{
Console.WriteLine("le 10 nombres suivant sont" + i);
}
Console.In.ReadLine();
}
}
}
A. LES TABLEAUX
Le cours n’a, jusque-là, parlé que de variables simples, c’est – à – dire de
variables constituées d’une seule zone – mémoire, ne pouvant contenir qu’une seule donnée
(un numérique entier, un numérique réel, un caractère…). Ainsi il était difficile de faire
plusieurs opérations sur plusieurs valeurs préalablement saisies (ex : faire la somme de 10
nombres, afficher la somme, puis les nombres, puis faire le produit…). C’est ainsi que vient la
notion de tableaux. Ce sont des types de variables composées qui peuvent contenir plusieurs
valeurs. Ils sont composés des types de valeurs introduites généralement dans les variables
vues précédemment (numériques,caractères…).
Nous définissons un tableau comme étant un ensemble ou collection des données
de même nature, manipulable par un identificateur et accessible par des numéros appelés
indices.
Nous trouvons deux types de tableaux, les tableaux à une dimension et les
tableaux à plusieurs dimensions.
i. Déclaration du Tableau
Syntaxe :
type[] identificateur=new type[taille] ;
Exemple :
int[] tab=new int[3];
N.B :
Apres la déclaration du tableau, notons que le premier élément du tableau est à
l’indice 0 et le dernier élément du tableau est à l’indice taille du tableau – 1.
tab[0] = 20;
Exemple :
int[] tab = { 20, 40, 60, 70 };
Cette instruction permet de déclarer le tableau tab et de l’initialiser par les 20, 40,
60 et 70.
Exemple :
Soit à faire un programme en langage Csharp demandant à l’utilisateur trois
entiers stocker dans un tableau et qui fait leur somme et affiche le résultat.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int []tab= new int[3];
int s;
Console.WriteLine("Entrer le nombre");
tab[0] = int.Parse(Console.In.ReadLine());
tab[1] = int.Parse(Console.In.ReadLine());
tab[2]=int.Parse(Console.In.ReadLine());
s=tab[0]+tab[1]+tab[2];
}
}
}
Écrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau.
Le programme doit afficher le nombre d'entiers supérieurs ou égaux à 10.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int[] t = new int[10];
int i, nb=0;
int n = 10;
for (i = 0; i < n; i++)
{
Console.WriteLine("Entrer un entier");
t[i] = int.Parse(Console.In.ReadLine());
}
for (i = 0; i < n; i++) if (t[i] >= 10) nb++;
}
}
}
Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau.
Le programme doit ensuite afficher l'indice du plus grand élément.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int[] t = new int[10];
int i, indice;
int n = 10;
for (i = 0; i < n; i++)
{
Console.WriteLine("Entrer un entier");
t[i] = int.Parse(Console.In.ReadLine());
}
indice = 0;
for (i = 1; i < n; i++)
if (t[indice] < t[i] ) indice=i;
Console.WriteLine( "L'indice du plus grand élément est : " +indice);
Console.ReadLine();
}
}
// Cette instruction permet la déclaration d’un tableau de plusieurs dimensions ayant deux
lignes et trois colonnes.
b. Déclaration et initialisation
Type [ , ] tableau = {{val1, val2, valn}, {val1, val2, valn},…};
Exemple :
int[ , ] t = {{1, 2, 3}, {4, 5, 6}};
Exemple
Proposez un programme qui crée et initialise une matrice carrée, qui calcul et
affiche le produit des éléments de la première ligne.
class Program
{
static void Main(string[] args)
{
int[,] t = { { 8, 2}, { 4, 5 } };
int p = 1, s = 0;
for (int i = 0; i <= 1; i++)
{
p = p * t[0,i];
}
I. INTRODUCTION
Microsoft propose un ensemble des classes permettant de faciliter la
programmation Windows. La majorité d’entre elles se trouve dans l’espace de nom :
System.windows.Forms. Visual Studio (l’architecture .NET de manière générale) est livré
avec toute une série de composants prêts à l’emploi : boutons, cases à cocher et d’option,
boîtes de liste, zone d’édition, etc.
Ces composants sont amenés dans la fenêtre de développement de manière aussi
simple qu’intuitive, par un glisser-coller à partir de la boîte à outils jusqu’à la fenêtre de
développement. Une fois le composant déposé dans la fenêtre de développement, il ne reste
plus qu’à modifier ses propriétés. Pour cela, il faut connaître les propriétés de chaque classe
de composant (classe Button pour les boutons de commande, classe ListBox pour les boîtes de
liste, etc.). Heureusement, tous ces composants ont donc beaucoup de propriétés communes.
A. INTRODUCTION
B. LES CONTROLES
1. Le Bouton de commande
Les boutons de commande vous sont tellement familiers qu’ils n’ont pas besoin
d’une présentation particulière. Ce sont des objets de la classe Button. Faites du glisser-
déposer (drag and drop) pour avoir le bouton sur le formulaire. Dès que le bouton est sur le
formulaire, un ensemble des propriétés sont alors disponible permettant de modifier l’Etat de
l’application.
a. Name
Elle donne un nom interne significatif qu’on pourra utiliser dans les codes.
b. Text :
Elle permet de modifier le libellé sur le contrôle ; en d’autres termes elle change le
texte de dessus d’un contrôle.
d. Cursor
Forme que prend le curseur de la souris lorsqu’il survole le bouton.
e. Enabled
Propriété permettant d’activer ou désactiver le contrôle. Si la propriété Enabled
vaut false, le bouton est grisé et est sans effet. Un clic sur le bouton n’a alors aucun effet.
f. FlatStyle
Si la propriété Enabled vaut false, le bouton est grisé et est sans effet. Un clic sur
le bouton n’a alors aucun effet.
g. Visible
Indique si le bouton doit être affiché ou non. Tout en sachant qu’elle est du type
booléen.
N.B :
L’événement le plus traité (généralement même le seul) dans le cas d’un bouton
de commande est l’événement Click. Comme le clic est l’événement par défaut pour le
bouton, un double-clic génère la fonction de traitement du bouton. Mais on pourrait aussi
passer par l’événement Click de la fenêtre des propriétés (onglet Evénements).
N.B :
Généralement, un programme ne traite pas les événements liés à une case à cocher
: il laisse faire l’utilisateur et se contente de lire l’état des cases quand il a besoin de
l’information (c’est le cas quand AutoCheck vaut true, true étant la valeur par défaut de cette
propriété). On peut cependant imaginer qu’un programme réagisse immédiatement à un
changement d’état d’une case, généralement pour vérifier si le nouvel état de la case est
compatible avec d’autres informations (par exemple passer à l’état veuf pour un célibataire).
Pour cela, on traite l’un des trois événements présentés ci-après. Les autres
événements ne présentent quasiment aucun intérêt.
Les cases d’option ou bouton radio (radio buttons) présentent, à une exception
près. Les mêmes propriétés et les mêmes méthodes de traitement d’événements que les cases
à cocher. Une case d’option ne passe cependant pas par le troisième état (estompé) et ne
connaît donc pas les propriétés ThreeState et CheckState. Le fait qu’une case d’option soit
cochée ou non est contrôlé par la propriété Checked qui prend la valeur true si la case est
cochée ou false si elle ne l’est pas.
Les cases d’option sont des objets de la classe RadioButton, dérivée de
ButtonBase comme les boutons et les cases à cocher. Seul l’événement CheckedChanged
présente de l’intérêt. Il est signalé quand la case d’option change d’état. Bien souvent, les
cases d’option sont placées dans un groupe. Dans ce cas, seule une case d’option du groupe
peut être cochée à un moment donné. Si vous cliquez sur une case d’option qui fait partie d’un
groupe, les opérations suivantes sont automatiquement réalisées : la case d’option qui était
cochée ne l’est plus et celle sur laquelle vous avez cliqué devient la case cochée.
La boite à liste Combo est une catégorie de liste utilisée fréquemment en outrance
de List qui est elle-même de la classe ListBox ; tandis que Combo est de la classe ComboBox.
Voici les propriétés vitales de ce contrôle.
a. Items
Elle renvoie la liste des libellés d’articles au sein du ComboBox.
b. MaxLength
Nombre maximal de caractères qui peuvent être introduits dans la zone d’édition
de la boîte combo (aucune limite si MaxLength contient 0).
c. SelectedIndex
Elle renvoie l’index de l’item (élément) sélectionné au sein du combo.
d. SelectedItem
Elle renvoie l’item ou l’élément sélectionné au sein du Combo.
NB :
Il existe certaines méthodes qu’on effectue sur les éléments du combo. Entre autres :
RemoveAt(Index) qui spécifie l’index de l’élément à supprimer ; Remove(Item) qui
précise l’élément à supprimer ; Add(’’Item’’) l’ajout d’un élément dans la collection ;
Clear() nettoye ou supprime tous les éléments d’un combo.
Exemple : ComboBox1.Items.Add(’’toto’’) ; ComboBox1.Items.Clear() ;
Nous trouvons aussi un ensemble des évènements susceptibles d’être utilisés sur un
ComboBox à savoir : TextChanged : Le contenu de la partie zone d’édition a changé
(suite à une nouvelle sélection ou parce que la zone d’édition est en train d’être
éditée). SelectedIndexChanged : Sélection d’un nouvel article à l’aide de la souris
mais aussi chaque fois que l’utilisateur passe sur un autre article à l’aide des touches
de direction.
5. Etiquette
Une zone d’affichage (encore appelée étiquette ou label) sert à afficher du texte.
Elle peut servir de libellé ou être associée à un autre composant, généralement une zone
d’édition. La zone d’affichage sert alors d’étiquette ou de titre pour la zone d’édition. Une
zone d’affichage peut être initialisée et modifiée par un programme (propriété Text). Elle ne
peut cependant pas être modifiée par l’utilisateur. Le texte de la zone d’affichage peut être
affiché. Elle contient aussi un ensemble des propriétés permettant de l’utiliser.
a. BackColor
Elle change la couleur de font de l’étiquette.
6. Le Lien
Les contrôles LinkLabel sont également des zones d’affichage (la classe
LinkLabel est dérivée de Label), mais elles présentent les caractéristiques d’un bouton
(événement LinkClicked). Tout le texte du contrôle (propriété Text), ou une partie seulement,
peut servir d’hyperlien (propriété LinkArea). Le texte peut même comprendre plusieurs
hyperliens (propriété Links utilisable par un programme uniquement, voir exemple). Voici les
propriétés majeures au sein de ce contrôle.
a. LinkArea
Portion du texte qui doit être considérée comme un hyperlien. Un objet LinkArea
peut être construit en spécifiant deux arguments de type int : Start et Length. La classe
LinkArea contient d’ailleurs ces deux propriétés :Start et Length
b. LinkBehavior
c. LinkColor
Elle modifie la couleur d’affichage de l’hyperlien.
NB :
L’événement important est LinkClicked qui correspond au clic sur la partie
hyperlien de la zone de texte. Un objet LinkLabelLinkClickedEventArgs est passé en second
argument de la fonction de traitement. Cet argument contient une propriété Link qui elle-
même contient les propriétés Start, Length, Visited et LinkData.
Si nous voulons lancer le demarrage d’un site Internet, nous aurons les
instructions qui suivent :
using System.Diagnostics;
namespace ExerG3
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
Process.Start("www.developpez.com");
}
}
}
7. La Zone d’Edition
Les zones d’édition (ou text box) permettent de saisir du texte, comme, un nom ou
une adresse, par exemple. Au vu de leurs possibilités, on peut presque considérer que
Windows incorpore un traitement de texte rudimentaire pour ces zones. Elles permettent, sans
avoir à écrire la moindre ligne de programme :
• De déplacer le curseur par les touches de direction ;
• D’insérer et de supprimer des caractères, avec traitement de la touche backspace ;
• De sélectionner une partie de texte, le texte sélectionné apparaissant en inverse vidéo et
pouvant être supprimé par la touche SUPPR ou copié à un autre emplacement ;
• De faire défiler automatiquement le texte (autoscroll en anglais) si la zone d’édition n’est
pas de taille suffisante pour le texte ;
• D’étendre le texte sur plusieurs lignes, avec défilement vertical automatique.
Voici les différentes propriétés pour répondre à ses exigences :
a. BorderStyle
Type de contour de la zone d’édition : encadré ou non.
b. CharactereCasing
Type de caractères que l’on peut taper dans la zone d’édition : minuscules
seulement, majuscules seulement ou n’importe quel caractère. Les caractères non conformes
sont automatiquement convertis.
c. MaxLength
Nombre maximal de caractères que l’utilisateur peut introduire dans la zone
d’édition. Si MaxLength vaut 0, il n’y a aucune limite.
d. Multiline
Indique s’il s’agit d’une zone d’édition multilignes.
e. PasswordChar
Caractère qui remplace (pour l’affichage uniquement) les caractères tapés au
clavier. Cette propriété est donc utile pour les zones d’édition (d’une seule ligne uniquement)
servant à l’introduction de mots de passe. PasswordChar peut contenir n’importe quelle lettre,
y compris un espace blanc (d’ailleurs préférable, car il ne laisse pas deviner le nombre de
caractères du mot de passe) :
f. ReadOnly
Indique si la zone d’édition est protégée contre les modifications effectuées par
l’utilisateur (cette restriction ne concerne que l’utilisateur). Par programme, il est toujours
possible de modifier une zone d’édition, quelle que soit la valeur de sa propriété ReadOnly.
g. ScrollBars
Indique quelles barres de défilement sont éventuellement affichées. Scroll-Bars
peut prendre l’une des valeurs suivantes de l’énumération ScrollBars : None aucune barre de
défilement ; Horizontal barre horizontale (celle-ci n’est cependant pas affichée si la propriété
WordWrap vaut true) ; Vertical barre verticale ; Both les deux barres de défilement sont
affichées.
h. Text
Elle permet d’octroyer à la zone d’édition (zone de texte) un texte quelconque.
i. TextAlign
Cadrage du texte dans la zone d’affichage. TextAlign peut prendre l’une des
valeurs suivantes de l’énumération HorizontalAlignment : Center : texte centré ; Left : texte à
gauche ; Right : texte à droite.
j. WordWorap
Indique s’il y a passage automatique à la ligne suivante quand le bord de droite de
la zone d’édition est atteint (ne s’applique qu’aux zones multilignes). Sinon (si WordWrap
vaut false), il y a défilement du texte.
8. Le Menu
A. LA CLASSE MESSAGEBOX
La classe MessageBox, bien que ne comprenant qu’une seule fonction utile (sa
fonction statique Show) permet d’afficher une boîte de dialogue simple mais limitée pour
signaler un problème ou demander confirmation à l’utilisateur.
Nous trouvons la méthode show au sein de cette classe. Cette méthode permet
d’afficher une boite de dialogue avec plusieurs arguments. Le nombre (4 au maximum)
d’arguments à utiliser est facultatif selon le besoin du développeur.
Syntaxe :
MessageBox.Show("string msg", "titre", MessageBoxButtons, MessageBoxIcon);
Où :
- String msg : Représente le message qui devra s’afficher ;
- Titre : Représente le texte qui devra apparaître dans la barre de titre ;
- MessageBoxButtons : Représente les boutons susceptibles d’apparaître sur la fenêtre.
Nous trouvons les catégories des boutons suivants :
o AbortRetryIgnore : Les boutons Abandonner, Réessayer et Ignorer
sont affichés ;
o OK : Seul le bouton OK est affiché ;
o OKCancel : Les boutons OK et Annuler sont affichés ;
o RetryCancel : Les boutons Réessayer et Annuler sont affichés ;
o YesNo : Les boutons Oui et Non sont affichés ;
o YesNoCancel : Les boutons Oui, Non et Annuler sont affichés.
- MessageBoxIcon : Représente le type d’icone qui sera utilisée dans la boite. Pour
les icones, nous avons aussi Asterisk, Error, Exclamation, Hand, Information, None,
Question, Stop et Warning.
Remarque :
Pour ce qui concerne les boutons, si l’on veut récupérer le bouton appuyé sur la
boite de dialogue, nous utilisons une variable du type DialogResult. Comme nous montre
l’exemple suivant : DialogResult r= MessageBox.Show("bonjour cliques sur un bouton", "Info",
MessageBoxButtons.OKCancel,MessageBoxIcon.Asterisk);
IV. LE FORMULAIRE
Un formulaire est une fenêtre qui a la possibilité de stocker les objets ou les outils
à savoir ; les zones de texte, bouton, label, etc. Une fois créer un projet Windows, Visual
Studio vous crée le premier formulaire que vous pouvez vous-même manipuler. Tandis que si
vous voulez en insérer d’autres, plusieurs possibilités sont offertes. L’une d’elles est d’aller
dans le menu Project et puis sur l’option Add_Windows_Form.
1. La Méthode Close()
Cette méthode nous permet de fermer un formulaire. Dans cette rubrique nous
trouvons aussi la méthode Dispose() qui fait quasiment la même chose. Voici un exemple :
this.Close();
Ou bien
this.Dispose();
2. La Méthode Hide()
Elle (méthode) permet de cacher un formulaire pour permettre un bon
basculement entre les différents formulaires.
this.Hide();
3. La Méthode Show()
Est une méthode la plus utilisée dans l’interdépendance des fenêtres dans la
programmation. Elle permet d’afficher un formulaire. Voici un exemple plus concret.
frm.Show();
10. WindowState :
Elle Spécifie l’état du formulaire lors du démarrage. Soit le formulaire devra
s’afficher normalement avec la taille de sa conception, soit réduit à la barre de tâche ou bien
en plein écran.
Une fenêtre MDI (pour Multiple Document Interface en anglais) est formée d’une
fenêtre « parent MDI » et de zéro, une ou plusieurs (le plus souvent) fenêtres enfants, dites
MDI Children.
Excel, mais aussi Visual Studio, présentent une telle interface. Le Bloc-notes est
au contraire un exemple de fenêtre SDI (SDI pour Single Document Interface). Avec le Bloc-
notes, on ne peut travailler que dans une seule fenêtre.
Les fenêtres MDI présentent les caractéristiques suivantes :
- Toutes les fenêtres enfants sont affichées à l’intérieur de la fenêtre parent ;
- Les fenêtres enfants peuvent être déplacées mais uniquement à l’intérieur de la fenêtre
parent ;
- Les fenêtres enfants peuvent être réduites en icône mais les icônes de ces fenêtres
enfants sont affichées dans la fenêtre parent, jamais dans la barre des tâches ;
- Si une fenêtre enfant est agrandie au maximum, elle occupe toute l’aire client de la
fenêtre parent et le titre de la fenêtre enfant est ajouté à celui de la fenêtre parent ;
- Le menu de la fenêtre enfant active s’insère dans celui de la fenêtre parent.
NB :
L’utilisation de la fenêtre MDI suit la procédure suivante :
1. Créer les différentes fenêtres ou formulaire ;
2. Préciser la fenêtre MDI en octroyant la valeur booléenne true à la propriété
IsMDIContainer la fenêtre sensée jouer le rôle de la fenêtre parent ;
3. Ajouter les fenêtres enfants à la fenêtre parent en utilisation la syntaxe :
FormEnfant k = new FormEnfant();
k.Text = "Multiplication ";
k.MdiParent = this;
k.Show();
S’il faut expliquer; la première ligne permet de créer un objet du type fenêtre qui s’appelle
FormEnfant. La deuxième donne le texte qui devra s’afficher dans la barre de titre. La
troisième permet d’affecter l’objet (donc la fenêtre) à la fenêtre parent ; et l’ultime, permet
d’afficher la fenêtre enfant.
4. Faire la même chose (la troisième opération) pour l’ensemble des fenêtres filles. Il est
à noter que chaque, fenêtre devra avoir une option permettant de l’afficher.
REMARQUE : Ainsi, nous proposons ici un projet qui crée une calculatrice dont voici.
Cette application possède aussi 16 boutons dont les dix chiffres (de 0 à 9) les
opérateurs arithmétiques (addition, soustraction, division, multiplication), un bouton d’égalité
(sur lequel nous devons programmer tout les calculs) et un bouton qui permet d’initialiser les
calculs. Outre les boutons nous avons la zone d’affichage appelée zone de texte qui nous
permet de rendre visible toutes les opérations.
Affichage Calculatrice
Nous avons raisonné de la sorte, qu’une fois cliquer sur un opérateur, que l’on
puisse saisir l’opérateur dans une variable, l’on récupère la valeur qu’il y a dans la zone de
texte et qu’on affecte dans une variable publique de la manière suivante :
public Form1()
{
InitializeComponent();
}
textBox3.Text = textBox3.Text + 1;
}
{
b = textBox3.Text;
textBox3.Text = "";
if (operat == "+")
{
c = a + b;
textBox3.Text = c;
}
if (operat == "*")
{
c = a *b;
textBox3.Text = c;
}
if (operat == "/")
{
c = a / b;
textBox3.Text = c;
}
if (operat == "-")
{
c = a - b;
textBox3.Text = c;
}
}
}
A partir d’un programme CSharp, il est possible de pouvoir exécuter une autre
application externe ; en l’occurrence celles qui viennent avec le système d’exploitation et
même celles qui sont indépendants des Windows (installées indépendamment du système
d’exploitation). Ainsi plusieurs procédures utilisables pour réaliser cette opération ; dans ce
cours, nous maintenons celle qui consiste à utiliser la classe « PROCESS », avec la syntaxe
suivante :
System.Diagnostics.Process.Start("NOM DE L’APPLICATION");
En guise d’exemple, soit à proposer une application qui permet de lancer le
programme WIN WORD à partir d’une application CSharp.
System.Diagnostics.Process.Start("WINWORD.exe");
REMARQUE :
Il y a aussi moyen d’utiliser un utilitaire qui vient avec le système d’exploitation
qui a la possibilité de fermer un ordinaire d’une manière automatique. Comme nous montrent
les codes suivants.
private void button1_Click(object sender, EventArgs e)
{
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication6
{
public partial class Form1 : Form
{
int time = 0;
public Form1()
{
InitializeComponent();
}
I. ADO.Net
Pour qu’une application accède à la base de données dans les technologies
DotNet, elle est appelée à passer par la couche logicielle appelée ADO.Net. ADO est un sigle
qui signifie ActiveX Data Objet, est un environnement qui permet de donner accès à la
manipulation des données au sein d’une application. Csharp étant un langage de
programmation de cette génération DotNet, il utilise aussi cette couche qui est par moment
considérée comme SGBD (Système de Gestion de Base de Données) virtuel de la plateforme
.Net.
ADO.Net est un ensemble de classes qui exposent les services d’accès aux
données pour les programmeurs .NET Framework. Il permet d’accéder à des données
relationnelles, XML et d’application. Vu cet ensemble des fonctionnalités qu’il donne,
ADO.net est considéré par moment comme langage (regorgeant un ensemble des signes pour
communiquer), dans le sens qu’il permet l’ouverture, l’interrogation, la modification d’une
base de données quel que soit le Système de Gestion de Base de données sur lequel la BDD
est implémentée.
Pour avoir accès aux données, votre application devra charger les pilotes (ou
Providers). Etant dans la diversité des SGBD, chacun d’entre eux propose son pilote
permettant d’accéder à ses bases de données.
A. LE PILOTE (provider)
N.B :
Il existe plusieurs types de pilotes utilisés dont deux d’entre eux sont les utilisés
pour accéder à une base de données ; à savoir :
Le pilote ODBC (Open DataBase Connectivity) : est un pilote permettant à une
application d’accéder à une base de données.
Le pilote OLEDB (Object Linking Embedding): est un pilote mise au point par la
société Microsoft pour accéder à une source de données, tout en gardant le lien avec la
source de données qu’on pourra appeler pour une éventuelle modification ou mise à
jour.
Il existe deux modes d’accès à une base de données ; le mode connecté et le mode
déconnecté.
1. Le Mode Connecté
L’utilisation du mode connecté est une opération qui consiste à manipuler la base
de données en lecture/écriture tout en maintenant la connexion à celle-ci. Voici la procédure :
Ouvrir une connexion avec la source de données
Travailler avec la source de données en lecture/écriture
Fermer la connexion
2. Le Mode Déconnecté
Le mode déconnecté est un mode permettant d’accéder à une base de données
pour récupérer les données qui s’y trouvent et de les exploiter en lecture/écriture du côté
application ; voici la procédure :
1. Ouvrir la connexion avec la source de données
2. Obtenir une copie mémoire de tout ou partie des données de la source
3. Fermer la connexion
4. Travailler avec la copie mémoire des données en lecture/écriture
5. Lorsque le travail est fini, ouvrir une connexion, envoie les données modifiées à la
source de données pour qu'elle les prenne en compte, fermer la connexion.
NB :
Dans ce cours, nous allons exploiter seulement le mode connecté et le pilote
OLEDB.
Remarque :
Etant donné qu’on utilise les classes, il est indispensable d’importer les espaces des
noms qui contiennent ces classes. Dans le cadre des classes manipulation les sources
de données avec le pilote OLEDB, les espaces de noms à importer sont :
Using System.Data ;
Using System.Data.Oledb;
La chaine de connexion est une chaine de caractères qui doit contenir en son sein ; la
version du pilote utilisée, le nom, l’emplacement et le type de la base de données ;
d’autres informations sont utiles telles que le nom utilisateur et le mot de passe pour
un utilisateur.
En guise d’exemple, pour une base de données Access se trouvant sur la racine du
HDD (C:/) voici ce que sera la chaine de connexion.
"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:/Pharmacie.mdb";
Avec les versions les plus récentes d’Access, la base de données est un fichier
d’extension .accdb et la chaîne de connexion est :
"Provider=Microsoft.ACE.OLEDB.12.0;Data Source= c:/Pharmamcie.accdb";
NB :
Si le fichier de base de données Access se trouve dans le répertoire courant de
l’application (par défaut celui du fichier EXE de l’application), vous pouvez laisser
tomber le nom du répertoire.
Pour ouvrir la connexion ayant déjà créer l’objet connexion, nous utilisons la méthode
.open() qui permet de réaliser cette tâche. Nous avons la syntaxe suivante :
nomObjet.open() ;
Lorsqu’il faut réunir tous ces codes, nous aurons ce qui suit :
String constr="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:/Pharmacie.mdb";
OledbConnection connect=new OledbConnection( constr) ;
connect.open();
Dès que l’objet commande créé, il faut spécifier maintenant la connexion sur laquelle
l’objet commande doit s’exécuter. Dans ce cas, la propriété connection s’interpose
dans ce qui suit :
ObjCommand.connection=ObjConnection ;
2. Accès aux données
Après la création de la connexion, il y a moyen de travailler de trois manière et
cela est à la préférence du programmeur.
Avec un objet DataReader, on extrait les données en lecture seule : on peut lire
uniquement les données et aller à l’enregistrement suivant. Il travail en mode
connecté. Pour gérer un DataReader on a besoin d’un objet Command.
Avec un objet DataSet, on manipule les données. Une requête SQL charge le DataSet
avec des enregistrements ou des champs, on travaille sur les lignes et colonnes du
DataSet en local. En mode déconnecté (une fois que le DataSet chargé, la connexion à
la base de données est libérée).
Avec un objet Command on peut manipuler directement la BD (Update, Insert,
Delete).
B. ETUDE DE CAS
Pour concilier la théorie à la pratique, nous proposons une étude de cas, où nous
accédons à la base de données GProduit implémentée sous le SGBD Access dans sa version
2010, qui se trouve dans le même projet que l’application. Nous manipulons la table Produit
dans laquelle nous enregistrons les données et faisons la mise à jour.
Quant à ce, l’interface utilisateur se présente de la manière suivante :
1. Chargement de données
private void VENTE_Load(object sender, EventArgs e)
{
OleDbConnection con = null;
string ch = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=GProduit.accdb";
con = new OleDbConnection(ch);
con.Open();
string re = "select * from produit";
OleDbCommand com = new OleDbCommand(re);
com.Connection = con;
OleDbDataReader lect = com.ExecuteReader();
while (lect.Read())
{
this.comboBox1.Items.Add(lect[0]);
}}
2. Recherche de données
Dans ce point, la recherche a été implémentée au sein du combobox par
l’évènement SelectIndexChanged, qui signifie changement de l’index de l’élément
sélectionné. Là nous sommes toujours en lecture seule, avec l’objet DataReader.
}
}
L’insertion de données est parmi les opérations les plus importantes dans la
gestion d’une base de données. Etant donné que nous devons modifier les données de la base,
en d’autres termes l’accès en écriture à la base de données ; le DataSet est indispensable pour
cette cause. Donc, l’accès sera en lecture/écriture.
Voici les codes sources :
4. La Modification de données
Appelée souvent, opération de mise à jour. Est une opération qui consiste à
changer ou modifier les valeurs d’un enregistrement sans en insérer un nouveau. Toujours
dans le mode lecture/écriture avec le DataSet, voici le code.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.OleDb;
namespace Demande_de_terrain
{
public partial class Fo1 : Form
{
OleDbCommand cmd = new OleDbCommand();
OleDbConnection con = new
OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=terre.accdb");
OleDbDataReader dr;
public Fo1()
{
InitializeComponent();
}
}
private void button2_Click(object sender, EventArgs e)
{
con.Open();
string rqt = "insert into
demandeur(nom,lieu,daten,sexe,nationalite,numerocarte,profession,etatcivil,nomepoux,
regime,nombreenf,ville,commune,avenue,numero,quartier,datej)values(@d1,@d2,@d3,
@d4,@d5,@d6,@d7,@d8,@d9,@d10,@d11,@d12,@d13,@d14,@d15,@d16,@d17)";
cmd = new OleDbCommand(rqt,con);
cmd.Parameters.AddWithValue("@d1", nom.Text);
cmd.Parameters.AddWithValue("@d2",lieu.Text);
cmd.Parameters.AddWithValue("@d3", DateN.Text);
cmd.Parameters.AddWithValue("@d4", sexe.Text);
cmd.Parameters.AddWithValue("@d5", nationalite.Text);
cmd.Parameters.AddWithValue("@d6", numpiece.Text);
cmd.Parameters.AddWithValue("@d7", DateN.Text);
cmd.Parameters.AddWithValue("@d8", prof.Text);
cmd.Parameters.AddWithValue("@d9", etat.Text);
cmd.Parameters.AddWithValue("@d10", nomepoux.Text);
cmd.Parameters.AddWithValue("@d11", regime.Text);
cmd.Parameters.AddWithValue("@d12", nombre.Text);
cmd.Parameters.AddWithValue("@d13", Ville.Text);
cmd.Parameters.AddWithValue("@d14", commune.Text);
cmd.Parameters.AddWithValue("@d15", numero.Text);
cmd.Parameters.AddWithValue("@d16", quartier.Text);
cmd.Parameters.AddWithValue("@d17",dateJ.Text);
cmd.ExecuteNonQuery();
con.Close();
auto();
MessageBox.Show("Enregistrement Succès!!!!!!");
}
public void nex()
{
nom.Text="";
lieu.Text="";
DateN.Text="";
sexe.Text="";
nationalite.Text="";
numpiece.Text="";
DateN.Text="";
prof.Text="";
etat.Text="";
nomepoux.Text="";
regime.Text="";
nombre.Text="";
Ville.Text="";
commune.Text="";
numero.Text="";
quartier.Text="";
dateJ.Text="";
}
}
}
}
EXERCICE PERSONNELS
e. Ecrire un programme qui permet de faire des opérations sur un entier (valeur
initiale à 0). Le programme affiche la valeur de l'entier puis affiche le menu
suivant :
1. Ajouter 1
2. Multiplier par 2
3. Soustraire 4
4. Quitter
Le programme demande alors de taper un entier entre 1 et 4. Si l'utilisateur
tape une valeur entre 1 et 3, on effectue l'opération, on affiche la nouvelle
valeur de l'entier puis on réaffiche le menu et ainsi de suite jusqu'à ce qu'on
tape 4. Lorsqu'on tape 4, le programme se termine.