LPIIICSharp 2022

1
REPUBLIQUE DEMOCRATIQUE DU CONGO

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET UNIVESITAIRE
UNIVERSITE CHRETIENNE SOURCE DE VIE
FACULTE DES SCIENCES DE L’INFORMATIQUE
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
Ramazanitreso4@gmail.com
+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
Descriptif : Le cours est organisé en chapitres.

Introduction
Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

2
Chapitre I Notions de base et les Structures
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

3
Prérequis : La matière suivante est supposée maîtrisée :

• Mathématique
• Informatique Générale
• Base de données
• MAI1 et MAI2
• Réseaux informatiques
• UML
• Langage de programmation II
Méthodes : La méthodologie de cet enseignement est fondée sur la philosophie du « Learning
d'enseignement by doing », apprendre par la pratique et l’exercisation. Les méthodes principales
utilisées sont :
• Les cours interactifs
• Les travaux pratiques individuels
Ressources : • Matérielles
◦ PC,
◦ Smartphone
• Logicielles
◦ OS : Windows 7 ,Windows 8, Windows10, Andoid
◦ Ms office Access
◦ Visual Studio 2015
Stratégies : Seront évalués :

d'évaluation • la ponctualité, la présence et la discipline : /2
• la participation : /3
• les travaux pratiques : /5
• l'examen pratique : /5
• et l'examen écrit : /5
Bibliographie : L'ensemble des documents utilisés dans la préparation du cours sont disponibles
auprès du titulaire.
Serge TAHE, Apprentissage du langage C#, ISTIA Université

d’Angers, Mai 2008 ;
Alexandre MESLE, Introduction à la programmation C#, Mars
2014 ;
Gerar LeBlanc, C# et .Net, Eyrolles, Paris, 2009
Nicolas Hilaire, Apprenez à développer en C#, Simple IT, 2012
Jean Luc BAPTISTE, Cours de langage C# ; ;
www.developpez.com;
www.btsig.com

4

5
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
Le framework (plate-forme) .NET fournit un ensemble de fonctionnalités qui

facilitent le développement de tout type d'applications :
Les applications Windows classiques ;

6
Les applications Web ;

Les services Windows ;
Les services Web
La programmation réseau
En VB.net, Csharp, FSharp, etc ; toutes les applications sont conçues grâce à ce
framework, du développement de l'application jusqu'à son exécution. Le framework .NET
prend en charge l'intégralité de la vie de cette application. Ce framework doit être hébergé sur
le système d'exploitation avec lequel, il doit interagir en vue de jouer l’intermédiaire entre
l’application et le système d’exploitation. Ainsi donc, le premier système d'exploitation
permettant de le posséder est bien sûr Windows, mais d'autres versions sont disponibles
permettant l'adaptation de la plate-forme .NET à des systèmes d'exploitations tel que Linux ou
Unix...
Deux éléments majeurs constituent le framework .NET : la bibliothèque de classes
(Base Class Library) et le Common Language Runtime.
Bibliothèque de classes : ensemble de classes utilisées pour le
développement d'application, vous l'utilisez fréquemment.
Common Language Runtime : c'est le moteur du framework .NET :
runtime est comme un moteur d'exécution qui gère l'exécution du code
ainsi que de la mémoire. Le code pris en charge par le Common Language
Runtime est appelé code managé.

7
CHAPITRE I NOTIONS DE BASE ET LES STRUCTURES
I. NOTIONS DE BASE
A. DEFINITION DES VARIABLES EN C#
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 ;
3. Déclaration des constantes

La syntaxe de déclaration d'une constante est la suivante :
const type identificateur=valeur; //définit constante nom=valeur
ex : const float PI=3.141592;éé
const String="Bon c’est Bon" ;

8
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 :
 La conversion de nombres aux chaînes de caractères

Il peut arriver que nous voulions afficher le résultat qui est un entier en dans une
zone de texte (chaine) ; dans d’autres termes nous voulons effectuer une conversion d’une
valeur numérique en chaine de caractères dans ce cas, nous utilisons la méthode ToString().
int k;
String RMZ;
RMZ=k.ToString() ; // int to String
 La conversion de chaine de caractères au numérique

Pour des raisons de calculs, il peut nous être plus important d’assurer la
conversion des chaînes de caractères aux numériques ; dans ce cas la formule est la suivante :
int i; double d; float f;
String k;
k = "10";
i=int.Parse(k); // String to int

9
d=double.Parse(k);//String to double
f=float.Parse(k);//String to float
chaine -> int Int32.parse(chaine) ou int.Parse(Chaine)

chaîne -> long Long.parse(chaine)
chaîne -> double Double.Parse(chaine)
chaîne -> float Float.parse(chaine)
Exemple :
Soit à déclarer trois variables dont les deux premières sont des chaines de
caractère, et la dernière entière. On demande par la suite d’effectuer la conversion de deux qui
sont des chaines en entiers pour effectuer la somme dans la dernière.
String a, b;
int c;
c= Int32.Parse(a) + Int32.Parse(b);
C. LES OPERATEURS USUELS
1. Les opérateurs arithmétiques

a. Les opérateurs
Les opérateurs arithmétiques que nous avons sont les suivants :
 Addition +
 Soustraction –
 Division /
 Multiplication *
 Modulo %
b. Les Fonction Mathématiques

Les fonctions mathématiques sont les méthodes (opérations) qui nous permettent
de réaliser les calculs mathématiques dont les opérateurs ne nous permettent pas.
Tous ces opérateurs sont de la classe Math, les plus usuels sont les suivantes :
- Math.PI : elle nous donne la valeur exacte de PI, le résultat retourné est un réel.
double l=Math.PI ;

10
- 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) ;
2. Les opérateurs de comparaison

 Supérieur à >
 Supérieur ou égal à >=,
 Inférieur <
 Inférieur ou égal à <=
 == Egal à
 != Non égal à
3. Les opérateurs Logiques

 Non !
 Et Logique &&
 Ou Logique ||
D. LES ENTREES / SORTIES
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 :

11
Console.WriteLine() est équivalent à Console.Out.WriteLine() et écrit sur le flux Out

associé habituellement à l'écran.
Console.Error.WriteLine() écrit sur le flux Error, habituellement associé lui aussi à
l'écran.
Exemple :
1. Afficher le message Bonjour SISABIDIMBO ;
Console.Out.WriteLine("Bonjour SISABIDIMBO?");
2. Déclarer la constante PI avec sa valeur respective, afficher du texte « la constante PI

vaut : 3,14 ;
const double P=3.14;
Console.WriteLine("La Constante PI vaut: "+P);
3. Si l’on veut juste afficher le nom de la variable (identificateur), il est demandé

d’utiliser la virgule au lieu du signe d’addition (plus) comme nous montre l’exemple
suivant :
const double P=3.14;
Console.WriteLine("La constante s’appelle: ",P);
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.

12
3. Autres membres de la classe console

a. La Couleur de la fénêtre
Depuis C# version 2 (Visual Studio 2005), il est possible d’afficher en couleurs,
de positionner le curseur avant affichage, et de redimensionner la fenêtre console. Bien qu’il y
ait une fonction SetWindowPosition, il n’est pas possible de spécifier la position de la fenêtre
à l’écran (c’est le système d’exploitation qui décide, et spécifier la position de la fenêtre par
rapport à l’écran n’est possible qu’en programmation Windows). Pour forcer un fond bleu, on
écrit :
Console.BackgroundColor = ConsoleColor.Gray;
Console.Clear();
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);

13
E. STRUCTURE D’UN PROGRAMME CSHARP

Un programme Csharp a les 4 grandes parties qui sont :
1. Importation : cette partie permet d’importer tous les paquets à utiliser au sein du
programme, cette opération se fait à l’aide du mot clé réservé du langage
using.NameSpace, d’une manière générale toutes les classes sont dans le paquet
using.System.
2. Le nom de l’espace de nom (paquet) : l’espace de nom ici nous permet de regrouper
toutes les classes (fichiers du programme) créées au sein de l’application. Cela se fait à
travers le mot clé réservé du langage namespace NomEspaceDesNoms
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.
Exemple : Concevoir un programme de permet de realiser la somme en C# ;
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());
b=int.Parse (Console.In.ReadLine());
c=a+b;
Console.WriteLine ("la somme est "+c);
Console.ReadLine ();
}
}
}

14
II. LES STRUCTURES DE CONTROLE

A. LES STRUCTURES CONDITIONNELLES
Les structures alternatives sont ceux qui nous permettent d’exécuter une partie des
instructions et d’en laisser une autre. Pour ce qui concerne ce cours nous allons voir deux
types de structures alternatives.
1. If Conditionnel
Rien de nouveau par rapport au C/C++. Si vous connaissez n’importe quel
langage moderne, il suffira d’analyser les exemples qui suivent pour tout comprendre :
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
{
{
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

15
{
{
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
{
{
int a;
Console.Write("Introduisez l'entier SVP: ");
a=int.Parse(Console.In.ReadLine());
if (a > 0)
{
Console.Write("L'entier saisi est positif ");
}

16
else
{
Console.Out.WriteLine("L'entier est negatif");
}
Console.ReadLine();
}
On souhaite écrire un programme C# de résolution dans R de l'équation du second

degré : Ax2 + Bx +C = 0
using System;
using System.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
{
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)
{

17
case valeur1 : instruction ; break ;

default : instruction ;break ;
}
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
{
{
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;

18
default: Console.Write("Le numéro ne correspond à aucun mois"); break;

}
Console.ReadLine();
}
}
B. LES STRUCTURES REPETITIVES

Sont les instructions permettant d’exécuter au moins une fois la même
instruction ; nous avons while, do while et for.
1. While
En C#, la boucle (while) tant que se code de la façon suivante :

while (< condition >)
{
<instructions >
}
Les instructions du corps de la boucle sont délimitées par des accolades. La
condition est évaluée avant chaque passage dans la boucle, à chaque fois qu'elle est vérifiée,
on exécute les instructions de la boucle. Une fois que la condition n'est plus vérifiée,
l'exécution se poursuit après l'accolade fermante. Affichons par exemple tous les nombres de
1 à 5 dans l'ordre croissant,
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
{
{
int rmz;

19
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
{
{
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.Linq;
using System.Text;
namespace TP_G3
{

20
class Program
{
{
int i,n,som;
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);
}
}
}
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.Linq;

21
using System.Text;
namespace ConsoleApplication1
{
class Program
{
{
int i, n, som;
som = 0;
i = 1;
do
{
som = som + i;
i++;
}
while (i <= n);
Console.WriteLine("la sommes des entiers est" + som);

}
}
}
3. For
Cette boucle est quelque peu délicate. Commençons par donner sa syntaxe :
for (< initialisation > ; <condition > ; <pas >)
{
<instructions >
}
L'initialisation est une instruction exécutée avant le premier passage dans la

boucle. La <condition> est évaluée avant chaque passage dans la boucle, si elle n'est pas
vérifiée, on ne passe pas dans la boucle et l'exécution de la boucle pour est terminée. Le
<pas> est une instruction exécutée après chaque passage dans la boucle. On peut convertir
une boucle for en boucle while en procédant de la sorte :
for ( int i = 1; i <= 5 ;i++)

{

22
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.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
{
int i, n,som;
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);
}
}
}

23
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.Linq;
using System.Text;
namespace TP_G3
{
class Program
{
{
int i,n;
Console.WriteLine("le 10 nombres suivant sont");
for (i = n + 1; i <= n + 10; i++)
{
Console.WriteLine("le 10 nombres suivant sont" + i);
}
}
}
}
III. LES STRUCTURES DE DONNEES
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.

24
Nous trouvons deux types de tableaux, les tableaux à une dimension et les
tableaux à plusieurs dimensions.
1. Le Tableau A Une Dimension

Un tableau à une dimension appelé aussi vecteur, consiste en une suite de cellules,
toutes de même type (bien qu’il soit possible, avec les tableaux d’objet, de créer des tableaux
dont chaque cellule a un type particulier).
Les programmeurs C/C++ doivent noter la position des crochets et bien
comprendre ce qui suit. Avec la déclaration précédente, nous n’avons signalé qu’une chose :
nous allons utiliser un tableau, baptise t, d’entiers. Il s’agit ici d’un tableau à une seule
dimension puisqu’on s’est limite a une seule paire de crochets.
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;
Cette instruction permet d’affecter la valeur 20 au premier élément du tableau.
ii. Déclaration et Initialisation

La déclaration et initialisation est une opération qui consiste à déclarer un tableau
et à l’initialiser au même moment. Voici la syntaxe.
Type [] tableau = { val1,val2,valn};
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.

25
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.Linq;
using System.Text;
{
class Program
{
{
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];
Console.WriteLine("la sommes des entiers est" + s);

}
}
}
É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.Linq;
using System.Text;
{
class Program
{
{
int[] t = new int[10];

26
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++;
Console.WriteLine("Le nombre d'entiers supérieurs ou égaux à 10 est" + nb);

Console.ReadLine();
}
}
}
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.Linq;
using System.Text;
{
class Program
{
{
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();
}
}

27
2. Le Tableau A Plusieurs Dimensions

Il s’agit d’un tableau des tableaux qui manipule plusieurs tableaux à une
dimension. Ce genre de tableau est aussi appelé la matrice.
Les données ici sont stockées en ligne et en colonne.
a. Déclaration
Syntaxe :
type[ , ] tableau = new type[tailleLigne, tailleColonne];
Exemple :
int[,] t = new int[2, 3];
// 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
{
{
int[,] t = { { 8, 2}, { 4, 5 } };
int p = 1, s = 0;
for (int i = 0; i <= 1; i++)
{
p = p * t[0,i];
}

28
Console.WriteLine("Le Produit des entiers du premiere ligne de tableau

donne: " + p);
Console.ReadLine();

29
CHAPITRE II LES INTERFACES GRAPHIQUES
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.
II. DESCRIPTION DES CONTROLES DE BASE
A. INTRODUCTION
Toutes les classes de l’architecture .NET dérivent, de près ou de loin, de la classe

Object. Cette classe permet, via sa fonction membre GetType, de fournir des informations sur
la classe d’un objet: le nom de la classe (propriétés Name et FullName), s’il s’agit d’un objet
d’une classe déterminée ou s’il s’agit d’un objet appartenant à une classe dérivant d’une
classe déterminée.
D’un point de vue général, la classe de base des composants (composants visuels
ou non) est Component (et plus précisément System.ComponentModel.Component). Toute
classe dérivée de Component doit être en mesure de libérer ses en appelant la méthode
appelée Dispose().
La classe Control (dérivée de Component) est la véritable première classe de base
pour tous les composants. C’est en effet à partir de cette classe que l’on peut parler de
composant visuel. Control comprend les propriétés et les méthodes liées aux caractéristiques
(couleur de fond, par exemple), à la position (emplacement dans la fenêtre mère et taille) ainsi
qu’à la manipulation du composant.

30
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.
c. Font, ForeColor et BackColor

Elles permettent de spécifier une police de caractères (Font) pour le libellé du
bouton, la couleur du libellé (ForeColor) et la couleur d’arrière-plan (BackColor).
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.

31
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).
2. Les Cases à Cocher
La case à cocher comme son l’indique, permet de préciser l’Etat de l’application

sur base de l’activation ou désactivation de la case. Elle prend généralement deux états non
coché (unchecked en anglais) et coché (checked en anglais), même si c’est possible d’en
prendre trois. Toutes les différentes propriétés que nous avons vues pour les boutons sont
utilisables aussi pour les cases à cocher.
En dehors de ces dernières voici les quelques propriétés que nous pouvons aussi
utiliser sur les cases à cocher.
a. Appearance
Elle change l’apparence du contrôle qui s’affiche soit comme une case à cocher,
soit comme un bouton enfoncé (Normal et Button : sont les deux valeurs que nous trouvons
dans cette propriété).
b. ThreeState
C’est une propriété booléenne permettant de préciser que la case à cocher aura
trois Etats à savoir : coché, non coché et indéterminé (checked, unchecked, indeterminate).
Parce que par défaut elle a deux Etats.
c. CheckState
Elle indique l’état du contrôle dans le cas de trois Etats ; mais si la case a deux états la
propriété devient Checked.

32
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.
3. Les Cases d’Option
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.
4. La Boite à Liste Combo
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.

33
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.

34
b. BorderStyle, Font et ForeColor
Elles permettent respectivement de définir le style de bordure, la police de

caractère et la couleur du texte.
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
Comportement de l’hyperlien. On peut y trouver une des valeurs suivantes de

l’énumération LinkBehavior : AlwaysUnderline l’hyperlien est souligné ; HoverUnderline
l’hyperlien est souligné au moment où la souris le survole ; NeverUnderline il n’est jamais
souligné ; SystemDefault comportement par défaut d’un hyperlien.
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

35
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 :

36
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.

37
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
Créer le menu de l’application est l’enfance de l’art, cliquez sur l’icône

MenuStrip dans la boîte à outils (catégorie Menu et barres d’outils). Un objet menuStrip1
s’insère automatiquement en haut de votre fenêtre. À tout moment, Visual Studio est prêt à
créer des articles à gauche et en dessous de l’article courant.
Il suffit de compléter les cases qui s’ajoutent au fur et à mesure que le menu se
construit (cliquez sur Tapez ici et confirmez la création d’un article de menu par ENTREE).
III. LES BOITES DE DIALOGUES
Ce sont des petites fenêtres qui permettent d’interagir avec l’utilisateur de

l’application ou du logiciel.
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.

38
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.

39
A. LES METHODES D’UN FORMULAIRE
Un formulaire est un objet de la classe Form. Ainsi, un ensemble des méthodes

sont proposées pour permettre sa manipulation. Nous citons ici quelques-unes, qui sont très
pertinentes.
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();
B. LES PROPRIETES D’UN FORMULAIRE
En outrance des différentes méthodes, les formulaires regorgent aussi les

propriétés permettant leur paramétrage. Nous allons aussi quelques-unes qui sont très
primordiales.
1. Name :
Cette propriété aide le programmeur à octroyer le nom interne à son formulaire.
2. BackColor :
Elle la donne la couleur d’arrière-plan au formulaire.
3. BackgroundImage :

40
Elle donne une image en arrière-plan à un formulaire.

4. ControlBox
Propriété booléenne permettant d’afficher ou pas les boutons de gestion d’une
fenêtre (réduire, agrandir, fermer).
5. FormBorderStyle
Elle permet de modifier le type de bordure à un formulaire.
6. Icon
Elle modifie l’icône du formulaire, qui s’affiche généralement dans la barre de
titre.
7. Opacity
Qui crée la transparence de la fenêtre ou du formulaire.
8. StartPosition
Elle spécifie la position du formulaire lors de son démarrage.
9. Text
Spécifie le message titre qui devra s’afficher dans la barre de titre.
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.
V. LE FORMULAIRE NON RECTANGULAIRE

Il est possible de créer une fenêtre avec une autre forme que celle d’un rectangle.
Pour créer une fenêtre en forme d'Ellispe, on affecte à la Région de la fenêtre un
GraphicsPath dans lequel il y a une ellipse. Il faut le faire dans le constructeur de la Form
(Form1, New) et ne pas oublier d'importer Drawing2D.
Cela est décrit par les suivants :
GraphicsPath lmk = new GraphicsPath();
lmk.AddEllipse(0, 0, 500, 800);
this.Region = new Region(lmk);

41
VI. LA FENETRE MDI
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.

42
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.
Voici comment ça se présente ;
Affichage Calculatrice
Les boutons allant de 0 à 9 il y a du code suivant :

textBox3.Text = textBox3.Text + 1;
Ce code nous permet de concaténer la chaine 1 à la chaine existante dans la même

zone. C’est ainsi il a été tiré sur le bouton 1, s’il faut programmer sur le bouton, il s’agit de
remplacer juste 1 par 2, ainsi de suite jusqu’à zéro (0).
Le problème actuellement reste celui de pouvoir introduire maintenant l’opérateur

pour l’opération à effectuer ; soit c’est + pour exécuter l’addition, soit ce – pour la
soustraction, soit * pour la multiplication, soit ce / pour faire la soustraction.

43
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 :
private void button17_Click(object sender, EventArgs e)

{
operat = "*";
a = Int32.Parse(textBox3.Text);
textBox3.Text = "";
}
En tout voici tous les codes comment ça se présente :

{
int a, b, c;
string operat;
public Form1()
{
}

{

{
}

{
operat = "+";
textBox3.Text = "";
}

{
textBox3.Text =textBox3 .Text + 2;

44
{
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;
}

{
}
private void Form1_Load(object sender, EventArgs e)

{

{

{
operat = "*";
textBox3.Text = "";

45

{
operat = "-";
textBox3.Text = "";
}

{
operat = "/";
a = textBox3.Text;
textBox3.Text = "";
}

{
}

{
}

{
}

{
}

{
}

{
}

{
}

46
private void button1_Click_1(object sender, EventArgs e)

{
textBox3.Text = "";
}
}
VII. LANCER DES APPLICATIONS EXTERNES
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.
{
System.Diagnostics.Process.Start("shutdown.exe", "-s -t 05");

47
Exemple 1 : Création d’un chrono en C#
using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication6
{
{
int time = 0;
public Form1()
{
}
private void Button1_Click(object sender, EventArgs e)

{
if (Button1.Text == "Demarrer")
{
timer1.Start();
Button1.Text = "Arret";
}
else
{
timer1.Stop();
Button1.Text = "Demarrer";
}
}
private void timer1_Tick(object sender, EventArgs e)

{
time = time + 1;
int h = time / 3600;
int m = (time % 3600) / 60;
int s = (time % 3600) % 60;
Label1.Text = h.ToString("00") + ":" + m.ToString("00") + ":" + s.ToString("00");
}
private void Button2_Click(object sender, EventArgs e)

{
Label1.Text = "00:00:00";
}
}
}

48
CHAPITRE ACCES AUX BASES DE DONNEES
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)
Le pilote est un programme informatique qui présente deux interfaces, la première

interface permettant de communiquer avec l’application et la seconde permettant de
communiquer avec la base de données comme nous montre la figure suivante.

49
Dans le schéma ci-dessus, le pilote présente deux interfaces :

• L'interface I1 présentée à l'application
• L'interface I2 vers la base de données
Afin d'éviter qu'une application écrite pour une base de données B1 soit réécrite si
on migre vers une base de données B2 différente, un effort de normalisation a été fait sur
l'interface I1. Si on utilise des bases de données utilisant des pilotes "normalisés", la base B1
sera fournie avec un pilote P1, la base B2 avec un pilote P2, et l'interface I1 de ces deux
pilotes sera identique. Aussi n'aura-t-on pas à réécrire l'application. On pourra ainsi, par
exemple, migrer une base de données ACCESS vers une base de données MySQL sans
changer l'application.
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.
B. ACCES A LA BASE DE DONNNEES
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

50
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.
Quels sont les avantages et inconvénients des deux méthodes ?

Une connexion est coûteuse en ressources système. S'il y a beaucoup de connexions
simultanées, le mode déconnecté permet de réduire leurs durées à un minimum. C'est
le cas des applications web ayant des milliers d'utilisateurs.
L'inconvénient du mode déconnecté est la gestion délicate des mises à jour
simultanées. L'utilisateur U1 obtient des données au temps T1 et commence à les
modifier. Au temps T2, l'utilisateur U2 accède lui aussi à la source de données et
obtient les mêmes données. Entre-temps l'utilisateur U1 a modifié certaines données
mais ne les a pas encore transmises à la source de données. U2 travaille donc avec des
données dont certaines sont erronées. Les classes .NET offrent des solutions pour
gérer ce problème mais il n'est pas simple à résoudre.
En mode connecté, la mise à jour simultanée de données par plusieurs utilisateurs ne
pose normalement pas de problème. La connexion avec la base de données étant
maintenue, c'est la base de données elle-même qui gère ces mises à jour simultanées.
Ainsi Oracle verrouille une ligne de la base de données dès qu'un utilisateur la
modifie. Elle restera verrouillée donc inaccessible aux autres utilisateurs jusqu'à ce
que celui qui l'a modifiée valide (commit) sa modification ou l'abandonne (rollback).
Si les données doivent circuler sur le réseau, le mode déconnecté est à choisir. Il
permet d'avoir une photo des données dans un objet appelé dataset qui représente une
base de données à lui tout seul. Cet objet peut circuler sur le réseau entre machines.

51
NB :
Dans ce cours, nous allons exploiter seulement le mode connecté et le pilote
OLEDB.
II. MANIPULATION DE LA BASE DE DONNEES
A. CREER UNE CONNEXION

Le premier des objets que l’on est amené à rencontrer est l’objet de connexion.
Quel que soit le mode de travail (connecté ou déconnecté), il faut disposer, avant toute chose,
d’un objet de connexion. C’est dans cet objet que nous allons spécifier les caractéristiques de
la base de données à utiliser, notamment le nom et le type de base de données (Access, SQL
Server, Oracle, etc.).
ADO.NET utilise en interne OleDbConnection pour des connexions à des bases
de données Access mais aussi aux systèmes de bases de données pour lesquels il n’y a pas (ou
pas encore) de driver optimisé pour l’architecture .NET.
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;
Pour créer un objet connexion, nous utilisons la syntaxe suivante:

OledbConnection nomObjet=new OledbConnection( conString) ;
Sachant nomObjet représente le nom de votre objet (nom de votre choix), et conString
qui représente la variable contenant la chaine de connexion.
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.

52
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();
1. Exécuter une Commande

Nous allons maintenant adresser des commandes au serveur de base de données,
qui peut se trouver soit sur une autre machine du réseau soit sur la machine locale. La
connaissance du langage SQL est indispensable. Pour exécuter une commande, il faut
disposer d’un objet de commande. Comme nous avons décidé de travailler de manière
générique, nous demanderons la création d’un objet de la classe OledbCommand.
OleDbCommand nomObet= new OleDbCommand(strReq);
Le paramètre fournit représente la requête SQL à exécuter sur la source de données
(au sein de l’objet connexion). A titre d’exemple nous avons la requête suivante.
Select * from produit ;
Tous les codes réunis donne ce qui suit:
string strReq=”Select * from produit”;
OleDbCommand nomObet= new OleDbCommand(strReq);

53
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).
Dans ce cours nous aborderons l’utilisation de dataset et datareader
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 :

54
A l’affichage du formulaire, on doit charger les produits dans le combobox,

lorsqu’on sélectionne un nom du produit, on affiche automatique toutes les autres
coordonnées de ce produit. Lorsqu’on veut ajouter un produit, on devra saisir les données
correspondantes dans les différents champs et appuyer sur la case à cocher « Ajouter » les
données devrons alors se retrouver dans la table produit.
Voilà comment est la logique applicative de ce que nous devons faire.
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]);
}}

55
Les codes ci-dessus se trouvent dans l’évènement de l’affichage (chargement) du

formulaire. Dès que le formulaire se chargent, ajoute automatiquement toutes les données de
la table produit qui se trouvent dans le champ nom (représente par lect[0].
Nous notons ici que le mode d’accès utilisé c’est le DataReader en lecture seule
pas le DataSet.
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.
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)

{
string ch = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=SHEKINABD.accdb";
con.Open();
OleDbDataReader lect = com.ExecuteReader();
while (lect.Read())
{
if (this.comboBox1.Text.Equals(lect[0]))
{
int i = (Int32)lect[1];
int y = (Int32)lect[2];
this.textBox1.Text = i.ToString();
this.textBox2.Text = y.ToString();
}
}
}
3. Ajouter ou Enregistrement de données

56
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 :

{
string ch = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=GProduit.accdb";
con.Open();
OleDbDataAdapter ad = new OleDbDataAdapter(com);
DataSet ds = new DataSet();
ad.Fill(ds, "produit");
DataTable tbl = ds.Tables["produit"];

DataRow dr;
dr = ds.Tables["produit"].NewRow();
dr["Nom"] = this.comboBox2.Text;
dr["Prix"] = this.textBox2.Text;
dr["Qte"] = Int32.Parse(this.textBox3.Text);
ds.Tables["produit"].Rows.Add(dr);
OleDbCommandBuilder ben = new OleDbCommandBuilder(ad);
ad.Update(ds, "produit");
this.comboBox2.Text = "";
this.textBox2.Text = "";
this.comboBox2.Focus();
}
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.

57

{
int t=this.comboBox2.SelectedIndex;
string ch = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=SHEKINABD.accdb";
con.Open();
OleDbDataAdapter ad = new OleDbDataAdapter(com);
DataSet ds = new DataSet();
ad.Fill(ds, "produit");
DataTable tbl = ds.Tables["produit"];
DataRow dr;
dr= ds.Tables["produit"].Rows[t];
dr["Nom"] = this.comboBox2.Text;
dr["Prix"] = this.textBox2.Text;
OleDbCommandBuilder ben = new OleDbCommandBuilder(ad);
ad.Update(ds, "produit");
this.comboBox2.Text = ""; this.textBox2.Text = "";
this.comboBox2.Focus();
}
Code source projet G3 info

58
using System;
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()
{
}
private void Form1_Load(object sender, EventArgs e)

{
auto();
}
public void auto()

{
con.Open();

59
string rt = "select* from demandeur";

cmd = new OleDbCommand(rt, con);
dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
dgw.Rows.Clear();
while (dr.Read() == true)
{
dgw.Rows.Add(dr[0], dr[1], dr[2], dr[3], dr[4], dr[5], dr[6], dr[7], dr[8], dr[9],
dr[10], dr[11], dr[12], dr[13], dr[14], dr[15], dr[16]);
}
con.Close();
}
{
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="";

60
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="";
}
private void dgw_RowPostPaint(object sender,

DataGridViewRowPostPaintEventArgs e)
{

{
nex();
}
private void dgw_MouseClick(object sender, MouseEventArgs e)

{
nom.Text =dgw.CurrentRow.Cells[0].Value.ToString();
lieu.Text = dgw.CurrentRow.Cells[1].Value.ToString();
DateN.Text = dgw.CurrentRow.Cells[2].Value.ToString();
sexe.Text = dgw.CurrentRow.Cells[3].Value.ToString();
nationalite.Text = dgw.CurrentRow.Cells[4].Value.ToString();
numpiece.Text = dgw.CurrentRow.Cells[5].Value.ToString();
DateN.Text = dgw.CurrentRow.Cells[6].Value.ToString();
prof.Text = dgw.CurrentRow.Cells[7].Value.ToString();
etat.Text = dgw.CurrentRow.Cells[8].Value.ToString();
nomepoux.Text = dgw.CurrentRow.Cells[9].Value.ToString();
regime.Text = dgw.CurrentRow.Cells[10].Value.ToString();
nombre.Text = dgw.CurrentRow.Cells[11].Value.ToString();
Ville.Text = dgw.CurrentRow.Cells[12].Value.ToString();
commune.Text = dgw.CurrentRow.Cells[13].Value.ToString();
numero.Text = dgw.CurrentRow.Cells[14].Value.ToString();
quartier.Text = dgw.CurrentRow.Cells[15].Value.ToString();

{

61

{
}
}
}
EXERCICE PERSONNELS
a. Ecrire un programme qui affiche ceci à l'écran: Bonjour Monde!
b. Ecrire un programme qui demande à l'utilisateur de taper la largeur et la

longueur d'un champ et qui en affiche le périmètre et la surface
c. Ecrire un programme qui demande à l'utilisateur de taper un entier et qui
affiche GAGNE si l'entier est entre 56 et 78 bornes incluses PERDU sinon.
d. Ecrire un programme qui demande à l’utilisateur de taper 10 entiers et qui

affiche le plus petit de ces entiers.
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.

62
f. Ecrire un programme qui demande de saisir 10 entiers et qui affiche le nombre

d'occurrences de la note la plus haute.
g. É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.
h. 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.
i. Ecrire un programme qui saisit 2 tableaux de 10 entiers a et b. c’est

un tableau de 20 entiers. Le programme doit mettre dans c la fusion
des tableaux a et b. On copiera dans les 10 premières cases de c le
tableau a, dans les dix dernières le tableau b. Le programme affiche
ensuite le tableau c.

LPIIICSharp 2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

LPIIICSharp 2022

Transféré par

Droits d'auteur :

Formats disponibles

1

REPUBLIQUE DEMOCRATIQUE DU CONGO

Descriptif : Le cours est organisé en chapitres.

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Chapitre I Notions de base et les Structures

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Prérequis : La matière suivante est supposée maîtrisée :

Stratégies : Seront évalués :

Serge TAHE, Apprentissage du langage C#, ISTIA Université

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Le framework (plate-forme) .NET fournit un ensemble de fonctionnalités qui

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Les applications Web ;

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

CHAPITRE I NOTIONS DE BASE ET LES STRUCTURES

A. DEFINITION DES VARIABLES EN C#

3. Déclaration des constantes

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

 La conversion de nombres aux chaînes de caractères

 La conversion de chaine de caractères au numérique

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

chaine -> int Int32.parse(chaine) ou int.Parse(Chaine)

C. LES OPERATEURS USUELS

1. Les opérateurs arithmétiques

b. Les Fonction Mathématiques

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

2. Les opérateurs de comparaison

3. Les opérateurs Logiques

D. LES ENTREES / SORTIES

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Console.WriteLine() est équivalent à Console.Out.WriteLine() et écrit sur le flux Out

2. Déclarer la constante PI avec sa valeur respective, afficher du texte « la constante PI

3. Si l’on veut juste afficher le nom de la variable (identificateur), il est demandé

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

3. Autres membres de la classe console

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

E. STRUCTURE D’UN PROGRAMME CSHARP

Exemple : Concevoir un programme de permet de realiser la somme en C# ;

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

II. LES STRUCTURES DE CONTROLE

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

On souhaite écrire un programme C# de résolution dans R de l'équation du second

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

case valeur1 : instruction ; break ;

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

default: Console.Write("Le numéro ne correspond à aucun mois"); break;

B. LES STRUCTURES REPETITIVES

En C#, la boucle (while) tant que se code de la façon suivante :

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Console.WriteLine("la sommes des entiers est" + som);

L'initialisation est une instruction exécutée avant le premier passage dans la

for ( int i = 1; i <= 5 ;i++)

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

III. LES STRUCTURES DE DONNEES

Seule votre volonté vous conduira à l’excellence/Ir. RAMAZANI

1. Le Tableau A Une Dimension

Cette instruction permet d’affecter la valeur 20 au premier élément du tableau.

ii. Déclaration et Initialisation