ESGAE_C#_2021-2024 Cours Avancé (('.pptx

Ingénieur Christopher BANDZOUZI
1
« Les ordinateurs sont comme les dieux de
l’Ancien Testament : avec beaucoup de règles, et
sans pitié. »

Ingénieur christ BANDZOUZI
Ingénieur Christofer BANDZOUZI
2

3
Objectif Général: Cet enseignement vise à fournir à
l’étudiant les connaissances fondamentaux du
langage programmation de C# et l’environnement de
programmation Visual studio de la plate forme .net
Objectifs Spécifique: Au terme de cet
enseignement, l’étudiant doit être en mesure:
• de comprendre le rôle du Framework .net;
• D’utiliser les différents techniques d’accès aux
bases de données (ADO.NET et Link)
• De comprendre les principes du développement
objet avec C#
• De développer les applications avec C#

Plan du cours
 Rappel 0 : Présentation du langage
 Rappel 1 : Les bases du langage C#
 Chapitre 2 : Structures, Classes et Interfaces
 Chapitre 3 : Classes d’usage courant
 Chapitre 4 : Interfaces graphiques
 Chapitre 5 : Gestion des événements
 Chapitre 6 : Accès aux bases de données
 Travaux Pratiques
4

5
Objectifs Spécifique: Au terme de ce chapitre,
l’étudiant doit être capable :
• De connaitre les concepts du langage C#
• D’appliquer les formalismes du langage C#

Présentation du langage
 C# est un langage de programmation pour la plateforme
.NET Framework
 Sa syntaxe ressemble à celui d’autres langages de
programmation comme Java, C/C++,…
 C# est un langage dit à « code géré » : la gestion de la
mémoire est automatique
 C’est un langage de programmation compilé : vous devez
compiler le programme avant de l’exécuter
6
Chapitre 0 :

 C# est une base pour développer des applications ciblant
différent plateforme
Desktop
Web
Mobile
C#
7
Chapitre 0 :

 C# est un langage en constante évolution
2001 2012
2005 2007 2010 2015
.NET 1.0
C# 1.0
Version
initiale
.NET 2.0
C# 2.0
Les méthodes
anonymes
La généricité
Les methods
iterateurs
Les classes
Partielles
Les types
nullables
.NET 3.0
C# 3.0
L’inférence
de type
Les initialiseurs
d’objets
Les types
anonymes
Les propriétés
.NET 4.0
C# 4.0
Programmation
dynamique
Paramètres
Namés
Paramètres
optionels
.NET 4.5
C# 5.0
Les méthodes
asynchrones
(async, await)
Attributs caller
Information
Changement
closure pour la
boucle foreach
.NET 4.6
C# 6.0
Imports
statiques
Interpolation
de chaînes
Filtres
d'exception
Opérateur
nameof
8
realese
Chapitre 0 :

 C# est un langage ayant de bons IDE facilitant le
développement et le débugge des applications
9
Chapitre 0 :

10
• D’écrire les programmes en langage C#
• D’appliquer les syntaxe du langage C#

Chapitre 1 : Les bases du
langage C#
La syntaxe du langage
 Les identifiants
Les identifiants sont les noms donnés aux classes et à leurs membres
ou aux variables
Un identifiant doit :
 être composé d’un seul mot
 commencer par une lettre ou un underscore ( _ )
Les identifiants peuvent être composés de lettres majuscules ou
minuscules
NB : le langage C# est sensible à la casse
11

langage C#
 Les commentaires
// commentaires pour texte court : 1 ligne
/* commentaires pour long texte : 2+ lignes */
 Les mots clés
Les mots clés sont des noms réservés par le langage C#
Ils ne peuvent pas être utilisés en tant qu’identifiants
NB : Si vous avez besoin d’utiliser un mot clé en tant qu’identifiant
pour un membre, il faut préfixer le nom de l’identifiant par le
caractère @
Exemple : public class @class { };
12

langage C#
 Les mots clés (la liste)
abstract add as ascending base bool break by byte case
catch char checked class const continue decimal default delegate descending
do double dynamic else equals enum event explicit extern false
finally fixed float for foreach from get global goto group
if implicit in int interface internal into is join let
lock long namespace new null object on operator orderby out
override params partial private protected public readonly ref remove return
sbyte sealed select set short sizeof stackalloc static string struct
switch this throw true try typeof uint ulong unchecked unsafe
ushort using value var virtual volatile void where while yield
13

langage C#
Les variables
 La déclaration de variable
type name
int monCompteur;
string message;
14
int monCompteur = 0;
string message = ‘’Bonjour’’;
 L’affectation de valeur
int monCompteur2;
monCompteur2 = monCompteur;

langage C#
Les types de données
 C# est un langage à typage fort :
 aucune variable ne peut être utilisée sans être déclarée
 une fois déclarée, une variable ne peut plus être changée
 Il y a deux catégories de type en C#
15
Type valeur
(tous type primitifs)
struct
int
double
enum
…
Type référence
class
interface
array
delegate

langage C#
Les types de données
 La différence fondamentale entre les types de valeur et les
types de référence se situe au niveau de leur
manipulation en mémoire
16
types
valeur
types
référence
int i = 3;
int j = i;
i 3
j 3
i = 5;
public class Point { public int X, Y; }
Point P1 = new Point();
P1.X = P1.Y = 7
P1 X 7
Y 7
P2
Point P2 = P1;
5

langage C#
Les types de données(les primitifs)
17
Type Taille en octets Type d’exécution Description Plage de valeurs
byte 1 Byte Entier non signé de 8 bits De 0 à 255
sbyte 1 SByte Entier signé de 8 bits De -128 à 127
short 2 Int16 Entier signé de 16 bits De -32 768 à 32 768
ushort 2 UInt16 Entier non signé de 16 bits De 0 à 65 535
int 4 Int32 Entier signé de 32 bits De -2 147 483 648 à 2 147 483 647
uint 4 UInt32 Entier non signé de 32 bits De 0 à 4 294 967 295
long 8 Int64 Entier signé de 64 bits
De -9 223 372 036 854 775 808
à 9 223 372 036 854 775 807
ulong 8 UInt64 Entier non signé de 64 bits De 0 à 18 446 744 073 709 551 615
float 4 Single Nombre à virgule flottante de 32 bits 7 chiffres significatifs
double 8 Double Nombre à virgule flottante de 64 bits 15 chiffres significatifs
decimal 8 Decimal Nombre à virgule flottante de 128 bits 28 chiffres significatifs
string variable String Chaine de caractères Unicode variable
char 2 Char Caractère Unicode 1
bool 1 Boolean
Représente le résultat une expression
logique
true ou false

langage C#
Conversion de type
La conversion d’un de variable un autre est
appelée « casting »
18
int nbEntier = 0;
float nbReel = 2,5f;
nbReel = nbEntier; // OK : conversion implicite de int à float
nbEntier = nbReel ; // ERREUR : conversion explicite de float
// à int est obligatoire, car il y a risque de
// perte de données
nbEntier = (int) nbReel ; // OK maintenant : car conversion
//explicite de float à int

langage C#
Les opérateurs et les expressions
 Une expression est un ensemble d’opérandes et des
opérateurs qui produit un résultat
E1(X) = 5 + 2 - |X| ou E2 =
−𝑏± 𝑏2−4𝑎𝑐
2𝑎
 Les opérateurs sont des symboles ou des fonctions qui
déterminent comment évaluer les expressions
 Les opérateurs usuels dans leurs ordre de priorité
19
1. Multiplicatif * / %
2. Additif + -
3. Relationnel == != < > <= >= is as
4. Logical && || ! true false
5. Bitwise & | ^ ~
6. Ternaire ?:
7. Affectation = += -= *= /= %=
&= |= ^= <<= >=

langage C#
Les structures conditionnelles
 La paire if else
Les structures conditionnelles if else permettent de faire
des choix alternatifs sur base d’une condition
20
?
Flux d’exécution
faux
vraie
if ( condition ) {
}
else {
}
//code à exécuter si la
//condition est vérifiée
//code à exécuter dans
//le cas contraire
NB : les expressions ternaires permettent aussi des choix alternatifs
int entier = ( val1 < val2 ) ? val1 : val2;

langage C#
Les structures conditionnelles
 La structure switch
Les structures conditionnelles switch permettent de faire des
choix en se basant sur une liste finie de valeurs
21
switch ( valeur ) {
}
case valeur1 :
break;
//code à exécuter
case valeurN :
break;
//code à exécuter
default :
break;
//code à exécuter
//en C#, chaque option a une
//instruction break à la fin
NB : les mots break et continue
permettent de sortir des
blocs

langage C#
Les boucles itératifs
La boucle itération est un bloque de qui a
vocation de s’exécuter de façon répétitive
22
for ( int i = vi; i < vf; i++ ){
}
while ( condition ) {
} while ( condition )
do {
}
NB : la condition est une expression booléenne à vérifier
Il y a une autre version pour la boucle for :
foreach ( élément dans un ensemble ) { }
//code à exécuter
//jusqu’à ce que la
//valeur maximale vf
// soit atteinte
// code à exécuter
// si la condition
// est vérifiée
// code à exécuter
// si la condition
// est vérifiée
//code à exécuter

langage C#
Les constantes et les énumérations
Les constantes et énumérations sont des contrats basiques de
C# permettent de maintenir le code propre
facile à comprendre
facile à maintenir
23
if ( valeur == 0) {
}
//code à exécuter
if ( valeur == CONGELATION ) {
}
//code à exécuter
// Mauvaise pratique,
// que signifie 0 ?
// Et si ça devait changer
// Bonne pratique, facile à //
comprendre et à
// maintenir
const int CONGELATION = 0;
const int CONGELATION = 0;
const int CHAUD = 40;
const int BOUILLON = 100;
const int FROID = 15;
enum Temperature
CONGELATION = 0;
CHAUD = 40;
BOUILLON = 100;
FROID = 15;
}
{
CNTP = 27;
: shot

langage C#
Les tableaux
Un tableau est une structure de taille statique regroupant
un ensemble de données de même type
24
type nomTableau [ ] = new type [taille];
// exemple d’un tableau d’entiers de taille 10
Int[ ] tableauEntiers = new int[10];
NB : On peut avoir des tableau de types complexes class struct
// pour affecter à l’élément en position 3 la valeur 5
tableauChaines [2] = 5;
Pour accéder à un élément du tableau en position index il
suffit d’écrir :
nomTableau[index] // index varie entre 0 et taille-1

langage C#
Les procédures et fonctions
Les fonctions fournissent un moyen efficace de
constituer des blocs de traitement réutilisables
25
[ type de retour|void ] nomFonction ( [ ref|out ] type parm ) {
}
//code à exécuter dans
//le cas contraire
[ return élément à retourner;]
NB : il y a une possibilité de construire des fonctions avec :
des paramètres nommés
des paramètres ayant des valeurs initiales
des paramètres facultatifs
Les variables en C# en une porté « de bloque »

26
De comprendre les principes du développement objet
avec C#
• d’appliquer les principes et méthodes de la
programmation orientée objet;

Chapitre 2 : Structures, Classes
et Interfaces
La POO et C#
 C# est un langage de POO : les notion de classes et
d’objets sont fondamentales
 Tout est objet en C# :
 les types (même les primitifs)
 Le programme
27
int entier = new int();
entier = 5;
class Program
{
static void Main(string[] args)
{
}
}
int entier;
entier = 5;
Console.WriteLine("entier = {0}",entier);
Objet 1
données
…
traitements
…
Objet 2
données
…
traitements
…

et Interfaces
La notion de Classe et d’Objet
 Une classe est la description d’une catégorie d’objet
 Elle supporte l’héritage et permet d’avoir en une seule
structure des propriétés et des méthodes (membres) : on
parle alors d’encapsulation
 Elle est, de façon pratique en C#, un type référence
 Les classes sont des moules utilisées pour créer des objets
: les objets créés sont des instances
28

et Interfaces
La notion de Classe et d’Objet
29
class
Rectangle
longueur
largeur
calculSurface( )
RectA
12
4
"surface = 48"
RectB
8
6
" surface = 48 "
RectC
9
9
" surface = 81 "

et Interfaces
Définir une Classe dans C#
30
public class Personne {
}
// Supposons que nous
// voulions représenter
// une personne
// Les champs contenant les données
string nom;
string prenom;
string titre;
// Méthode qui retourne le nom
public string nomComplet( ){
// Traitement de calcul
}
// Constructeur
public Personne (string nom, string prenom){
longueur = L;
largeur = l ;
}

et Interfaces
Création et utilisation des Objets
 En C# l’opérateur new est utiliser pour créer ou instancier
des objets d’une classe
 Pour utiliser les champs et les méthodes d’une classe, on
utilise l’opérateur "."
 Les membres static n’exigent pas l’intanciation de la classe
avant d’être utilisés
31
Personne user = new Personne(" TOTO", " Lolo");
user.nomComplet( ); // Appel de la méthode nomComplet
Console.WriteLine("Salut"); // Appel de la méthode WriteLine

et Interfaces
Membres d’instance et static
 Les membres d’instance sont liés aux objets d’une classe
et s’invoque sur un objet
 Les membres static sont liés à la classe et peuvent être
invoqués sans instanciation de celle-ci
32
class Personne{
string nom;
short anneeNaissance;
static int populationMondiale;
public Personne(string nom, short an){
this.nom = nom;
this.anneeNaissance = an;
populationMondiale++;
}
}

et Interfaces
Les modificateurs d’accès
 Par défaut, les données et méthodes définies dans une
classe ne peuvent être utilisés que dans celle-ci
 Les modificateurs d’accès spécifient comment des
programmes qui utilisent vos classes peuvent accéder leurs
membres
33
NB : Un assembly est un package de code comme une bibliothèque ou
un autre programme
class Personne{
string nom;
short anneeNaissance;
static int populationMondiale;
}
Par défaut
tous ces champs
sont privés
public
private
protected

et Interfaces
Les modificateurs d’accès
34
Accesibilité Description
public Aucune restriction d’accès
protected Accessible dans la classe qui a déclarée ou dans les classes
dérivées
internal Accessible par tous les types dans le même assembly de la
classe qui a déclarée et les autres assembly spécifiquement
nommés en utilisant le mot clé internal
protected internal N’import quel accès autorisé par protected or internal
private Seulement accessible dans la classe qui a déclarée
public
private
protected

et Interfaces
Les champs et les propriétés
 Dans une classe, les champs et les propriétés sont les
membres qui contiennent les données
 Les propriétés ont la particularité de permettre les calculs à
la volé : elles apportent un peu de logique au données
35
class Personne{
protected string nom;
private int anneeNaissance;
public static int populationMondiale;
}
//quand il n’y a pas de traitements spécifiques
public int Age { get; set; }
public int Age {
get{ return (DateTime.Now.Year - this.anneeNaissance); }
set{ this.anneeNaissance = (DateTime.Now.Year - value); }
}

et Interfaces
L’héritage de classe
 En C#, les classes peuvent hériter des attributs et des
méthodes d’autres classes
36
class Personne {
public Personne(string nom, short an)
{
this.nom = nom;
}
}
class Agent : Personne {
protected double salaire;
public Agent (string nom, short an, double salaire) :
base (nom,an)
{
this.salaire = salaire;
}
}

et Interfaces
La sur-définition (surcharge de méthode)
 La surcharge sert à proposer, pour un même nom de
méthode, plusieurs signatures (différentes manières de l’appelée
car le type de retour ne fait pas parti de la signature)
37
class Personne {
}
// surcharge du
// constructeur
// constructeur avec paramètres
public Personne(string nom, short an) {
this.nom = nom;
}
// constructeur à vide
public Personne( ) {
}

et Interfaces
surcharge des opérateurs
38
 C# permet la surcharge d’opérateurs dans des classes:
 Les opérateurs arithmétiques:
unaires: + - ! ~ ++ --
binaires:+ - * / % & | ^ << >>
 Les opérateurs de conversion de type (appelés aussi opérateurs de transtypage.
 Les opérateurs de comparaison:
== != < > <= >=

et Interfaces
La redéfinition de méthode
 La redéfinition c’est la possibilité que nous offre la POO de
pouvoir changer ou augmenter le comportement des
méthodes dans les classes (sans en changer la signature)
 Pour signifier au compilateur que la méthode Crier peut être
redéfinie : public virtual void Crier( ){ … }
 Dans les classes filles pour redefinir :
public override void Crier( ){ … }
 Dans une classe fille pour utiliser le méthode de la classe
mère : base.Crier( );
39
Animal
Crier( )
Lion
Crier( )
Chien
Crier( )
Chat
Crier( )

et Interfaces
Les classes abstraites
 Une classe abstraite est une classe qui ne peut être
instancié : il faut la dériver et instancier ses filles
 Une classe abstraite a forcement au moins une méthode
abstraite
 Une méthode abstraite est déjà virtuelle par définition: il ne
faut plus utiliser le clé virtual
40
public
}
abstract class Animal {
public abstract void Crier( );
public class Lion : Animal {
public override void Crier( ) { … }
}

et Interfaces
Les classes sellées
 Une classe sellée est une classe qui ne peut être héritée :
c’est l’opposé d’une classe abstraite
 Les méthodes individuelles peuvent être sellées
 Il est courant de trouver les classes sellées que les
méthodes sellées dans une classe
41
public
}
sealed class Mulet {
public sealed void SeReproduire( );
public class AutreEspece : Mulet {
public override void SeReproduire( ) { … }
}
// ERREUR

et Interfaces
Les interfaces
 Une interface procure un moyen de grouper un ensemble
de comportements dans un seul endroit où plus d’une
classe peut les utiliser
 Une interface définit un protocole (contrat) qui devra être
respecté par toutes les classes qui l’implémentent
 Une classe peut implémenter plusieurs interfaces
 Toutes les méthodes d’une interfaces sont abstraites par
définition : il ne faut plus utiliser le clé abstract
42
public class iAmovible {
void SeMouvoir( );
}
public class Animal : iAmovible {
public void SeMouvoir( ) { … }
}

et Interfaces
Le polymorphisme
 Le polymorphisme est la capacité, pour un même
message de correspondre à plusieurs formes de
traitements selon l'objet auquel ce message est adressé
 Pour mettre en œuvre le polymorphisme, il suffit d’avoir une
même méthode dont le traitement diffère entre plusieurs
classes :
 Soit ces classes implémenteraient une méthode de la même
interfaces
 Soit elles redéfiniraient une méthode de la même classe
43

44
• D’utiliser les classes d’usages courant;

Chapitre 3 : Classes d’usage
courant
Les tableaux multidimensionnels
Un tableau multidimensionnel a plus d’une dimension
45
Int multiDimTab [ , ] = new int [3,3];
multiDimTab [0,1] = 10;
NB : Un tableau multidimensionnel n’est pas forcement carré
Int multiDimTab [ , ] = new int [ , ] {
{ 0, 1, 2 },
{ 4, 5, 9 },
{ 8, 6, 7 },
};
[ 0 ] [ 1 ] [ 2 ]
[ 0 ]
[ 1 ]
[ 2 ]
10
0 1 2
4 5 9
8 6 7

courant
Les fonctions relatives aux tableaux
 Les tableaux sont bien sûr des objets dans C#
 La classe qui permet de les manipuler est : Array
46
int tableauEntiers [ ] = { 4,7,5,8 };
tableauEntiers.GetLenght( ); // retourne sa taille : 4
Array.Clear(tableauEntiers,0,4); // le de nettoyer(efface)
//de 0 à 4
Array.Sort(tableauEntiers); // trie le tableau en paramètre :
// { 4, 5, 7,8 }
Array.Reverse(tableauEntiers); // renverse le tableau en
// paramètre : { 4, 5, 7,8 }

courant
Les tableaux
47
 C# permet la création et l’utilisation de tableaux à une
ou plusieurs dimensions.
 Les types de tableaux sont tous des types référence. En
fait chaque type de tableau est une classe qui hérite de
la classe abstraite System.Array.
 C# oblige tous les éléments d’un tableau à avoir le
même type. Cette contrainte peut être facilement
contournée. Il suffit de spécifier que les éléments sont
des références vers une classe de base, pour qu’en fait,
chaque élément puisse être une référence vers un objet
de n’importe quelle classe dérivée.

courant
Les tableaux dynamiques (ArrayList)
Un ArrayList est comme un tableau mais a une taille
dynamique : qui varie au besoin
48
// instanciation d’un ArrayList
ArrayList tableauDynamique = new ArrayList ( );
ArrayList tableauDynamique = new ArrayList (capacité);
// quelques méthodes
tableauDynamique.Add(Object o);
tableauDynamique.Insert(int i, Object o);
tableauDynamique.Remove(Object o);
tableauDynamique.RemoveAt(int i);
tableauDynamique.Count;
// indexer un élement
tableauDynamique[ index ]
tableauDynamique[ index ] = "capacité";
NB : Un ArrayList peut contenir élements de types différents
Il y a une autre version pour la boucle for :
foreach ( object o in tableauDynamique ) { Console.WriteLine("{0}", o) }

courant
Les piles (la classe Stack)
Une Stack est une implémentation en C# de la notion de
pile
Une Stack une structure de taille dynamique mais elle
respect le principe LIFO
49
Stack pile = new Stack( ); //instanciation
pile.Push("Chaine 1"); // empiler de Chaine 1
pile.Push("Chaine 2"); // empiler de Chaine 2
Object o = pile.Pop( ); // dépiler
Object o = pile.Peek( ); // retourner sans dépiler
Int taille = pile.Count; // conter le nombre d’élts
"Chaine 2"
pile
"Chaine 1"

courant
Les files (la classe Queue)
Une Queue est une implémentation en C# de la notion
de file
Une Queue est une structure de taille dynamique mais
elle respect le principe FIFO
50
Queue file = new Queue( ); //instanciation
file.Enqueue("Chaine 1"); // entrée de Chaine 1
file. Enqueue("Chaine 2"); // entrée de Chaine 2
Object o = file.Dequeue( ); // sortir
Object o = file.Peek( ); // retourner sans sortir
Int taille = file.Count; // conter le nombre d’élts
"Chaine 2"
file
"Chaine 1"

courant
Les dictionnaires
Les dictionnaires implémentent en C# la notion
d’annuaire ou répertoire : les tableaux associatifs
Ils sont des structures type clé-valeur
Chaque clé doit être unique car le dictionnaire n’a pas la
notion d’ordre
51
Une implémentation en C# de la notion de dictionnaire
est la classe Hashtable
BZ Brazzaville
PN Pointe-Noire
Fils 05 060 00 80
dictionnaire
Hashtable dico = new Hashtable( ); //instanciation
dico.Add("BZ", "Brazzaville" ); // ajout de elt
dico.Add("PN", "Pointe-Noire" ); // ajout de elt
dico["Fils"] = 05 060 00 80 ; // ajout de elt
dico.Remove("BZ"); // supprimer Brazzaville
int taille = dico.Count; // conter le nombre d’élts
bool test = dico.ContainsKey("PN"); // teste clé d’élts
bool test = dico.ContainsValue("Brazzaville" ); // teste valeur
// d’élts

courant
Les fichiers (les classes File & Stream)
Quand on lit ou écrit des données dans un fichier, quand
on les envoie ou quand les recevoir d’un réseau, elles
sont transformées en flux de données.
52
1010101…..00110
Fichier
Réseau
Internet
Stockage de données
Flux de données

courant
Un flux peut être ouvert en écriture, en lecture ou les
deux à la fois
Tous les flux héritent de la classe abstraite
System.IO.Stream
53
Stream
FileStream MemoryStream NetworkStream

courant
L’espace de nom System.IO fourni des classes pour la
manipulation des fichiers et dossiers
54
Fourni des fonctions de haut-niveau pour la manipulation des fichiers
File
FileInfo
FileStream
Stockage de données
Flux de données
Directory
DirectoryInfo
Fourni des fonctions de bas-niveau pour plus de contrôle des fichiers
Expose un flux associé à un fichier, avec un contrôle détaillé
Fourni des fonctions de haut-niveau pour la manipulation des dossiers
Fourni des fonctions de bas-niveau pour plus de contrôle des dossiers

courant
 Travailler avec des fichiers existant
La classe System.IO.File offre les méthodes communes à la
manipulation des fichiers :
55
Vérifie si le fichier dont l’emplacement est
donné en paramètre existe
File.Exists
Créé un fichier à l’emplacement donné en
paramètre
File.Create
Copy le fichier à l’emplacement indiqué
File.Copy
File.Move Déplace le fichier à l’emplacement indiqué
File.Delete Supprime le fichier à l’emplacement indiqué

courant
Les dossiers(la classe Directory)
 Travailler avec les dossiers
Travailler avec les dossier est assez similaire à la manipulation
des fichiers :
56
Vérifie si le dossier existe
Directory.Exists
Créé un dossier
Directory.CreateDirectory
Retourne le dossier courant
Directory.GetCourantDirectory
Directory.Move Déplace le dossier
Directory.Delete Supprime le dossier
Retourne les fichiers contenus
Directory.GetFiles
Retourne les dossiers contenus
Directory.GetDirectories

courant
Le chemin (la classe Path)
La classe System.IO.Path offre une collection de
méthodes utiles à la manipulation des chemins:
57
C:UsersAuroreDocumentsfichier.txt
La racine le chemin
le
fichier
l'extension
Retourne le nom du dossier
Path.GetDirectoryName
Séparateur de dossier ( ou /)
Path.DirectorySeparatorChar
Retourne le nom du fichier
Path.GetFileName
Retourne le chemin complet
Path.GetFullPath
Retourne l’extension du fichier
Path.GetExtension

courant
Lecture et écriture des données
La plateforme .NET fourni plusieurs moyens pour lire les
données et pour écrire les données dans un fichier
58
File.WriteAllLines
File.AppendAllText
File.WriteAllBytes
Lire les données
Ecrire les données
File.WriteAllText
File.ReadAllLines
File.ReadAllBytes
File.ReadLines
File.AllText

courant
Les exceptions (la classe Exception)
Une exception est une erreur qui se produit durant
l’exécution d’un programme
59
int x = 10;
int y = 5;
int resultat = x / y; // OK : resultat vaut 2
y = 0;
Resultat = x / y; // ERREUR : division par 0
//exception : DivisionByZeroException

courant
Les exceptions sont levées, ou déclenchées, quand des
erreurs sont rencontrées dans le programme
Une fois qu’une exception est levée, le flux d’exécution
normal du programme s’arrête et le gestionnaire
d’exception le plus proche s’exécute
Vous pouvez créer vos propres exceptions et les
déclencher avec l’instruction throw
60

courant
Les exceptions sont des objects de la classe
System.Exception ou de ses classes dérivées
Le framework .NET défini un grand nombre de classes
pour la gestion d’exception
61
IndexOutOfRangeException FormatException
OverflowException
ArithmeticException
ApplicationException
DivideByZeroException FileNotFoundException
FileLoadException
IOException
SqlException

courant
La gestion des exceptions
Les mots clés pour la gestion des exceptions sont :
62
try { //code susceptible de levé une exception
}
catch (<type d’execption> ex) { // l’exception est géré ici
}
resultat = x / y;
finally { // le code qui s’exécutera dans tous les cas
}
Console.WriteLine("Une exception a été levée !");
int x = 10, y = 5, resultat;
Console.WriteLine("Le programme est terminé !");

courant
Création des exceptions
La classe System.Exception possède entre autres les
propriétés :
 Message (message de description de l’exception);
 Source (nom de la source d’erreur);
 StackTrace (representation des fenêtres sur la pile qui appelle au
moment où l’exception courante a été levée);
 InnerException (instance de l’exception à la cause de
l’exception courante);
 HelpLink (un lien d’aide pour fichier associé)
et les constructeurs :
 Exception( ), constructeur à vide;
 Exception( String message).
63

courant
Création des exceptions
Une exception personnalisée ressemblerait à :
64
class MonException : Exception {
public MonException (string message) :
base (message)
{
this.HelpLink = "http://www.bomoye.com";
}
}
// pour déclencher cette exception
throw new MonException("Exception perso");

courant
Réenclencher une exception
Réenclencher une exception est un processus très
intéressant dans le cadre des développements
programme à plusieurs couches
Il évite de laisser mourir une exception, quand on ne sait
pas la traiter
Pour le mettre en œuvre, il suffit d’ajouter l’une des
instruction suivante :
 throw;
 throw (instance de l’exception traité);
à la fin de instructions de la clause catch.
65

66
• De développer une application intégrant une
interface graphique.

Chapitre 3 : Interfaces
graphiques
Les WinForms et les WPF
La plateforme .NET offre plusieurs bibliothèques de
composants graphiques :
 WinForms : la vielle technologie qui permet la
création des composants graphiques
 WPF : la vielle technologie qui permet la création des
composants graphiques
67

graphiques
Les Fenêtres
68
Dim fenetre1 As Form
fenetre1 = New Form()
fenetre1.Text = "fenetre 1"
fenetre1.MdiParent = Me
fenetre1.Show()
fenetre2.Show()
fenetre3.Show()

graphiques
Les Boites de dialogue
69
Dim resultat As String
resultat = InputBox("Veuillez saisir votre nom",
"identification", "votre nom")
Dim reponse As Integer
MessageBox.Show("Voulez vous
enregistrer en quittant l’application", "Fin de
programme",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question,MessageBoxDef
aultButton.Button1)
MsgBox("Veuillez saisir votre nom",
MsgBoxStyle.OKCance1)

graphiques
Les Boites de dialogue
70
Les constantes disponibles
pour les icônes pour le bouton par défaut
pour les boutons

graphiques
Les Boites de dialogue Windows
71
Dialogue d’ouverture de fichier
Dim dlgOuvrir As OpenFileDialog
dlgOuvrir = New OpenFileDialog()
dlgOuvrir.InitialDirectory = "c:dos"
dlgOuvrir.Title = "selection du fichier à ouvrir"
dlgOuvrir.Filter
="tous|*.*|Images|*.bmp;*.gif;*.jpg|texte|*.txt"
dlgOuvrir.DefaultExt = "toto"
dlgOuvrir.AddExtension = True
dlgOuvrir.CheckFileExists = False
dlgOuvrir.Multiselect = True
dlgOuvrir.ShowDialog()

graphiques
72
Dialogue d’enregistrement de fichier
dlgOuvrir.Filter
dlgOuvrir.CreatePrompt = True
dlgOuvrir.OverwritePrompt = True

graphiques
73
Dialogue de choix de répertoire
dlgChoixRep.RootFolder = Environment.SpecialFolder.MyDocuments
dlgChoixRep.ShowDialog()
MsgBox(dlgChoixRep.SelectedPath, , "Répertoire sélectionné")

graphiques
74
Dialogue de choix d’une couleur
Dim dlgColor As ColorDialog
dlgColor = New ColorDialog()
dlgColor.FullOpen = True
dlgColor.SolidColorOnly = True
dlgColor.Color = Me.BackColor
dlgColor.ShowDialog()
Me.BackColor = dlgColor.Color

graphiques
75
Dialogue de choix d’une police
Public Class TestPolice
Inherits System.Windows.Forms.Form
Dim WithEvents dlgFont As FontDialog
Private Sub cmdPolice_click(ByVal sender As System.Object, ByVal e As
System.EventArgs)Handles cmdPolice.Click
dlgFont = New FontDialog()
dlgFont.ShowApply = True
dlgFont.ShowColor = True
dlgFont.ShowEffects = True
dlgFont.MaxSize = 20
dlgFont.MinSize = 12
dlgFont.FontMustExist = True
dlgFont.AllowScriptChange = True
dlgFont.ShowDialog()
txtEchantillon.Font = dlgFont.Font
End Sub
Private Sub dlgFont_Apply(ByVal sender As Object, ByVal e As
System.EventArgs) Handles dlgFont.Apply
txtEchantillon.Font = dlgFont.Font
End Sub
End Class

graphiques
76
Dialogue d’ouverture de fichier
dlgOuvrir.Filter
dlgOuvrir.Multiselect = True

graphiques
Les Contrôles
77
Les contrôles d’affichage d’informations
Le contrôle Label est utilisé po
ur afficher, sur un formulaire, u
n texte qui ne sera pas modifia
ble par l’utilisateur
Le contrôle Label
Le contrôle LinkLabel
Le contrôle ToolTip
Le contrôle LinkLabel hérite de toutes les caractér
istiques du contrôle Label et ajoute simplement d
es fonctionnalités de lien style Web
ToolTip1.SetToolTip(RadioButton3, "
Couleur bleu pour le texte ")

graphiques
Les Contrôles
78
Les contrôles d’édition de texte
Le contrôle TextBox
Le contrôle MaskedTextBox
Le contrôle RichTextBox

graphiques
Les Contrôles
79
Les contrôles de déclenchement d’actions
Le contrôle Button Le contrôle MenuStrip Le menu ContextMenuStrip
Le contrôle ToolStrip
Le contrôle RadioButton
Le contrôle ListBox
Le contrôle ComboBox
Le contrôle DateTimePicker

graphiques
Les Contrôles
80
Les contrôles de regroupement
Le contrôle GroupBox Le contrôle TabControl
Le contrôle Panel
Le contrôle GroupBox per
met le regroupement logiq
ue et visuel de contrôles s
ur un formulaire
Il ne dispose cependant pasd
e propriété Text et ne perme
t donc pas l’affichage d’une l
égende

Chapitre 5 : Gestions des
évènements
Principe de base de Gestions des
évènements
Dans les programme WinForms ou WPF la gestion
d’événements se fait presque de la même manière
Cette gestion est faite par programmation
événementielle
81

82
• De d’écrire les programmes avec interface
graphique et un SGBD en langage C#
• De se connecter à une base de données,
• d’y effectuer une recherche,
• de la mettre à jour grâce au langage SQL

Chapitre 6 : Accès aux bases
de données
La notion de persistance
83
Instancié
utilisé
détruit
Les entités utilisées ont un cycle de vie bien connu :
instancié
utilisé
stocker
détruit
restaurer

de données
La notion de persistance
84
Pour sauvegarder l’état des objets manipulés, plusieurs
solutions ont été proposées
La plus répandue consiste à sauvegarder dans un fichier
plat l’état des objets que l’on manipule : c’est la
sérialisation
L’état ainsi sauvegardé servira à rétablir l’état du
système par un mécanisme appelé : dessérialisation

de données
La sérialisation
C’est le mécanisme par lequel l’état d’un objet est stocké
dans un fichier ou envoyé sur le réseau
Il implique un mécanisme inverse : la désserialisation
Avec un fichier, le principe est simple :
 On saisie toutes les informations relatives à une entité sur une
seule ligne
 Un caractère spécial est utilisé en guise de séparateur entre les
différents attributs de l’entité
Le principe de persistance par sérialisation est applicable
aux base de données
85

de données
L’architecture de ADO.NET
La gestion de base de données dans la plateforme .NET
est rendue possible grâce à ADO.NET
86

de données
Connexion à la base de données
La connexion à la base est implémentée par une instance
de SqlConnection de OledbConnection
Son paramétrage s’effectue par l’intermédiaire d’une
chaîne de connexion de la forme :
 "Server=<Server>;Initial
Catalog=<Database>;uid=<Login>;password=<Password>"
 "Server=<Server>;Initial Catalog=<Database>; Integreted
Security=true"
"Data Source=localhostSQLEXPRESS; Initial Catalog=
baseDD; Integreted Security=true"
87

de données
Connexion à la base de données
String chaineConnexion = "Data
Source=localhostSQLEXPRESS;Initial Catalog=bomoye;Integrated
Security=true";
var connexion = new SqlConnection(chaineConnexion);
connexion.Open();
MessageBox.Show(connexion.State.ToString());
//Les traitements à effectuer
connexion.Close();
MessageBox.Show(connexion.State.ToString());
88

de données
La manipulation des données
La requête est une instance de la classe SqlCommand
Le curseur (ou résultat) de la requête est elle instance
de SqlDataReader
Après avoir créer la requête il l’exécuter par l’appel d’une
des méthodes suivantes:
89
Résultat Méthodes Description
Rien ExecuteNonQuery() Dans le cas des insertions, update
Un curseur (+lignes) ExecuteReader() Dans le cas des selections
Une seule valeur ExecuteScalar() Min( ), Max( ), Sum( ), Count( ),…

de données
La manipulation des données
SqlTransaction tx = connexion.BeginTransaction();
var req = new SqlCommand();
req.CommandText = "SELECT * FROM personne";
req.Connection = connexion;
var resultat = req.ExecuteReader();
if (resultat.HasRows) {
while(resultat.Read()) {
resultat.GetSqlString(1);
}
}
tx.Commit();
90

de données
Cristal report
91
 Crystal Report est un progiciel d’informatique décisionnelle qui permet de générer une
grande variété de rapports à partir de données informatiques.
 Fonctionnalités : Crystal Reports permet de créer les connexions aux données sources et
la génération de présentations graphiques à des fins de reporting.
 Données sources supportées : Parmi les données d’entrées accessibles:
 Bases de données telle que Sybase, SAPHANA (en), IBM DB2, Microsoft Access,
Microsoft SQL Server, MySQL, Interface, SQLite et Oravcle,
 Fichiers HTML XML
 Fichier texte
 Fichier Lotus
 Classeurs Microsoft Excel
 Toutes données accessibles par des liens ODBC, JDBC ou OLAP.

de données
Production de l’éxécutable
92
 Le langage C# est un langage de programmation compilé orienté objet
(langage machine : ordinateur, tablette, smartphone…). Il est supporté par
l’environnement de développement Visual Studio (Microsoft .Net) et permettent
de développer des applications sur le système d’exploitation Windows. La
compilation génère un fichier exécutable que les utilisateurs doivent installer
sur leur appareil pour faire fonctionner l’application.
 pour générer un setup, il existe des programmes tel que InnoSetup qui permet
de générer des setups d'installation.

93
Suite Chapitre 4, 5 et 6
confère
Travaux Pratiques

94 Bibliographie :
94
Michel Divay LA
PROGRAMMATION OBJET
EN C# Dunod, Paris, 2008 p460
Apprenez à développer en C#
Par nico.pyright OpenClassroom, 2013
p382
Robert Michel di Scala, Les premiers pas
dans .Net Framework avec le langage C#,
les éditions Berti Alger, 2004 p647

95
Merci pour votre attention

ESGAE_C#_2021-2024 Cours Avancé (('.pptx

Contenu connexe

Similaire à ESGAE_C#_2021-2024 Cours Avancé (('.pptx

ESGAE_C#_2021-2024 Cours Avancé (('.pptx