16/05/2023 Section :

INFOTMATIQUE
DE GESTION
Programmation
DESKTOP
Langages C#

Notes des cours destinées aux étudiants de

Deuxieme année de Licence (L2
ISC GOMA
 1

PREAMBULE
C# (C sharp) est un langage de programmation orienté objet commercialisé par Microsoft
depuis 2002, conçu par son ingénieur Anders Hejlsberg. Ce langage est proche du Java et
est utilisé pour développer des applications windows (DESKTOP), mobiles, web, des
services web ainsi que des jeux vidéos.
Microsoft visual studio est l’environnement de développement utilisé pour programmer
en C#.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 2

PLAN DU COURS
Chapitre I : Introduction
Chapitre II : La programmation orientée Objet
Chapitre III : Programmation DESKTOP
Chapitre IV : Les rapports

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 3

CHAPITRE I. INTRODUCTION
D’après le classement récent des langages de programmation les plus utilisés, C# se place
à la cinquième position après Python, C, Java et C++. Comprenez par-là que c’est un
langage de programmation intéressant vu son classement.
Sa syntaxe n’est pas différente de celle du Java.

I.1. OUTILS DE DEVELOPPEMENT

En parlant d’un outil de développement, nous voyons un environnement de
développement à utiliser pour produire un programme. L’environnement de développement le
plus complet pour programmer avec le framework .NET est Microsoft visual studio.
Dans ce cours, nous allons utiliser visual studio 2012. Celui-ci n’est pas la dernière
version. Néanmoins, son choix s’explique par le fait le fait que nous n’aurons pas à
télécharger des outils en ligne après l’avoir installé, comme c’est le cas de Microsoft
visual studio 2022.

Toutefois, celui qui aura une version inférieure telle que MS Visual studio 2008,
celle supérieure, pourra l’utiliser.

I.2. SYNTAXE
Un projet C# a la même syntaxe que java. Cela peut se constater en créant notre
premier projet.
Lancer Microsoft visual studio/Fichier/Nouveau/Projet/Choix du langage
(C#)/Sélectionner application console/Nommer le projet/Choisir l’emplacement/Clic sur
Ok.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 4

Interprétation : Par défaut, 5 bibliothèques ont été générées. Elles commencent par le
mot clé « using ».
Le namespace prend le nom de notre projet. Nos codes sont mis dans une méthode
principale « Main ».
[Link] : pour afficher à l’écran
[Link] : pour bloquer jusqu’à ce qu’à ce qu’une touche de caractère ou
fonction soit enfoncée pour sortir.
Après avoir créé le projet, nous affichons une salutation et exécutons ce
programme.
Voici le résultat :

N.B : Le langage de programmation C# est sensible à la casse.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 5

- La majuscule est différente de la minuscule.

- Toutes les instructions se terminent par un point-virgule.
- Eviter d’utiliser les mots réservés au langage ainsi que les caractères spéciaux.

I.3. ENTREE AU CLAVIER

Les données provenant de l’utilisation du clavier sont transmises dans un flux
d’entrée créé automatiquement pour toute application C#.
La lecture au clavier de toute saisie n’est possible que si vous utilisez la méthode
ReadLine de la classe Console. Nous avons déjà utilisé La lecture avec
[Link]. Place, à l’écriture.
Exemple : Ecrire un programme permettant à l’utilisateur de saisir son nom et le lui
afficher.

Résultat :

Interprétation : En exécutant le programme, on demande à l’utilisateur quel est son

nom. Une fois saisi, on lui dit, votre nom est la variable saisie.
Nous avons déclaré une variable de type string dans laquelle nous affectons la saisie au
clavier.
N.B : Comme il s’agit du type string, l’instruction [Link]() est affectable.
Mais s’il s’agit d’un int, on doit convertir.
Exemple : Ecrire un programme permettant à l’utilisateur de saisir son année de
naissance et lui calculer son âge.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 6

I.4. LES CONDITIONS

A. IF …. ELSE
Les conditions sont utilisées avec les conditions logiques mathématiques. On peut
parler des conditions imbriquées si une condition est dans une autre.
Syntaxe : if(condition ){
Instruction ;

}
else{
Instruction ;
}

Exercice : Faites un programme permettant à l’utilisateur d’afficher si l’âge affecté à

une variable correspond à un mineur ou majeur.

Résultat : Ce programme affichera « Mineur »

On a la possibilité de mettre un intervalle dans la condition. Dans ce cas, on peut ajouter
&&. Il s’agit des conditions multiples.
Exemple : Ecrire un programme qui affiche la mention d’une cote obtenue. (A,S, D, GD).

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 7

Résultat : Comme 89 est affecté à la variable cote, le résultat est « GD »

B. SWITCH
Un code peut fonctionner avec un if… else if… else… autant qu’il le peut avec
switch. Néanmoins, switch allège un peu le code.
switch(/*variable*/)
{
case /*Argument1*/ :

/*Action*/

break ;
case /*Argument2*/ :
/*Action*/

break ;

default:
/*Action*/
}

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 8

Interprétation: En voyant la syntaxe de la structure switch, on se rend compte qu’on

doit avoir une variable qui sera testée avec des cas. Après avoir fini, on a la possibilité
de mettre un résultat par défaut. Retenez que default est facultatif. On le met que s’il
n’y a pas d’autres cas à gérer.
Voici les opérations qu'effectue cette expression.

 La classe évalue l'expression figurant après le switch (ici /*Variable*/). Si la

première languette (case /*Valeur possible de la variable*/:) correspond à la
valeur de /*Variable*/, l'instruction figurant dans celle-ci sera exécutée.
 Sinon, on passe à la languette suivante, et ainsi de suite.
 Si aucun des cas ne correspond, la classe va exécuter ce qui se trouve dans
l'instruction default:/*Action*/;. Voyez ceci comme une sécurité. Notez bien la
présence de l'instruction break ; Elle permet de sortir du switch si une languette
correspond.
Exemple : Ecrire un programme affichant le mois si nous affectons un chiffre à une
variable.
class Program
{
static void Main(string[] args)
{
int mois=11;

switch (mois)
{
case 1:
[Link]("Janvier");
[Link]();
break; case 2:
[Link]("Fevrier");
[Link]();
break; case 3:
[Link]("Mars");
[Link](); break;
case 4:
[Link]("Avril");
[Link](); break;
case 5:
[Link]("Mai");
[Link](); break;
case 6:
[Link]("Juin");
[Link](); break;
case 7:
[Link]("Juillet");
[Link]();
break;
case 8:
[Link]("Aout");
[Link](); break;
case 9:

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 9

[Link]("Septembre");
[Link]();
break; case 10:
[Link]("Octobre");
[Link]();
break; case 11:
[Link]("Novembre");
[Link]();
break; case 12:
[Link]("Decembre");
[Link]();
break;

Interprétation: Ce code affichera « Novembre ».

Dans chaque instruction case, une seule ligne de code a été écrit. Vous pouvez écrire
autant des lignes de code selon vos besoins.
L'instruction break; permet de sortir de l'opération en cours. Dans notre cas, on sort de
l'instruction switch.
N.B : L'instruction switch ne prend que des entiers ou des caractères en paramètre. Il est
important de le remarquer.
C. BOUCLES
Le rôle des boucles est de répéter un certain nombre de fois les mêmes opérations.
Pour parcourir une série de données, nous aurons besoin des boucles. Pour qu’elle
s’exécute, une condition doit être testée.

- La boucle while
La boucle while est une structure de contrôle permettant d’exécuter un ensemble
d’instructions de façon répétée sur base d’une condition booléenne.
Pour utiliser une boucle, il faut faire la déclaration. La condition suit pour permettre à
la boucle de s’arrêter. Cela nous évite des boucles infinies.
La boucle while va dans le sens de tant que….
While(/* condition*/)
{
Instruction à répéter ;
}
Expérimentons notre boucle avec le code suivant :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 10

Résultat :

Interprétation : Ces codes affichent Bonjour L3, 10 fois. Nous avons initialisé notre boucle
à 1. Et avons mis la condition « <=10 » dans notre boucle.

- Boucle for
Nous avons vu comment faire une boucle avec while, maintenant nous allons voir
comment réaliser une boucle avec for. Cette boucle autorise l’exécution des instructions
à l’intérieur du bloc en répétition un certain nombre de fois précis. Il prend tous ses
attributs dans sa condition pour agir. Avec while, nous avons déclaré et initialisé avant
la boucle. Avec for, tout sera mis dans sa condition.
Nous illustrons la boucle for pour obtenir le résultat comme celui précédent :

Résultat : La salutation sera affichée 10 fois comme ce fut le cas avec while.

- La boucle do... while

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 11

L’instruction do… while crée une boucle qui exécute une instruction jusqu’à ce qu’une
condition de test ne soit plus vérifiée. Le bloc d’instruction défini dans la boucle est
exécuté au moins une seule fois.
Différence entre la boucle while et do… while Les
deux blocs sont semblables. La différence réside au niveau ou :

while évalue la condition avant d’exécuter le bloc d’instructions.

do…. While évalue la condition après avoir exécuté le bloc d’instructions.
Néanmoins, ces deux boucles fonctionnent de la même manière. Vous pourrez
opérer un choix.
Nous prenons l’exemple précédent pour illustrer le fonctionnement de la boucle
do…while.

- Boucle imbriquée
Est dite boucle imbriquée, une boucle à l’intérieur d’une autre boucle. On peut
faire une boucle imbriquée avec différents types, c.à.d. dans un for, on peut y mettre
un while et vice-versa.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 12

I.5. LES TABLEAUX

Un tableau est une structure de données contenant un groupe d’éléments tous de
mêmes types. Les tableaux sont des collections des valeurs ou d’objets. Il est géré par
un pointeur. Il est encore une variable. Un tableau a plusieurs dimensions.
Bref, un tableau est un objet qui stocke plusieurs variables de même types. Si votre
tableau contiendra des entiers, il faut le préciser lors de la déclaration.
Lorsque vous déclarez un tableau, il n’est pas tellement différent de la déclaration d’une
variable d’un type donné.
Syntaxe : Type du tableau[] nom_tableau={contenu_du_tableau} ;

Interprétation : Nous avons créé un programme où nous avons la variable nom qui est un
tableau contenant deux informations.
Lors de l’affichage, nous parcourons notre tableau pour afficher le premier élément.
Résultat :

Nous pouvons afficher tous les éléments du tableau en utilisant une boucle.
Expérimentons-le :

Résultat :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 13

Interprétation : Nous mettons une boucle for, dans laquelle nous initialisons notre
variable i à 0, le parcours est inférieur à la taille du tableau. Dans l’affichage, nous
mettons i qui contient la taille du tableau (Length).
N.B : il y a une possibilité de déclarer un tableau tout en limitant sa taille. Dans ce cas,
on utilise le mot clé new permettant d’instancier.
Ex : string[] postnom = new string[5];

I.6. METHODE
Une méthode est une fonction faisant partie d’une classe. Elle permet
d’effectuer des traitements sur (ou avec) les données membres. Elle est définie par son
nom suivie des parenthèses. Pour son utilisation, il suffit de l’appeler à l’intérieur d’une
autre méthode suivie des parenthèses et point-virgule pour terminer.
Nous l’illustrons par l’exemple précédent.

Interprétation : Nous créons une méthode de type void dans laquelle nous mettons nos
instructions.
Cette méthode « CalculAge() » est appelée dans la méthode principale « Main ».
Le type void signifie qu’il s’agit d’une méthode retournant un vide.
On a utilisé le mot clé static parce que la méthode ne s’applique qu’à la classe elle même
et pas à ses instances.
N.B : Si la méthode retourne une valeur, cela signifie qu’elle a pris un type, par
conséquent elle devient une fonction. Celle-ci est une méthode qui retourne une valeur.
Dans ce cas, à la fin on met le mot clé return.
Elle peut être de type int, double, float, string et…
Exemple : Nous utilisons l’exercice précédent avec une fonction.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 14

Interprétation : Dans ces codes, nous avons changé le type de notre méthode, de void à
int. A la fin de l’instruction, nous avons retourné la variable ag.
Dans la méthode principale « Main », nous avons appelé notre fonction en la concaténant
dans des chaines des caractères. Ce qui a produit le même résultat.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 15

CHAPITRE II. LA PROGRAMMATION ORIENTEE OBJET

La POO consiste en la définition et l’interaction des briques logicielles
appelées objets. Un objet représente un concept, une idée ou toute entité du monde
physique, comme une voiture ou une personne… Elle permet de transcrire les
él2ments du réel sous la forme virtuelle.
La programmation par objet consiste à utiliser des techniques de
programmation pour mettre en œuvre une conception basée sur les objets.
Concrètement, un objet est une structure de données qui répond à un
ensemble de messages.
La représentation abstraite des objets qui partagent les mêmes propriétés
et comportement est une classe.
Le regroupement de diverses classes est appelé package.
II.1. OBJECTIF DE LA PROGRAMMATION ORIENTEE OBJET
L’objectif de la programmation orientée objet est de produire du code :

 Facile à développer, à maintenir ou à faire évoluer ;

 Réutilisable, tout ou en partie, sans avoir besoin de le dupliquer ;
 Générique et dont les spécialisations sont transparentes
Structure de base
Dans nos anciens projets, nous avons utilisé une classe sans l’aborder en
profondeur. Lorsqu’on crée un projet, par défaut la classe Program qui est exécutable
est créée.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 16

En voyant les codes ci-dessus, on se rend compte qu’il s’agit de la classe Program.
Lorsqu’on crée une classe, il y a présence du mot clé class suivi du nom de la classe. Ex
: class Program
Le nom de la classe est coloré différemment du mot clé class.
N.B : La classe Program n’est pas à confondre avec d’autres classes par le fait que celleci
est exécutable.
II.2. LA CLASSE
Une classe est une représentation abstraite d’un objet. Si on a des classes à créer,
procéder de la manière suivante :
Projet/Ajouter une classe/Nommer/Clic sur le bouton ajouter

Nous allons ajouter la classe Cours dans notre projet.

N.B : A voir cette classe, on constate qu’elle est différente de la classe par défaut
Program

Quels sont les objets de la classe Cours ?

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 17

Un objet Cours possède des attributs dont codeCours, designCours et credit.

Cours
- codeCours : String
- designCours : String
- credit : int
+ listeCours () : void

Un attribut définit les caractéristiques d’un objet d’une classe.

En voyant cette représentation, on constate que notre forme a des compartiments dont
le premier contient le nom de la classe, le deuxième prend les attributs et en fin, la
méthode.

A. Notions de portée
On parle d’une portée pour symboliser l’accessibilité qu’aura un attribut par rapport aux
autres classes. Une portée peut être publique, privée ou protégée.
Nos attributs de la classe Cours sont tous privatisés. Cela se constate par le signe (-) qui
est devant l’attribut.
Notre méthode listeCours est publique. C’est la raison de la présence du signe (+).
- : privé
+ : public
# : protégé
La portée a un même sens que la visibilité. Elle détermine qui peut avoir accès à une
classe, une méthode ou une variable. Nos classes sont publiques. Cela signifie qu’on peut
y accéder étant dans l’une ou autre classe.
Une portée privée signifie que la méthode ou l’attribut n’est accessible que si on est à
l’intérieur de la classe. On peut aussi protéger une méthode en utilisant le mot-clé
protected.
Mettons nos attributs de la classe Cours dans nos codes. Pour ce faire, un attribut est
précédé de sa portée et du type.
Ex : private int nombre ;
Voici comment cela se présente :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 18

Nous devons maintenant créer un objet. Pour ce faire, nous allons avoir un constructeur.
Un constructeur est une méthode spéciale utilisée pour initialiser les objets. Il peut être
utilisé pour définir des variables initiales des attributs d’un objet.
Il est conseillé de créer un constructeur par défaut, c’est-à-dire un constructeur sans
paramètre. Son rôle sera de permettre l’instanciation. Celui-ci prend le nom de sa classe
et il est public.

Nous pouvons instancier un objet Cours en allant dans la classe (Program) contenant la
méthode Main.
L’instanciation est faite en prenant le nom de la classe suivi du nom d’objet, signe
d’égalité puis new nom de la classe.
Exemple : Cours cours = new Cours();

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 19

Ce qui signifie que pour accéder à la classe Cours, on doit utiliser le nom de l’objet cours.
Dans ce, si nous procédons de la sorte, l’instruction se trouvant dans le constructeur par
défaut va être exécutée. Néanmoins, pour bloquer l’affichage, nous ajoutons la méthode
ReadKey().

Après exécution, voici le résultat :

Ce message vient de la classe Cours. Comme nous l’avons instancié dans la classe
Program, il est accessible.
Jusqu’à ce niveau, nos attributs ne sont pas accessibles à l’extérieur de sa classe. Etant
donné que nos attributs sont privés, ils ne peuvent pas être accessibles à l’extérieur de
la classe. On parle de l’encapsulation.
L’encapsulation désigne le regroupement de données avec un ensemble des routines qui
permettent la lecture et la manipulation. Ce principe est souvent accompagné du
masquage. Il empêche l’accès aux données par un autre moyen que les services proposés.

B. Accesseurs et mutateurs
Les accesseurs sont les moyens permettant d’agir sur nos objets en lecture, alors que
les mutateurs permettent d’agir sur nos variables en écriture. On peut donc afficher les
variables de nos objets grâce aux accesseurs (getters) et les modifier grâce aux
mutateurs (setters). Nos méthodes accesseurs et mutateurs doivent donc être publics
afin d’être accessible depuis les autres classes. On peut donc retenir qu’un mutateur
sera de type void car il ne renvoie rien. Alors qu’un accesseur renvoie une variable et
sera donc de type de celle-ci.
Pour ce faire, nous cliquons droit sur un attribut, puis
refactoriser/Encapsuler/Ok/Appliquer

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 20

using System;
using
[Link];
using [Link]; using
[Link];
using [Link];
namespace
Premier_Projet_L3_ISESOD
{
class Cours
{
private string codeCours;

public string CodeCours

{
get { return codeCours; }
set { codeCours = value; }
}
private string designCours;

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 21

public string DesignCours

{
get { return designCours; }
set { designCours = value; }
}
private int credit;
public int Credit
{
get { return credit; }
set { credit = value; }
}

//Constructeur par défaut

public Cours()
{
[Link]("Nous avons crée notre cours");
}
//Constructeur paramétré
public Cours(string code, string desi, int cred)
{
[Link] = code;
[Link] = desi;
[Link] = cred;
}
}
}

Les accesseurs commencent par get et les mutateurs par set.

Nous avons un autre constructeur surchargé avec 3 paramètres. Ces paramètres sont
affectés à nos attributs dans le but de protéger ces derniers.

Nous allons devoir accéder aux données à travers nos accesseurs. Nous revenons
dans la classe où il y a la méthode Main.

Interprétation : Nous avons créée 3 objets dont cours1, cours2, cours3. Ces objets sont
lus en les renvoyant à la ligne suivante après chaque objet. Un objet contient le code du
cours, la désignation et le crédit.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 22

Le \n (anti slash n) joue le rôle de renvoyer le résultat suivant à la ligne suivante. Le

constructeur étant public, il est accessible.
Les constructeurs, les accesseurs et mutateurs sont tous des méthodes avec un rôle pour
chacun.

 Constructeurs : méthode servant à créer les objets ;

 Accesseurs : méthode servant à accéder aux données des objets ;
 Mutateurs : méthode servant à modifier les données des objets
Résultat

Si nous rentrons dans notre diagramme de classe, nous constaterons qu’il y a une
fonction appelée listeCours de type void dans le troisième compartiment. Créons une
méthode listeCours dans la classe Cours. En tenant compte de la modélisation, il y a le
signe (+) devant la méthode, ce qui veut dire qu’elle est publique. Elle sera accessible
dans d’autres classes.
Partant de cela, nous allons récupérer nos objets crées dans la classe principale
pour les mettre dans une méthode listeCours de la classe Cours.
Classe Cours

Classe Program

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 23

C. Héritage
1. Généralités
L’héritage est un concept fondamental qui permet de réutiliser le code de la
classe mère appelée en d’autres termes classe de base. Il symbolise la relation est Un.
Exemple : Un Agent est une personne, Une pomme est un fruit, Un chou est un légume.
Alors que l'objet membre représente la relation: A-UN
Exemple : Une voiture a un moteur
L'héritage est mis en œuvre par la construction de classes dérivées. Le graphe
de l'héritage est comme suit :
Personne

Etudiant Directeur Agent

Fruit Légume

Pomme Orange Mangue Chou Chou-fleur Epinard

2. Hiérarchisation
• La classe dont on dérive est dite CLASSE DE BASE.
Personne, Fruit et Légume sont donc des classes de base (classe supérieure) ;
• Les classes obtenues par dérivation sont dites CLASSE DERIVEE
Etudiant est une classe dérivée (sous-classes) de la classe de base Personne
Chat est une classe dérivée de la classe de base Animal
Voiture est une sous classe de la classe de base Véhicule
• Vers le haut (en analyse O.O.) => on regroupe dans une classe ce qui est commun
à plusieurs classes. Dans la classe Personne, on regroupe les caractéristiques
communes aux Agents, Etudiants et Directeur.
• Vers le bas (lors de la réutilisabilité) => la classe de base étant définie, on peut la
reprendre intégralement pour construire la classe dérivée. La classe Personne
étant définie, on peut la reprendre intégralement, pour construire la classe Agent .
3. Classe dérivée
Une classe dérivée modélise un cas particulier de la classe de base, et est
enrichie d'informations supplémentaires.
La classe dérivée possède les propriétés suivantes :
 Contient les données membres de la classe de base,

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 24

 Peut en posséder de nouvelles,

 Possède (à priori) les méthodes de sa classe de base  Peut redéfinir
(masquer) certaines méthodes,  Peut posséder de nouvelles méthodes.
La classe dérivée hérite des membres de la classe de base.

Personne

Numéro d’ordre
Nom
Post-nom
Sexe
Classe de base
Héritage
Attributs de Personne

Agent

Numéro d’ordre Attributs hérités

Nom
Post-nom
Sexe
Fonction Attribut propre à Agent
Syntaxe de l’héritage
: public Class classe_derivée
: Classe_de_base Protection : Droit d’accès attribué au niveau de la classe.
Les attributs de la classe de base sont déclarés protégés (protected)
Exemple : Nous créons les deux classes Personne et Agent en tenant compte de
l’héritage.
Classe Personne

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

namespace Premier_Projet_L3_ISESOD

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 25

{
class Personne
{
private int idpers;

protected int Idpers

{
get { return idpers; }
set { idpers = value; }
}
private string nom;

protected string Nom

{
get { return nom; }
set { nom = value; }
}
private string postnom;

protected string Postnom

{
get { return postnom; }
set { postnom = value; }
}
private string sexe;

protected string Sexe

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

public Personne()
{
}
}
}
Ci-dessus, la classe de base Personne avec un constructeur par défaut. Ses
attributs sont protégés.
Dans la classe dérivée, nous allons devoir faire hériter de la classe de base avec
l’instruction « : (double point) ». Ce qui nous permettra d’avoir accès aux attributs de
sa classe. A la suite, nous allons utiliser le mot clé « this. » pour accéder aux attributs
de la classe de base, tout comme de la classe dérivée.
Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 26

Voici maintenant la classe dérivée Agent.

Classe Agent

Interprétation : Dans cette classe dérivée, nous avons déclaré un attribut privé fonction
qui est propre à cette classe. Un double point ( : ) nous a permis d’avoir accès aux
attributs de la classe Personne, tout comme on peut avoir accès à ses méthodes.
Un constructeur surchargé a été créé, dans lequel nous avons affecté les attributs avec
le mot clé this.

D. Le polymorphisme
Le polymorphisme est un mécanisme de la programmation qui permet de modifier
le comportement d’une sous classe (classé dérivée ou classe fille) par rapport à la
classe de base (classe mère).
Le polymorphisme veut dire simplement qu’une classe peut prendre plusieurs
formes et c’est d’autant plus vrai avec les classes qui héritent d’une classe de base.
Prenons l’exemple de la classe de base Personne avec ses sous classes. La classe
de base offre une méthode Liste des personnes « listePersonne() ». Cette liste affiche
toutes les personnes.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 27

Classe Personne
using System; using
[Link]; using
[Link]; using [Link];
using [Link];

namespace Premier_Projet_L3_ISESOD
{
class Personne
{
private int idpers;

protected int Idpers

{
get { return idpers; }
set { idpers = value; }
}
private string nom;

protected string Nom

{
get { return nom; }
set { nom = value; }
}
private string postnom;

protected string Postnom

{
get { return postnom; }
set { postnom = value; }
}
private string sexe;

protected string Sexe

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

//Constructeur par défaut

public Personne()

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 28

{
}

//Constructeur surchargé
public Personne(int id, string no, string post, string sex)
{
[Link] = id;
[Link] = no;
[Link] = post;
[Link] = sex;
}

//Liste des personne

public void listePersonne()
{
Personne pers1 = new Personne(1, "Jeanne D'arc", "BARAKA", "F");
Personne pers2 = new Personne(2, "KABANZA", "Justin", "M");
Personne pers3 = new Personne(3, "Michel", "ODINGA", "M");
[Link]([Link] + " " + [Link] + " " + [Link] + " " +
[Link] + "\n"
+ [Link] + " " + [Link] + " " + [Link] + " " + [Link]+"\n"
+ [Link] + " " + [Link] + " " + [Link] + " " + [Link]);
}
}
}

Interprétation : Dans la classe de base, nous avons créé la méthode listePersonne de

type void. Dans celle-ci, nous avons créé trois objets parmi lesquels, pers1, pers2 et
pers3. Ces trois objets sont affichés à l’écran. Après chaque objet, nous renvoyons le
suivant à la ligne suivante avec « \n ».
Comme une méthode est dans la classe de base, nous créons une autre méthode dans la classe
dérivée, qui va faire appel à la méthode listePersonne en y apportant une petite modification
liée au titre.
Classe Agent

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 29

Interprétation : Dans la classe dérivée, nous créons la méthode liste qui appelle la
méthode listePersonne de la classe de base tout en ajoutant un titre. Résultat

Exception : les méthodes de portée private ne supporte pas le polymorphisme. En effet,

une méthode de portée private n’est accessible uniquement que par la classe qui la
déclare. Donc si une classe de base (classe mère) et une classe dérivée (classe fille ou
sous-classe) ont la même signature, le compilateur les traitera comme deux méthodes
différentes.

Résumé :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 30

 Une classe permet de définir des objets. Ceux-ci ont des attributs (variables
d'instance) et des méthodes (méthodes d'instance + accesseurs).
 Les objets permettent d'encapsuler du code et des données.
 Les constructeurs d'une classe doivent porter le même nom que la classe et n'ont
pas de type de retour.
 L'ordre des paramètres passés dans le constructeur doit être respecté.
 Il est recommandé de déclarer ses variables d'instance private, pour les protéger
d'une mauvaise utilisation par le programmeur.
 On crée des accesseurs et mutateurs (méthodes getters et setters) pour permettre
une modification sûre des variables d'instance.
 Dans une classe, on accède aux variables de celle-ci grâce au mot clé this.
 On instancie un nouvel objet grâce au mot clé new.
 On peut avoir autant des classes dans un projet.
 Si les classes partagent les attributs, on peut faire l’héritage, ce qui va donner
naissance aux notions de classe de base ou classe parente et sous-classe ou classe
fille.
 Le double point ( : ) est utilisé pour hériter une classe de base dans une sousclasse.
 Le polymorphisme permet de modifier le comportement d’une sous-classe par
rapport à la classe de base.
 On peut redéfinir et ajouter une signature dans une méthode où la portée public
ne reste que public, le protected peut rester ainsi ou devenir public.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 31

CHAPITRE III. LA PROGRAMMATION DESKTOP (EVENEMENTIELLE)

La programmation événementielle est un paradigme de programmation dans
lequel l’exécution d’actions est déclenchée automatiquement lorsqu’un événement
survient. Un événement correspond généralement à un changement d’état dans l’univers,
ou bien à une intervention explicite de l’utilisateur (ou d’un système externe).

III.1. LE FORMULAIRE
Un formulaire est une fenêtre crée dans le but de saisir une série de données
structurées. Il est composé des contrôles graphiques. Un contrôle graphique est un
composant logiciel paramétrable destiné à être affiché sur le formulaire.
Si on doit utiliser un formulaire, lors de la création du projet, on doit sélectionner
C#/Application windows Form/Nommer le projet.

Après la création aura :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 32

Nous pouvons mettre des contrôles ou outils sur notre formulaire en allant dans l’option
boite à outils.

Nous allons devoir utiliser 3 outils à savoir :

 Le label : C’est une étiquette. Il va jouer le rôle d’affichage d’un texte statique.
Toute, il est possible de le manipuler aussi.
 Le TextBox : C’est une zone de saisie.
 Le bouton : Pour lancer une commande.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 33

Nous avons deux labels (premier nombre et deuxième nombre) et un bouton. Pour
changer le texte de nos outils, nous sélectionnons l’outil et allons dans text de notre
propriété.
Créons un événement sur le bouton calculer afin qu’en cliquant sur le bouton calculer,
qu’on obtienne la sommation de ces deux nombres.
Avant de créer un événement, nous allons renommer nos outils. Pour ce faire, nous allons
dans propriétés/name après avoir sélectionné l’outil à renommer.

Après avoir, renommé, nous faisons un double clic sur le bouton calculer pour obtenir
l’événement click.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 34

Nous déclarons la variable somme de type int sur laquelle, nous affectons nos deux
variables (n1 et n2), puis nous affichons le résultat dans une boite.

Interprétation : Par défaut, nos variables sont de type string, raison pour laquelle nous
devons les convertir aussi.
[Link] nous permet d’afficher le résultat dans une boîte. La somme doit aussi
être convertie en string pour qu’elle s’affiche dans le MessageBox car prenant par défaut
le type string.
Voici le résultat après exécution et un clic sur le bouton Calculer.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 35

III.2. INTERACTION AVEC LA BASE DE DONNEES

L’interaction avec la base de données dont nous faisons allusion, concerne les
données pouvant être enregistrées dans la base de données et les traiter par des requêtes
de sélection.
Le système de gestion de base de données que nous allons utiliser est Microsoft
SQL/Server. Retenez qu’un système de gestion de base de données est un logiciel système
servant à stocker, à manipuler ou gérer, et à partager des données dans une base de
données en garantissant la pérennité et la confidentialité des informations, tout en
cachant la complexité des opérations.
La Base de données est un ensemble d’informations qui est organisé de manière à être
facilement accessible, géré et mis à jour.
Voici à quoi ressemble MS SQL/Server.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 36

1. CREATION DE LA BASE DE DONNEES

1° Lancement de notre SGBD MS SQL/SERVER 2012
On clique sur le bouton Connect/New query pour ouvrir l’éditeur de requête.

Nous créons notre base de données avec du code sql que nous allons exécuter et la
sélectionner pour y créer deux tables à savoir : Etudiant et Paiement.

Nous créons maintenant nos deux tables tout en sachant que la table étudiant cède une
clé étrangère à la table paiement selon deux règles de gestion suivantes :
RG1 : Un étudiant peut effectuer un ou plusieurs paiements
RG2 : Un paiement est effectué par un et un seul étudiant.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 37

Etudiant 1,n Effectuer

Paiement
numMat Text numPaie Integer
nom Text 1 ,1
montant Money
postnom Text
motif Text
prenom Text
dateDapaie Date & Time
sexe Text
...

Le dessus ci-dessus est un MCD. Nous faisons notre BD partant de ce modèle.

Toutefois, on pouvait procéder par le MLD si on le veut.

Pour l’exécution, nous allons sélectionner les codes créant nos deux tables et
cliquer sur le bouton exécuter.
Nous mettons en relation les deux tables par une contrainte Foreign key. Le type
text est varchar dans la base de données et on doit préciser la taille.

Comme nous venons de créer notre base de données avec ses deux tables,
connectons-la à une application.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 38

Nous créons un projet nommé « Application_windows_L3 ». Celle-ci sera

programmée en utilisant la POO. Partant de la programmation orientée objet, nous
considérons chaque table comme une classe. Ce qui signifie que nous aurons deux classes
dont Etudiant et Paiement. Vu qu’il y a interconnexion avec la base de données, nous
ajoutons une troisième classe appelée « ConnexionBD ».

Nous cliquons sur Projet/Ajouter une classe

Nous créons la classe ConnexionBD d’abord.

Nous aurons à utiliser le SGBD MS SQL/SERVER. Par conséquent, nous importons la
bibliothèque SqlClient avec l’instruction :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 39

using [Link];
Nous créons deux méthodes à savoir : Une pour la connexion (ouverture de la
connexion) à la Base de données et l’autre pour la déconnexion (fermeture connexion).
Voici la classe Connexion
using System;
using [Link];
using [Link]; using
[Link];
using [Link];
//Importation de la bibliothèque nous permettant de nous connecter à sql/Server
using [Link];
//Importation de la bibliothèque pouvant gérer les classes des données using
[Link];

namespace Application_Windows_L3
{
class ConnexionBD
{
//Instanciation de deux objets. cnx qui va nous permettre de gérer notre
connexion
SqlConnection cnx = new SqlConnection();
//cmd pour l'exécution des commandes
SqlCommand cmd = new SqlCommand();

//Constructeur par défaut

public ConnexionBD()
{

}
//Méthode pour connecter la BD
public void Connecter()
{
//Nous testons si la connexion est fermée
if ([Link] == [Link])
{
//Prise en compte de la chaine de connexion en spécifaint le nom du serveur et
celui de la base de données
[Link] = @"Data Source=JUSTINKABANZA\KABANZA;Initial
Catalog=BD_Gestion_paiement_ISESOD_L3;Integrated Security=True";
//Ouverture de la connexion
[Link]();
}

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 40

//Méthode pour la déconnexion

public void Deconnecter()
{
//Nous testons si la connexion est ouverte pour la fermer
if ([Link] == [Link])
{
//Fermeture de la connexion
[Link]();
}
}

//Méthode exécution requête d'insertion, modification et suppression dans

laquelle nous avons un argument de type string
public void ExecuterRequete(string rqt)
{
//On ouvre la connexion
Connecter();
//On relie l'objet connexion à l'objet commande
[Link] = cnx;
//Nous affectons notre argument qui contiendrant une reqête sql
[Link] = rqt; //Nous exécutons la commande
[Link](); //Nous fermons la connexion
Deconnecter();
}
}
}

Classe Etudiant

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

namespace Application_Windows_L3
{
class Etudiant
{
private string numMat;

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 41

public string NumMat

{
get { return numMat; }
set { numMat = value; }
}
private string nom;

public string Nom

{
get { return nom; }
set { nom = value; }
}
private string postnom;

public string Postnom

{
get { return postnom; }
set { postnom = value; }
}
private string prenom;

public string Prenom

{
get { return prenom; }
set { prenom = value; }
}
private string sexe;

public string Sexe

{
get { return sexe; }
set { sexe = value; }
}
//Constructeur par défaut
public Etudiant()
{
}

//Constructeur paramétré
public Etudiant(string mat, string no, string postn, string pren, string sex)
{

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 42

[Link] = mat;
[Link] = no;
[Link] = postn;
[Link] = pren;
[Link] = sex;
}

//Méthode d'enregistrement dans la table Etudiant

public void Enregistrer()
{
//L'instruction try et catch permet de gérer les erreurs (exception)
//Try teste et catch intercepte l'erreur en retournant un message d'erreur
try {
//Nous instancions un objet de la classe ConnexionBD
ConnexionBD con = new ConnexionBD();
//Nous appelons la méthode ExecuterRequete se trouvant dans la classe
ConnexionBD
//Nous y mettons une requête d'insertion de données dans la table Etudiant
//Nous précisons les noms des champs puis les valeurs viendront des attributs
[Link]("INSERT INTO Etudiant
(numMat,nom,postnom,prenom,sex) VALUES ('"+ numMat +"','"+ nom +"','"+ postnom
+"','"+ prenom +"', '"+ sexe +"') ");
//Après exécution de la requête qu'on nous affiche un message
[Link]("Enregistrement effectué avec succès");
}
catch(Exception ex){
//Affichage d'un message d'erreur
[Link]([Link]);
}
}
}
}

Après avoir fini avec la classe Etudiant, nous allons au formulaire pour y mettre des
contrôles. Néanmoins, le premier formulaire sera notre menu. Nous y mettons les options
puis nous allons créer un autre formulaire du nom « frmEtudiant ». Sur le menu, nous y
mettons le contrôle menustrip.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 43

Derrière l’option quitter, nous mettons l’instruction suivante pour nous

permettre de fermer l’application :
[Link]();
Lorsqu’on clique sur l’option Saisie Etudiant, qu’on affiche le formulaire étudiant dans
un panel du menu. Créons le formulaire étudiant en procédant de cette manière :
Projet/Ajouter nouvel élément/Contrôle utilisateur/Nommer-le/Clic sur ajouter.
Après avoir créé le contrôle utilisateur, nous y mettons des outils tels que label, TextBox,
CommboBox, Bouton et DataGridView.
Faisons fonctionner l’option saisie Etudiant en y mettant les instructions suivantes :

Voici le formulaire étudiant après un clic sur l’option saisie Etudiant :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 44

ComboBox : C’est une liste déroulante

DataGridView : C’est un tableau qui va nous afficher les informations enregistrées dans
la table Etudiant.
Nous créons le premier événement sur notre formulaire. Il s’agit de l’événement load
pour que la liste déroutante sexe nous charge M et F. Toutefois, nous devons dans un
premier temps, renommer tous les outils du formulaire exceptés les labels qui ne
seront pas manipulés. Pour renommer nous sélectionnons un
outil/Popriétés/Name/ Nous donnons un nouveau nom.
Pour créer l’événement load, nous faisons un double clic sur le formulaire.

Par les codes ci-dessus, nous venons d’ajouter les items sur notre liste déroulante sexe.
Créons un deuxième événement. Il s’agit de clic sur le bouton enregistrer. On y fait juste
un double clic pour y mettre les instructions.

Nous lançons notre application pour tester si le bouton enregistrer est devenu
fonctionnel après avoir mis les instructions ci-dessus.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 45

Après un clic sur le bouton Enregistrer, on nous renvoi le message enregistrement

effectué avec succès. Cela montre qu’on vient d’enregistrer dans la table Etudiant.
On peut faire une instruction sql SELECT *from Etudiant. Après l’avoir exécuté, voici le
résultat

Nous devons initialiser notre formulaire après l’enregistrement, c.à.d. nettoyer le

formulaire pour avoir des zones de saisies vide. Nous créons une méthode appellée «
Initialiser », qui sera appelé dans l’événement clic du bouton Enregistrer après
[Link].

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 46

Interprétation : Nous avons mis nos variables sur lesquelles nous affectons un vide. Ce
qui va faire le nettoyage après enregistrement. Puis nous avons fait [Link]() pour
placer le curseur sur la zone de saisie des matricules.
Comme nous avons déjà enregistré, chargeons nos informations dans le DataGridView
(tableau) pour nous permettre de voir ce qui est la table Etudiant.
Vu que le chargement d’informations dans notre DataGridView pourra être utilisé dans le
formulaire paiement aussi, pour éviter de nous répéter, nous créons une méthode dans
la classe ConnexionBD. Cette dernière sera paramétrée afin de la standardiser.
Pour charger les données dans un datagridview, nous aurons besoin d’utiliser deux objets
de deux classes différentes à savoir :

- SqlDataAdapter : Pour adapter les donner dans un tableau

- DataSet : Pour la mise d’informations dans un tableau

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 47

Interprétation : Dans notre méthode de chargement du datagrid, nous l’avons surchargé

avec deux arguments dont le premier concernant la requête, le deuxième lié au
DataGridView qui nécessite l’importation de la bibliothèque [Link].
Nous allons dans le formulaire étudiant pour appeler la méthode ci-dessus
créées afin de charger les informations de notre datagridview.

Cette méthode, doit être appelée dans l’événement load pour qu’au chargement du
formulaire, les informations s’affichent.

Nous chargeons la méthode ChargerDGVEtudiant dans l’événement clic du bouton

enregistrer pour qu’après chaque enregistrement, que le datagrid s’actualise.

Créons l’événement CellClick sur le datagrid afin qu’à un clic sur la colonne
du datagrid, les zones de saisie se complètent automatiquement. Pour ce faire, nous
sélectionnons le datagridview/Propriétés/Evénement/double clic sur CellClick.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 48

En cliquant sur la cellule du datagrid, l’information s’affiche dans les contrôles du

formulaire.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 49

Comme nous avons déjà les données sur le datagrid, nous pouvons maintenant
programmer le bouton Modifier. Etant donné que nous avons une méthode dans la classe
ConnexionBD nommée executerRequete, nous l’utilisons dans la classe Etudiant en
créant une méthode appelée Modifier.
Après avoir créé la méthode, nous créons un événement clic sur le bouton modifier sur
lequel nous allons relier les contrôles du formulaire avec les paramètres de notre
constructeur.
Code de la méthode Modifier de la classe Etudiant

Codes derrière le bouton Modifier du formulaire Etudiant

Nous créons la méthode supprimer dans la classe Etudiant. Avant de le faire, nous créons
un constructeur avec un seul argument pour gérer la suppression d’autant plus que seule
la clé primaire nous permettra de supprimer.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 50

Codes de la méthode supprimer

Codes derrière le bouton supprimer

Nous venons de terminer avec notre formulaire Etudiant qui est en interconnexion avec
la table Etudiant de la base de données BD_Gestion_paiement_ISESOD_L3 où nous avons
programmé les boutons Enregistrer, Modifier et supprimer. Pour ce qui est de la
recherche, nous nous sommes concentrés sur l’événement cellclick de notre
datagridview. Toutefois, cela n’exclut pas la fonctionnalité recherche.
Nous procédons de la même façon pour programmer le formulaire Paiement. Ce qui fait
que nous allons devoir créer la classe paiement avec ses attributs et créer différentes
méthodes possibles.
Allons-y.
Nous devons ajouter une méthode de chargement du ComboBox dans la classe
ConnexionBD étant donné que nous avons un champ qui va récupérer la clé étrangère.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 51

Méthode de la classe ConnexionBD

Classe Paiement
using System;
using [Link];
using [Link]; using
[Link]; using
[Link];
using [Link];

namespace Application_Windows_L3
{
class Paiement
{
private int numPaie;

public int NumPaie

{
get { return numPaie; }
set { numPaie = value; }
}
private double montant;

public double Montant

{

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 52

get { return montant; }

set { montant = value; }
}
private string motif;

public string Motif

{
get { return motif; }
set { motif = value; }
}
private DateTime datePaie;

public DateTime DatePaie

{
get { return datePaie; }
set { datePaie = value; }
}
private string numMat;

public string NumMat

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

//Constructeur par défaut

public Paiement()
{
}

//Constructeur surchargé
public Paiement(int num, double mont, string mot, DateTime datp, string numMa)
{
[Link] = num;
[Link] = mont;
[Link] = mot;
[Link] = datp;
[Link] = numMa;
}

//Constructeur surchargé avec un seul argument pour la suppression

public Paiement(int num)
{

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 53

[Link] = num;
}
//Méthode Enregistrer
public void Enregistrer() {
try
{
ConnexionBD con = new ConnexionBD();
[Link]("SET DATEFORMAT DMY INSERT INTO Paiement
(numPaie,montant,motif,datepaie,numMat) values ("+ numPaie +",'"+ montant +"','"+
motif +"','"+ datePaie +"','"+ numMat +"') ");
[Link]("Enregistrement effectué avec succès");
}
catch (Exception ex)
{
[Link]([Link]);
}
}

//Méthode Modifier
public void Modifier()
{
try
{
ConnexionBD con = new ConnexionBD();
//SET DATEFROMAT DMY permet de spécifier le format de la date française
[Link]("SET DATEFORMAT DMY UPDATE Paiement SET montant='" +
montant + "',motif='" + motif + "',datepaie='" + datePaie + "',numMat='" + numMat + "'
Where numPaie=" + numPaie + " ");
[Link]("Modification reussie");
}
catch (Exception ex)
{
[Link]([Link]);
}
}

//Méthode Supprimer
public void Supprimer()
{
try
{
ConnexionBD con = new ConnexionBD();
[Link]("DELETE FROM Paiement Where numPaie=" + numPaie

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 54

+ " ");
[Link]("Suppression effectuée");
}
catch (Exception ex)
{
[Link]([Link]);
}
}
}
}

Codes derrières le formulaire paiement

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

namespace Application_Windows_L3
{
public partial class frmPaiement : UserControl
{
public frmPaiement()
{
InitializeComponent();
}

private void btnEnregistrer_Click(object sender, EventArgs e)

{
//Instanciation de l'objet de la classe Paiement tout en chargeant les
paramètres
Paiement paie = new
Paiement([Link]([Link]),[Link]([Link]),[Link],DateTime.
Parse([Link]),[Link]);
//Appel de la méthode enregistrer de la classe paiement
[Link]();
//Chargement dgv après enregistrement
ChargerDGVPaiemnt();
//Appel de la méthode d'initialisation

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 55

Initialiser();
}

private void Initialiser()

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

private void btnModifier_Click(object sender, EventArgs e)

{
//Instanciation de l'objet de la classe Paiement tout en chargeant les
paramètres
Paiement paie = new Paiement([Link]([Link]),
[Link]([Link]), [Link], [Link]([Link]), [Link]);
//Appel de la méthode Modifier de la classe paiement
[Link]();
//Chargement dgv après modification
ChargerDGVPaiemnt();
//Appel de la méthode d'initialisation
Initialiser();
}

private void btnSupprimer_Click(object sender, EventArgs e)

{
//Instanciation de l'objet de la classe Paiement tout en chargeant les
paramètres
Paiement paie = new Paiement([Link]([Link]));
//Appel de la méthode Supprimer de la classe paiement
[Link]();
//Chargement dgv après suppression
ChargerDGVPaiemnt();
//Appel de la méthode d'initialisation
Initialiser();
}

//Chargement datagrid
private void ChargerDGVPaiemnt()

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 56

{
//Instanciation de la classe ConnexionBD
ConnexionBD con = new ConnexionBD();
//Appel de la méthode pour charger DGV
[Link]("SELECT *from Paiement", dataGridView1);
}

private void frmPaiement_Load(object sender, EventArgs e)

{
//Chargement données du datagrid
ChargerDGVPaiemnt();
//Chargement matricule dans le comboBox
chargerMatricule();
//Nettoyage du formulaire
Initialiser();
}
//Méthode chargement info du champs numMat dans le comboBox
private void chargerMatricule()
{
//instanciation de l'objet de la classe ConnexionBD
ConnexionBD con = new ConnexionBD();
//Appel de la méthode pour gérer le comboBox
[Link]("SELECT numMat from Etudiant", cbomat, "numMat", "numMat");

}
//Evénement cellclick du datagrid pour afficher les informations de la cellule
cliquée
private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
{
[Link] = [Link][0].[Link]();
[Link] = [Link][1].[Link]();
[Link] = [Link][2].[Link](); [Link]
= [Link][3].[Link](); [Link] =
[Link][4].[Link]();
}
}
}

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 57

Formulaire paiement

Résumé : Avec deux tables, nous avons créé deux formulaires y correspondant. Mais
également trois classes dont Etudiant, Paiement et ConnexionBD. Les événements ont
été créés sur nos formulaires et les codes sont commentés au point qu’il n’y aura pas de
confusion là-dessus. Ce qui fait à ce que la base de données joue pleinement son rôle de
stockage de données.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 58

CHAPITRE IV. LES RAPPORTS

Une application sans rapport est un projet inachevé. On peut avoir fait
l’enregistrement des données brutes mais retenez que cela n’est pas suffisant. Il faut
un traitement. Le rapport contient les informations exploitables ayant subies un
traitement.
Pour produire des rapports, nous allons utiliser un outil appelée Crystal Report.
Il n’est pas le seul outil pouvant produire des rapports car il en existe autant. Crystal
Report est un progiciel qui permet de générer des rapports à partir de données
informatiques. Il a été développé par SAP.
Comme nous utilisons MS visual studio 2012, vous constaterez que l’outil crystal
Report n’y est pas intégré. Il faut l’installer séparément. Dans le cas d’espèce, nous
avons un setup de crystal report version 13.0 qui est compatible avec notre
environnement de développement.

En lançant l’installation de crystal report, faites toujours des clics sur suivant
en acceptant les conditions d’utilisation.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 59

Après l’installation de cet outil, nous lançons MS visual studio 2012 pour voir si
CrystalReportViewer est intégré dans la boite à outils.

Une fois notre outil installé, nous créons un rapport qui va afficher la situation
globale de paiement. Nous rappelons avoir eu à créer une base de données avec deux
tables dont Etudiant et Paiement. Notre rapport aura les informations venant de ces
deux tables. Ce qui va faire à ce que nous puissions créer une vue dans MS SQL/Server
que nous allons nommer SituationGlobale.

Après avoir créé une requête, nous ajoutons un contrôle utilisateur (formulaire)
dans le projet créé précédemment qui va nous permettre de charger la situation
globale.
Nous lançons notre projet/Clic droit sur projet/Ajouter un contrôle
utilisateur/Nommer/OK.
Nous faisons un double clic sur le formulaire créé pour avoir l’événement load
à utiliser dans le chargement de ce dernier.
Nous revenons à notre formulaire frmSituationGlobale pour y mettre le contrôle
CrystalReportViewer ce qui va ressembler comme ceci afin de jouer le rôle de lecteur.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 60

Créons un crystalReport sur lequel nous chargeons les données.

Projet/Ajouter un nouvel élément/Reporting/CrystalReports/Nommer/Ajouter. Voici
la finalité de ce processus.

En cliquant sur le bouton ajouter, une nouvelle boite apparait/Ok/Créer une

connexion/Dérouler OLEDB ADO/Sélectionner SQL Native client/Suivant/Sélectionner
le nom du serveur/Cocher sécurité intégrée/Sélectionner la base de
données/Suivant/ok/Dérouler la base de données/Dérouler dbo/Dérouler
vue/Sélectionner la vue SituationGlobale/Suivant/Séléctionner tous les champs à
afficher/Suivant puis terminer.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 61

Ci-dessus l’image de notre crystalreport avant l’arrangement. Arrangeons notre

rapport en mettant des lignes et des colonnes. Il existe d’outils appropriés au
Crystalreport pour son arrangement, à savoir :

Pour mettre un titre à notre rapport, nous utilisons l’outil « Objet texte ». On a
la possibilité de spécifier la police avec la propriété Font. Si nous faisons un aperçu de
notre rapport, on aura :

En voyant ce rapport, on constate que nous n’avons pas encore mis des lignes et des
colonnes pour en faire un tableau. Pour ce faire, nous utilisons l’outils « Objet ligne ».

Programmons le formulaire frmSituationGlobale afin qu’à son chargement, les

données soient affichées.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 62

Nous appelons le formulaire derrière le bouton Rapport situation paiement.

Au chargement du formulaire rapport, voici le message d’erreur qui s’affiche :

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 63

Ce message est justifié par le fait que nous avions installé notre outil
CrystalReportViewer venant de l’extérieur. Il est recommandé de revoir les
configurations dans fichier xml de notre projet. Il s’agit du fichier AppConfig.

Nous avons ajouté dans la balise startup, la propriété

useLegacyV2RuntimeActivationPolicy="true" Après exécution, voici le résultat :

Etant donné que nous venons de créer la situation globale de paiement, faisons en
sorte qu’après avoir enregistré un paiement qu’on nous affiche le reçu qui peut être
imprimé. Nous rappelons que le reçu est un rapport paramétré d’autant plus qu’il sera
personnalisé.
Nous commençons par créer une vue dans la base de données qui va charger le numéro nom,
le postnom, prénom, montant payé, date de paiement et le motif.

Après l’avoir créé, nous l’exécutons puis créons un CrystalReport comme nous l’avons fait avec
la situation globale de paiement.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 64

Nous mettons un cadre arrondi qui va contenir nos données. Etant donné que c’est un
reçu, créons un champ qui va transcrire les chiffres en lettre pour avoir une zone de
montant payé en lettre.
Nous déroulons Explorateur des champs à gauche/Cliquons droit sur champ de
formule/Nous nommons/OK.
Après avoir cliqué sur Ok, un éditeur de formule s’ouvre et on met :

Enregistrer la formule puis, récupérer le champ crée comme formule et déposer sur le
crystal report.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 65

Les codes qui chargent le reçu sur le formulaire paiement. Une nouveauté est qu’au
lieu de charger les données dans un DataSet, nous avons utilisé un DataTable pour
dynamiser les données. Il doit être aussi déclaré dans la classe ConnexionDB.

Appel de la méthode chargerRecu sur l’événement clic du bouton Enregistrer.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 66

Résumé : On peut directement intégrer le rapport sur un formulaire de saisie, tout

comme le mettre à part. Notre rapport reçu est paramétré et tient compte du numéro
saisit pour se charger contrairement à la situation globale qui charge toutes les
données.
Pour charger la situation globale, nous avons mis nos données dans un DataSet
contrairement au reçu qui a utilisé un DataTable par le fait que ce dernier nous permet
de dynamiser alors que le DataSet mémorise la première information.
La classe ConnexionDB a pris toutes les méthodes pouvant être utilisée dans toutes les
autres classes. Ce qui nous évite la répétition. Pour dynamiser des méthodes, nous les
avons paramétrés avec des variables qui seront remplacées par leur équivalent au
moment de leurs utilisations.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 67

2ème partie : [Link]

Chapitre I : La programmation événementielle

Tel que précédemment dit, la programmation événementielle est un
paradigme de programmation dans lequel l’exécution d’actions est déclenchée
automatiquement lorsqu’un événement survient. Un événement correspond généralement à
un changement d’état dans l’univers, ou bien à une intervention explicite de l’utilisateur.
En parlant de l’événementielle, on voit le formulaire qui peut avoir différents événements,
à savoir :

• Clic : En cliquant sur un bouton, un événement se produit

• Load : En chargeant un formulaire, il y a une réaction
• Textchanged : En saisissant dans une zone
• Cellclicked : une action produite en sélectionnant une cellule du
datagridwiew.
• Selected : en sélectionnant une information dans un comboBox, un
événement survient Etc..

I.1. Formulaire
Pour créer un projet en [Link], on lance MS Visual
Studio/Fichier/Nouveau/Projet/Sélectionner visual Basic/ Sélectionner le type
d’application/Ok.
Les projets conçus avec C# peuvent l’être avec [Link]. Seules la syntaxe change
mais cela n’affecte à rien le résultat. D’ailleurs on a du mal à distinguer un produit fini
fait avec c# avec celui du [Link].
En c# on déclare comme en java en faisant type suivi du nom de la variable et
en fin un point-virgule, tandis que qu’en [Link], on fait Dim suivi du nom de variable
as type de la variable sans point-virgule. Dans les codes on en sait partant de la syntaxe
mais également de l’extension des fichiers. En C#, c’est « .cs » alors qu’en [Link] c’est
« .vb ».
C# : string idpers;
[Link]: Dim idpers As string

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 68

Créons un événement sur le bouton calculer comme nous l’avons fait dans c# en
faisant un double clic sur le bouton calculer.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 69

Prenons le formulaire Etudiant programmé avec C# et faisons de même avec [Link].

Nous rappelons que ce formulaire est connecté à la base de données et donc il permet
d’enregistrer dans la table Etudiant.

Nous créons un événement sur le bouton Enregistrer en faisant un double clic.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 70

Retenez qu’ici, nous avons fait la programmation procédurale. A travers elle, nous
avons mis nos codes uniquement derrière le formulaire. Voici les codes derrière le
formulaire Etudiant
'Nous importons nos bibliothèques pour manipuler des
'données avec SQL/SERVER
Imports [Link]
Imports [Link]

Public Class frmEtudiant

'Déclaration de deeux objets dont cnx et cmd
'L'un pour la connexion à la BD
'L'autre pour exécuter les requêtes
Dim cnx As New SqlConnection
Dim cmd As New SqlCommand

'Création de la méthode d'ouverture de connexion

Sub Connecter()
If [Link] = [Link] Then
[Link] = "Data Source=JUSTINKABANZA\KABANZA;Initial
Catalog=BD_Gestion_paiement_ISESOD_L3;Integrated Security=True"
[Link]()
End If
End Sub
'Création de la méthode de fermeture de la connexion
Sub Deconnecter()

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 71

If [Link] = [Link] Then

[Link]()
End If
End Sub

'Evénement enregistré
Private Sub btnEnregistrer_Click(sender As Object, e As EventArgs) Handles
[Link]
Try
Connecter() [Link] = cnx [Link] = "Insert
into Etudiant values ('" & [Link] & "','" & [Link] & "','" & [Link] & "','" &
[Link] & "','" & [Link] & "')" [Link]()
[Link]("Enregistrement effectué avec succès")
'On actualise les données dans le datagridview après enregistrement
ChargerDgv()
'On nettoie les contrôles
initialiser()
Deconnecter()
Catch ex As Exception
[Link]([Link])
End Try
End Sub

'L'initialisation des contrôles

Sub initialiser()
[Link] = ""
[Link] = ""
[Link] = ""
[Link] = ""
[Link] = ""
[Link]()
End Sub
'Evénement modifier
Private Sub btnModifier_Click(sender As Object, e As EventArgs) Handles [Link]
Try
Connecter() [Link] = cnx [Link] = "Update
Etudiant set nom='" & [Link] & "',postnom='" & [Link] & "',prenom='" &
[Link] & "',sexe='" & [Link] & "' where numat='" & [Link] & "'"
[Link]()
[Link]("Modification réussie")
'On actualise les données dans le datagridview après modification
ChargerDgv()
'On nettoie les contrôles

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 72

initialiser()
Deconnecter()
Catch ex As Exception
[Link]([Link])
End Try
End Sub
'Evénement supprimer
Private Sub btnSupprimer_Click(sender As Object, e As EventArgs) Handles
[Link]
Try
Connecter()
[Link] = cnx
[Link] = "DELETE FROM Etudiant where numat='" & [Link] &
"'"
[Link]()
[Link]("suppression effectuée")
'On actualise les données dans le datagridview après suppression
ChargerDgv()
'On nettoie les contrôles
initialiser()
Deconnecter()
Catch ex As Exception
[Link]([Link])
End Try
End Sub
'Evénement cellclick
Private Sub dataGridView1_CellClick(sender As Object, e As
DataGridViewCellEventArgs) Handles [Link]
[Link] = [Link](0).[Link]
[Link] = [Link](1).[Link]
[Link] = [Link](2).[Link]
[Link] = [Link](3).[Link]
[Link] = [Link](4).[Link] End
Sub

'Chargement du combobox sexe

Sub sexe()
[Link]("M")
[Link]("F")
End Sub

'Méthode de chargement de datagridview

Sub ChargerDgv()

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 73

Connecter()
Dim da As New SqlDataAdapter("select * from Etudiant ", cnx)
Dim dt As New DataTable
[Link](dt)
[Link] = dt
Deconnecter()
End Sub

'Evénement load
Private Sub frmEtudiant_Load(sender As Object, e As EventArgs) Handles [Link]
'En chargeant le formulaire, on charge le sexe
sexe()
'On charge les données dans le datagridview
ChargerDgv()
End Sub End
Class
Résumé : Le point commun entre C# et [Link] est l’environnement de développement.

• Les instructions utilisées en C# peuvent facilement être interprétées en [Link].

L’importation d’une bibliothèque est faite sur base du mot clé import.
• En [Link], une classe commence par public class nomclasse et se termine par En
class.
• Pour créer une méthode on utilise Sub nomclasse et se termine par End Sub.
• Il y a une complétion automatique en créant une méthode, ce qui fait qu’en
validant, la suite de la structure est complétée.
• Le mot clé Dim permet de déclarer une variable suivie de la variable, As type de
la variable.

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259
 74

Table of Contents
PLAN DU COURS ........................................................................................................................................................... 2
1ère partie : C# ...................................................................................................................... Erreur ! Signet non défini.
CHAPITRE I. INTRODUCTION ........................................................................................................................................ 2
I.1. OUTILS DE DEVELOPPEMENT............................................................................................................................. 3
I.2. SYNTAXE ............................................................................................................................................................. 3
I.3. LES CONDITIONS ................................................................................................................................................ 6
I.4. LES TABLEAUX .................................................................................................................................................. 12
I.5. ENTREE AU CLAVIER ........................................................................................................................................... 5
I.6. METHODE ......................................................................................................................................................... 13
CHAPITRE II. LA PROGRAMMATION ORIENTEE OBJET ............................................................................................. 15
II.1. OBJECTIF DE LA PROGRAMMATION ORIENTEE OBJET ....................................................................... 15
II.2. LA CLASSE .................................................................................................................................................... 16
A. Notions de portée ......................................................................................................................................... 17
B. Accesseurs et mutateurs ............................................................................................................................... 19
C. Héritage .......................................................................................................................................................... 23
D. Le polymorphisme ........................................................................................................................................ 26
CHAPITRE III. LA PROGRAMMATION EVENEMENTIELLE ........................................................................................... 31
III.1. LE FORMULAIRE ............................................................................................................................................. 31
III.2. INTERACTION AVEC LA BASE DE DONNEES................................................................................................... 35
1. CREATION DE LA BASE DE DONNEES ................................................................................................................ 36
CHAPITRE IV. LES RAPPORTS ..................................................................................................................................... 58
2ème partie : [Link] .................................................................................................................................................... 67
Chapitre I : La programmation événementielle ........................................................................................................ 67
I.1. Formulaire ........................................................................................................................................................ 67

Email: michelsadaka9@[Link]
Téléphone : +243 99 18 15 259