Langage de programmation 4 « LWEB3 » |1

PLAN DU COURS
Historique du langage de programmation C#
Première partie : Les fondamentaux du langage C#
Chapitre 1. Les types primitifs
Chapitre 2. Les structures de contrôles et itératives
Chapitre 3. Les entrées/sorties
Chapitre 4. Accès aux données
Deuxième partie : La programmation web
Chapitre 5. Technologie du web
Chapitre 6. Framework ASP.NET
Chapitre 7. La technologie MVC
Chapitre 8. Le routing
Chapitre 9. La réactivité avec jquery et ajax
 Langage de programmation 4 « LWEB3 » |2

INTRODUCTION
Le langage C# est apparu en 2000, langage conçu par le danois Anders Hejlsberg.
En octobre 1996, Microsoft, débauche Anders Hejlsberg de la société Borland. Dans la
foulée, Microsoft débauche une trentaine d’autres développeurs de Borland. Chez
Microsoft, Anders conçoit d’abord WFC (Windows Foundation Classes), c’est-à-dire les
classes Java pour interface graphique Windows. Le but était de permettre aux
programmeurs en Visual J++ (la version Microsoft du compilateur Java) de développer des
applications professionnelles dignes de ce nom. En effet, à l’époque, n’étaient disponibles
pour le développement Windows en Java que les classes AWT (Abstract Window Toolkit)
de Sun, des classes qui ne pouvaient satisfaire que des développeurs vraiment peu
exigeants (classes d’ailleurs aujourd’hui largement délaissées au profit de Swing). Les
relations entre Anders Hejlsberg et la communauté « officielle » de Java devaient vite
s’envenimer, car les classes WFC, bien que nettement plus professionnelles que ce qui
était à l’époque disponible en provenance de Sun, étaient propres à Windows et
incompatibles avec les autres systèmes, donc non conformes à la philosophie Java.
Dans la foulée, un nouveau langage était créé sous le nom de code COOL (pour
C-like Object Oriented Language). Le nom définitif devait être C#, langage qui est devenu,
et de loin, le premier langage de développement dans le monde Microsoft.
En juin 2000, Microsoft annonce, en même temps que la disparition de Visual J++
de sa gamme de produits, l’arrivée de l’architecture .NET et du langage C# dont Anders
Hejlsberg est le principal concepteur. Un an plus tard, Visual J++ fait néanmoins sa
réapparition (sous le nom de Visual J#) sans toutefois attirer les projecteurs, quasiment
dans l’indifférence. Visual J# est aujourd’hui abandonné, faute de combattants.
Pourquoi ce nom de C# ? Le C évidemment pour attester de l’appartenance au
monde C et C++. Et le # (croisillon) ? En notation musicale américaine, # indique « un ton
au-dessus ». On peut aussi voir dans # quatre + disposés en carré, ce qui évoque C++++,
à la signification évidente pour les programmeurs.
.NET constitue-t-il une révolution dans la manière de concevoir et d’utiliser les
programmes ? La réponse est incontestablement affirmative pour la manière de concevoir
et d’écrire des programmes : les programmeurs C++ habitués au développement à la dure
avec MFC découvriront, surtout s’ils passent au C# (ce qui constitue un jeu d’enfant pour
eux), la facilité de Delphi et du véritable développement à partir de briques logicielles. Les
programmeurs en Visual Basic découvriront un environnement de développement
entièrement orienté objet, comparable à l’orientation objet du C++ et du C# (et sans rien à
avoir à envier à ces deux géants). Dans tous les cas, le développement d’applications Web
 Langage de programmation 4 « LWEB3 » |3

et surtout de services Web s’avère bien plus facile. Écrire une application Web devient en
effet presque aussi simple que l’écriture d’une application Windows.
 Langage de programmation 4 « LWEB3 » |4

PREMIERE PARTIE

LES FONDAMENTAUX DU LANGAGE C#

 Langage de programmation 4 « LWEB3 » |5

CHAPITRE 1. TYPE ET VARIABLE

I.1.Les types de base
Les types de données permettent de stocker des valeurs dans l'application. Les
langages.NET étant fortement typés, il n'est pas toujours possible de convertir un type de
données en un autre. Les conversions, implicites ou explicites, permettent de convertir les
types de données. Cela est possible car tous les types du Framework.NET dérivent du
type Object qui est le type de base de tous les autres types.
I.1.1. Types numériques
Les types numériques sont décomposés en deux parties : les entiers et les déci-
maux. Chacun dispose d'un ensemble de types pour représenter les données de la
manière la plus judicieuse en fonction des besoins.
I.1.1.1. Les entiers
Type .Net Nom C# Description Plage de valeurs
System.Byte byte Entier non signé de 8 bits
De 0 à 255
System.Int16 short Entier signé de 16 bits De -32 768 à 32 767
System.Int32 int Entier signé de 32 bits De -2 147 483 648 à 2 147 483
647
System.Int64 long Entier signé de 64 bits De -9 223 372 036 854 775 808
à 9 223 372 036 854 775 807
System.SByte sbyte Entier signé de 8 bits De -128 à 127
System.UInt16 ushort Entier non signé de 16 De 0 à 65 535
bits
System.UInt32 uint Entier non signé de 32 De 0 à 4 294 967 295
bits
System.UInt64 ulong Entier non signé de 64 De 0 à 18 446 744 073 709 551
bits 615
Une valeur peut être assignée à un entier avec une notation :
 décimale : int i = 2 ; // notation décimale
 hexadécimal : int i = 0x4B
 binaire : int i = 0b1101 ; aussi int i = 10_000_000 // notation binaire équivalent
à 10000000
 Langage de programmation 4 « LWEB3 » |6

I.1.1.2. Les décimaux

Type .Net Nom C# Description Plage de valeurs

System.Single float Nombre à virgule 7 chiffres significatifs
flottante de 32 bits
System.Double double Nombre à virgule 15 chiffres significatifs
flottante de 64 bits
System.Decimal decimal Nombre à virgule 28 chiffres significatifs
flottante de 128 bits
I.1.2. Type booléen
Un booléen est un type qui permet de représenter une valeur qui est soit true, soit
false. Le type .NET correspondant est System.Boolean et son nom C# est bool.
I.1.3. Les chaînes de caractères
Le type System.String (string) est un type de référence qui représente une série de
types System.Char (char). Une variable de type char est assignée avec un caractère placé
entre guillemets simples :
Char c = ‘a’ ;

Le type char représente une instance d’un caractère Unicode de 16 bits. Il est donc
possible d’affecter une valeur à un type char en utilisant la valeur numérique du caractère
Unicode qui consiste à fournir un caractère sous forme hexadécimale de 4 chiffres :
Char c = ‘\u0061’ ; // équivalent à : c = ‘a’ ;

Une variable de type string est assignée avec une chaine de caractères placée
entre des guillemets doubles :
string s = "Ma chaîne";

Le type string étant un type référence, il possède des méthodes permettant de

manipuler les chaînes. Le tableau suivant présente des méthodes parmi les plus utilisées :

Type .Net Description

Format Remplace les expressions de type {0},{1},{2}, etc. présentes dans
la chaîne par les valeurs passées en paramètres lors de l’appel de
la fonction
Replace Remplace toutes les occurrences d’un caractère dans la chaîne
par un autre
 Langage de programmation 4 « LWEB3 » |7

Type .Net Description

Split Sépare la chaîne en plusieurs en fonction d’un caractère délimiteur
Substring Retourne une partie de la chaîne
ToCharArray Retourne un tableau de type char à partir de la chaîne
ToLower Convertit tous les caractères de la chaîne en minuscule
ToUpper Convertit tous les caractères de la chaîne en majuscule
Trim Supprime les espaces en début et fin de chaîne
Syntaxe des chaînes de caractères
Une chaîne de caractères peut avoir deux syntaxes différentes :
 Syntaxe avec caractères d'échappement : La chaîne est entourée par les
guillemets et l'anti-slash introduit un caractère spécial (\n, \t ...) ou empêche
son interprétation (guillemet \" et anti-slash \\)
 Syntaxe verbatim : La chaîne est précédée d'un caractère arobase, et l'anti-
slash n'est pas interprété. Si un guillemet doit faire partie de la chaîne de
caractère, il faut le doubler "".
Interpolation
Elle consiste à composer une chaîne de caractère en plaçant le nom de la variable
directement dans la chaîne (précédée du caractère $) en les encadrant par la séquence
{}.
string s = "Alphonse";

console.Write($ "Bienvenue {s} !") ; // Bienvenue Alphonse ;

I.1.4. La conversion des types

La conversion de types peut être effectuée de deux manières différentes :
 la conversion implicite : elle se fait de manière automatique
 la conversion explicite, la conversion et le type doivent être spécifiés
I.1.4.1. Conversion implicite

Du type Vers le type

byte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
int long, float, double, decimal
 Langage de programmation 4 « LWEB3 » |8

Du type Vers le type

long float, double, decimal
float double
sbyte short, int, long, float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
uint long, ulong, float, double, decimal
ulong float, double, decimal
char int, uint, long, ulong, float, double, decimal
Les constants et les énumérations
Les constantes sont des variables qui ne peuvent pas être modifiées lors de
l’exécution. Elles permettent d’une part d’associer des noms conviviaux à des valeurs
fréquemment utilisées dans le code, et d’autre part de centraliser une valeur de manière
à ne la modifier qu’une seule fois pour toute l’application. Les énumérations sont un
ensemble de constantes facilitant la lisibilité et la maintenance du code.
Les constantes se déclarent par le mot clé const. Quant aux énumérations, elles
permettent de grouper des constantes sémantiquement liées :
enum JourSemaine

{
Lundi,
Mardi,
Mercredi,
Jeudi,
Vendredi,
Samedi,
Dimanche
}

Les membres d’une énumération sont numérotés de façon séquentielle en

commençant par 0.
I.1.4.2. Les tableaux
Les tableaux permettent de grouper des séries de variables et d’y accéder au
moyen d’un index basé sur 0. Les tableaux peuvent avoir une ou plusieurs dimensions.
La déclaration d’un tableau se fait en ajoutant [] au type de données qui seront
stockées et son initialisation se fait en indiquant le nombre maximum d’éléments qu’il
pourra contenir.
 Langage de programmation 4 « LWEB3 » |9

int[] Tab ;

Tab = new int[10] ;

Il y a possibilité de déclarer et initialiser en même temps

int [] Tab = new int[10];

L’exemple ci-dessous déclare un tableau d’entiers pouvant contenir jusqu’à 10

éléments avec index compris entre 0 et 9.
6. Les collections
Une collection est un type spécialisé qui organise et expose des groupes d’objets.
A l’image des tableaux, on accède aux membres par un index. La différence est que les
collections sont redimensionnables et qu’il est possible d’ajouter et de supprimer des
membres lors de l’exécution.
Les collections se trouvent dans l’espace de noms System.Collections. La plus
commune des collections est le type ArrayList qui permet d’ajouter et de supprimer
dynamiquement des éléments soit à la fin, soit à un index prédéterminé :
ArrayList maCollection = new ArrayList() ;

maCollection.Add(new object()) ;

maCollection.Insert(0,”ABC”);

La collection de type ArrayList contient des objets de type object. Il est possible
d’insérer plusieurs types d’objets différents. Cela implique que, lors de la récupération,
l’objet doit être converti explicitement :
string s = (string)maCollection[0] ;

Le principal intérêt des collections est de pouvoir réaliser une boucle de tous les
membres grâce à l’instruction foreach :
forach (objet o in maCollection)

Lorsque vous utilisez cette syntaxe, il faut vous assurer que tous les membres ont
le même type que la variable d’itération et si ce n’est pas le cas, le corps de la boucle doit
comporter un processus pour tester le type de l’objet :
forach (objet o in maCollection)

if(o.GetType() == typeof(string))
 Langage de programmation 4 « LWEB3 » | 10

Les objets d’accès avec la boucle foreach sont en lecture seule. Pour créer une
boucle sur une collection afin d’en modifier les membres, il faut utiliser une boucle for.

Les types structurés

Le mot clé struct permet la définition d'un type. Le type créé représente des
variables structurées avec un ou plusieurs champs de données. Ci-dessous, une variable
de type PointS est une variable contenant deux champs entiers. Ces champs s'appellent
X et Y et peuvent être désignés à l'aide de la notation p.X et p.Y où p est une variable de
type PointS.
using System;
namespace Exemple
{
struct PointS // PointS est un type
{
public int X;
public int Y;
}
class Program
{
static void Main(string[] args)
{
PointS p1,
p2; // p1 et p2 sont des variables de type PointS
p1.X = 3;
p1.Y = 4;
p2.X = 6;
p2.Y = 1;
}
}
}
 Langage de programmation 4 « LWEB3 » | 11

Les opérateurs
1. Les opérateurs de calcul
Comme en mathématique, les opérateurs de calcul aident à effectuer le calcul.
Addition : elle est réalisée avec l’opérateur +
a+b
Soustraction : -
a-b
Multiplication : *
a*b
Division : /
a/b
modulo : %
a%b
2. Les opérateurs d’assignation
Ils permettent d’assigner une valeur à une variable. L’opérateur utilisé est =
a = b // On assigne à la variable a la valeur b.
Il est possible de combiner l’assignation et le calcul :
x += 5 => x = x + 5
x -=5 => x = x – 5
3. Les opérateurs de comparaison
Ils sont utilisés dans le cadre de décisions au sein d’instruction de contrôle.
1. == détermine si deux valeurs sont égales ;
Ex : x == y, va renvoyer une valeur True (vraie) sir x est égale à y
2. != détermine si deux valeurs sont différentes
x != y, cette expression renvoie la valeur True si x est différente de y
3. >, cet opérateur détermine si la valeur à sa gauche est supérieure à la valeur
de droite
x > y, true si la valeur de la variable x est supérieure à la variable y
 Langage de programmation 4 « LWEB3 » | 12

4. > = supérieur ou égal

5. <, inférieur
6. <=
 Langage de programmation 4 « LWEB3 » | 13

2. LES INSTRUCTIONS DE CONTROLE

2.1. Les instructions conditionnelles
Les instructions conditionnelles permettent d’exécuter une portion de code en
fonction de tests effectués sur les variables de l’application.
A. if, else et else if
if (expression_à_évaluer)
{
Instructions
}
[else if(expression_à_évaluer)
{
instructions
}]
else
{
Instructions
}

L’instruction if évalue l’expression booléenne, entre parenthèse et execute les

instructions de son bloc si l’expression est vraie. L’instruction else permet d’intégrer le
code qui sera exécuté si l’expression évaluée dans l’instruction if est fausse.
L’instruction else if permet d’évaluer une nouvelle expression lorsque celle de
l’instruction if est fausse.
Le bloc if else peut s’écrire sous forme d’une expression ternaire :
Condition?[instruction si vrai] : [instruction si faux]
B. Switch
Une instruction switch peut être considérée comme une suite d’instructions if, else
if et else.
 Langage de programmation 4 « LWEB3 » | 14

Syntaxe
switch (expression)
{
Case expression ou constance :
Instructions
[instruction de saut]
[default :
Instructions ]
}

Une instruction switch évalue la valeur d’une variable passée en paramètre et

exécute les instructions en fonction des valeurs possibles :
switch (i)
{
Case 0 :
i++ ;
break;
case 1:
i--;
break;
default :
i=0 ;
break ;
}
Le code sous defaulf s’exécutera si et seulement si aucune des conditions
précédentes n’est remplie. default est facultatif.
2.2. Les instructions itératives
Elles permettent d’effectuer des boucles sur une série d’instructions en fonction de
l’évaluation d’une expression. Les instructions itératives sont les boucles for, while, do
while et foreach.
A) Boucle for
Synthase
for (initialization; expression;pas)
{
instructions
}
 Langage de programmation 4 « LWEB3 » | 15

La boucle for contient une série d’instructions qui seront exécutées plusieurs fois suivant
les paramètres d’initialisation, d’expression et de pas. L’initialisation est la déclaration
et l’affectation d’une variable de type numérique. A chaque passage dans la boucle, la
variable est incrémentée de la valeur du pas et l’expression est évaluée afin de déterminer
si les instructions doivent être exécutées ou non.
Exemple d’utilisation :
int somme=0;
for (int i; i<4;i++)
{
somme +=i;
}
// somme=6;
B) Boucle while
Synthase
while (expression)
{
instructions
}
La boucle while permet d’exécuter une série d’instructions tant que l’expression
évaluée est vraie.
int i=0;
while (I < 4)
{
i++;
}
// i=3;

C) Boucle do while
Synthase
do
{
instructions
}
while (expression) ;
 Langage de programmation 4 « LWEB3 » | 16

La boucle do while est similaire à la boucle while dans le sens où les instructions
de la boucle sont exécutées si l’évaluation de l’expression vraie. La différence entre les
deux boucles réside dans le fait que la boucle do while effectue la vérification de
l’expression après l’exécution des instructions. Cette boucle garantit que les instructions
seront exécutées au moins une fois.
int i=0;
do
{
i--;
}
while (i >= 0)

// i=-1;

D) Boucle foreach
Synthase
foreach(type nom in object)
{
instructions
}

Les boucles foreach sont utiles pour parcourir les tableaux, les collections et tous
les types énumérables. L’instruction déclare un type et parcourir l’objet passé en
paramètre pour le type donné. La boucle s’exécute tant qu’il y a des éléments dans l’objet.
string nom = “alphonse”;
string son_nom=””;
foreach(char c in nom)
{
Son_nom += c ;
}
// son_nom = “alphonse”;

Il est clair que la variable nom de type string est une collection de type char. La boucle
foreach les prend un par un et les affecte à la variable c de type char. La variable peut
ensuite être utilisée dans le corps de la boucle.
 Langage de programmation 4 « LWEB3 » | 17

2.3. Les instructions de saut

Les instructions de saut permettent de modifier le flux d’exécution du programme.
Les instructions de saut sont break, continue, goto, return et throw.
a) l’instruction break
L’instruction break permet de sortir d’une boucle ou d’une instruction switch sans
attendre la fin de l’exécution de toutes les instructions :
for (int i = 0; I < 10;i++)
{
if (i == 5)
{
Break;
}
}
// i = 5, le corps de la boucle a été exécuté 5 fois

b) Continue
L’instruction continue permet d’arrêter l’exécution du corps d’une boucle et de
passer à la prochaine évaluation :
for (int i = 0; I < 10;i++)
{
if (i > 5)
{
Continue;
}
}
// i = 5, le corps de la boucle a été exécuté 10 fois

c) goto
L’instruction goto permet de transférer l’exécution à un bloc d’instructions. Cette
instruction est héritée des anciens langages procéduraux tels que le basic. Une instruction
goto est suivie par le nom d’une étiquette et l’exécution du code est transférée à celle-ci.
L’étiquette est définie dans le code par un nom suivi du caractère deux points :
 Langage de programmation 4 « LWEB3 » | 18

int i = 0 ;
ajout :
i++;
if (i < 5)
{
goto ajout;
}
// i = 5

d) return
L’instruction return est utilisée au sein d’une fonction et permet de définir la valeur
de retour de celle-ci :

int Addition(int a, int b)

{
return a + b;
}

e) throw
L’instruction throw permet de lever des exceptions. L’exécution est immédiatement
interrompue et la nature de l’erreur est passée à l’appelant dans la pile d’appel jusqu’à être
interceptée et traitée :
throw new Exception ();
 Langage de programmation 4 « LWEB3 » | 19

3. La programmation orientée objet en C#

3.1. Le paradigme objet en bref (vocabulaire)
La Programmation Orientée Objet (POO) est une façon de programmer et de
décomposer des applications. Qu'est-ce qu'un objet ? C'est une variable structurée avec
des fonctions membres. Ses attributs ? ce sont les champs de données d'un objet. Ils
décrivent ses caractéristiques. Par exemple, X et Y sont les attributs d'un objet de type
PointS.
Ses méthodes ? autre nom (utilisé en POO) pour les fonctions membres. Les
méthodes représentent les mécanismes/ les fonctionnalités dont dispose un objet. C'est
ce qu'il sait faire, son comportement. L'ensemble des méthodes d'un objet est aussi appelé
l'interface d'un objet.
L'encapsulation ? en POO, les attributs ne sont généralement pas accessibles
directement (contrairement à X et Y dans le type PointS) par l'utilisateur. Généralement,
les données d'un objet (valeurs de ses attributs) sont accessibles seulement via ses
méthodes. Le fait de cacher les données d'un objet à l'utilisateur est appelé encapsulation.
Le but de l'encapsulation est de forcer l'utilisateur à se concentrer uniquement sur les
méthodes de l'objet, ce qu'il sait faire, sans forcément savoir comment il le fait.
Etat d'un objet ? c'est la valeur de l'ensemble de ses attributs, à un instant donné.
Par exemple, l'état d'un objet de type PointS est simplement la valeur de ses coordonnées.
Les objets d'un même type ont tous les mêmes attributs, les mêmes caractéristiques, mais
des états différents. Tous les objets PointS ont X et Y comme attributs, mais la valeur de
ces attributs n'est pas identique pour tous les objets.
Le C# utilise le mot clé class pour pouvoir définir d'autres types structurés avec des
méthodes (struct ne convient pas à tous les objets). Les types class sont plus riches que
les types struct et conduisent à un fonctionnement différent de la gestion de la mémoire.
 Langage de programmation 4 « LWEB3 » | 20

using System;
namespace TypeClass
{
class Program
{
class PointC
{
// membres privés = inaccessibles depuis l'extérieur
de //l'objet (encapsulés)
private int X;
private int Y; // en revanche, les méthodes sont
//publiques
public void SetXY(int pX,int pY)
{
X = pX; Y = pY;
}
public void GetXY(out int pX, out int pY)
{
pX = X; pY = Y;
}
public string ToString()
{
return "(" + X.ToString() + "," + Y.ToString()
+ ")";
}
}
static void Main(string[] args)
{
PointC p3 = new PointC();
PointC p4 = new PointC();
p3.SetXY(2, 3);
p4.SetXY(6, 1);
Console.WriteLine(p3.ToString()); //affiche état de
p3
Console.WriteLine(p4.ToString()); //affiche état de
p4
int x, y;
p3.GetXY(out x, out y); // obtient l'état de l'objet
p3
Console.WriteLine("x={0} y={1}",x,y); // p3.X = 4;
// IMPOSSIBLE → p3.X n'est pas accessible
}
}
}

Qu'est-ce que l'instanciation ? C'est le fait de créer un objet (une instance d'une
classe). Un type classe décrit les caractéristiques d'un ensemble d'objets. Un objet est une
instance particulière d'un ensemble potentiellement infini d'objets ayant les mêmes
 Langage de programmation 4 « LWEB3 » | 21

méthodes et les mêmes attributs. Pour illustrer, Etre Humain représente une classe
d’“objets“ dont les attributs et les méthodes sont nombreux (couleur des yeux, des
cheveux, langue(s) parlée(s), taille, poids, marcher, manger, parler …). Chacun d'entre
nous est une instance de la classe Etre Humain avec ses propres valeurs d'attribut (brun,
yeux marrons, …). De même Voiture est une classe d'objets dont les attributs sont par
exemple le nombre de portes, la couleur, la puissance, la motorisation, la cylindrée, les
dimensions …
La voiture Renault Clio II 1.6 16V immatriculée FR 425 TZ est une instance de la
classe Voiture.
Dans l'exemple précédent, p3 et p4 désignent deux instances (deux objets) de la
classe PointC.
L'écriture de classes en C#
1. Namespaces
Le mot clé namespace définit un espace de nommage. Ceci permet de
structurer/hierarchiser les types et de lever d'éventuels conflits de noms. On peut avoir un
même nom de type dans différents namespaces. Ci-dessous, on définit une classe A dans
différents namespaces. Il s'agit donc de classes différentes, même si elles ont même nom.
Les namespaces peuvent être imbriqués. Le nom explicite du type A du namespace
EspaceA est EspaceA.A.
 Langage de programmation 4 « LWEB3 » | 22

namespace EspaceA // namespace avec deux types A et B

{
class A { } // le type A du namespace EspaceA = EspaceA.A
class B { }
}
namespace EspaceB // namespace avec un namespace imbriqué
{
namespace ClassesImportantes
{
class A { } // ce type est EspaceB.ClassesImportantes.A
}
}
namespace EspaceB.Divers // equivaut à namespace EspaceB{ namespace
//Divers{... } }
{
class A { } // ce type est EspaceB.Divers.A
}
namespace EspaceB.ClassesImportantes // on complète le namespace
{
class B { } // ce type est EspaceB.ClassesImportantes.B
}
namespace ExempleNamespace // namespace de la classe qui contient Main
{
class Program
{
static void Main(string[] args)
{
EspaceA.A p1 = new EspaceA.A();
EspaceB.ClassesImportantes.A p2 =
new EspaceB.ClassesImportantes.A();
EspaceB.Divers.A p3 = new EspaceB.Divers.A();
EspaceB.ClassesImportantes.B p4;
}
}
}

Directive using
Cette directive permet d'importer un namespace. Cela signifie que s'il n'y a pas
d'ambiguité, les noms de types seront automatiquement préfixés par le namespace. On
allège ainsi l'écriture des noms de type. Par exemple, la classe Console (I/O) dépend du
namespace System. Le nom complet de cette classe est donc System.Console.
L'utilisation devrait donc s'écrire System.Console.WriteLine("Hello!"); Ce qui signifie “appel
de la méthode WriteLine du type Console du namespace System”.
En important ce namespace (en début de fichier) avec le mot clé using, on peut
simplifier l'écriture.
 Langage de programmation 4 « LWEB3 » | 23

2. Accessibilité
Les membres définis au sein des types peuvent avoir un niveau d'accessibilité
parmi
public : membre (donnée ou fonction) accessible par tous
private : membre accessible seulement par une méthode d'un objet de la classe
protected : membre accessible par une méthode d'un objet de la classe ou par une
méthode d'un objet d'une classe dérivée (voir plus tard la dérivation) C'est grâce à ces
modificateurs d'accès que l'on assure l'encapsulation des données. Tous les membres
(attributs, méthodes ...) doivent être déclarés avec un niveau d'accessibilité. Par défaut,
un membre est privé. Il y a aussi des modificateurs d'accès spécifiques (non expliqué dans
ce support)
internal : accès autorisé pour l'assemblage courant
protected internal : assemblage courant + sous classes Ci-dessous un exemple
de classe (reference_type) MaClasse et son utilisation dans le programme. Notons qu'il
est possible aussi de donner une initialisation des attributs pour les types class. Ce n'est
pas autorisé pour les types struct.
Surcharge des méthodes
Surcharger les méthodes, c'est définir plusieurs méthodes ayant le même nom mais
des signatures différentes :
 dont le nombre de paramètres est diffèrent
 le type des paramètres est différent
 les paramètres peuvent aussi avoir même type même nombre mais différer
du mode de passage de paramètre (par valeur ou par référence)
En revanche, le type de retour d'une fonction ne fait pas partie de la signature. On
ne peut pas déclarer deux fonctions qui ne diffèrent que par le type de retour.
Objet courant (référence this)
Dans une méthode, on appelle Objet Courant l'objet sur lequel est appelée la
méthode.
Dans l'exemple ci-dessous, quand on invoque obj1.Compare(obj2), l'objet courant
est obj1. Dans une méthode, on peut désigner l'objet courant par la référence this. Notons
que par défaut dans une méthode, quand on désigne un attribut sans préfixer par une
référence d'objet, il s'agit d'un attribut de l'objet courant.
 Langage de programmation 4 « LWEB3 » | 24

using System;
namespace ObjCourant
{
class MaClasse
{
private int _val;
public MaClasse(int v) // constructeur (cf section suivante)
{ _
val = v; // équivaut à
this._val=v;
}
public bool Compare(MaClasse obj)
{
return _val == obj._val; // équivaut à return
this._val==_obj.val;
}
}
class Program
{
static void Main()
{
MaClasse obj1 = new MaClasse(12); // 2 instances
//différentes
MaClasse obj2 = new MaClasse(14);
Console.WriteLine("obj1 et obj2 ont le même état ? =
{0}", obj1.Compare(obj2));
}
}
}

Constructeurs (initialisation des objets)

Un constructeur est une méthode qui initialise l'état d'un objet (ne retourne rien),
juste après l'allocation de l'objet (au tout début de la vie de l'objet).
Il peut aussi y avoir surcharge des constructeurs, c'est-à-dire plusieurs façons
d'initialiser un objet.
Un constructeur s'appelle comme la classe. Un constructeur peut recevoir un ou
plusieurs arguments pour initialiser l'objet. Ces arguments sont fournis au moment de
l'instanciation.
 Langage de programmation 4 « LWEB3 » | 25

using System;
namespace SyntaxeCSharp
{
class MaClasse // classe avec 3 constructeurs = 3 façons d'initialiser
{
private string _nom;
private int _val;
public MaClasse() // constructeur C1) sans argument
{
_nom = "Nestor";
_val = 12;
}
public MaClasse(int val) // constructeur C2) avec un argument
{
_val = val;
_nom = "Nestor";
}
public MaClasse(int val, string nom) // constructeur C3)
{
_val = val;
_nom = nom;
}
}
class Program
{
static void Main(string[] args)
{
MaClasse m1 = new MaClasse(); // utilise C1)
MaClasse m2 = new MaClasse(23); // utilise C2)
MaClasse m3 = new MaClasse(17,"Paul");// utilise C3)
}
}
}

Membres statiques (données ou fonctions)

Une donnée membre statique (appelée aussi variable de classe) n'existe qu'en
un seul exemplaire, quel que soit le nombre d'objets créés (même si aucun objet n'existe).
C'est une variable unique, quel que soit le nombre d'instances. Un attribut est une variable
d'instance (propre à un objet)  variable de classe.
Une fonction membre statique (appelée aussi méthode de classe) peut être
appelée indépendamment de toute instance, elle n'accède donc pas aux attributs des
objets de la classe. En revanche, une fonction membre statique peut accéder aux données
membres statiques. Une telle fonction peut être invoquée même si aucune instance
n'existe. Par exemple, les fonctions mathématiques sont des fonctions statiques de la
classe System.Math. Méthode d'instance  méthode de classe.
 Langage de programmation 4 « LWEB3 » | 26

Console.WriteLine(System.Math.Sin(3.14/2)); // Sin() est fonction statique de

System.Math
Gestion des erreurs
using System;
class Prog
{
static void Main()
{
int a=10, b=0, c;
Console.WriteLine("Avant division");
c = a/b;
Console.WriteLine("Après division, c vaut " + c);
}
}

// Division par zero, le programme s’arrêtera avant le deuxième affichage

int[] t = new int[3]; // seuls les indices 0 à 2 sont accessibles
.....
t[3] = 1; // indice 3 inaccessible !

Les clauses try et catch

Pour traiter les erreurs, il faut placer dans un bloc (le bloc try en l’occurrence) les
différentes instructions susceptibles de poser problème (problème certes rare mais
prévisible). En anglais, try signifie « essayer », et on se lance effectivement dans une
tentative d’exécution d’instruction, sachant que l’on est sous contrôle. Le problème en
question pourrait se situer dans l’une des instructions du bloc try ou dans l’une des
méthodes appelées à partir du bloc try. À l’intérieur du groupe try, les instructions sont
écrites sans se soucier du traitement d’erreurs. Pour illustrer le sujet, nous allons placer
nos trois instructions dans le groupe try, bien que seule la seconde instruction soit sujette
à erreur (ce groupe try sera bientôt complété par un groupe catch) :
try
{
Console.WriteLine("Avant division");
c = a/b;
Console.WriteLine("Après division : c vaut " + c);
}

Les instructions de cette clause sont, tant qu’il n’y a pas d’erreur, exécutées
normalement en séquence. Dès qu’une erreur est détectée par le système ou par une
méthode (qui lève une exception en cas d’erreur), un objet de la classe Exception (dans
l’espace de noms System) ou d’une classe dérivée de celle-ci est automatiquement créé
et le programme rentre tout aussi automatiquement dans le bloc catch associé au bloc try :
 Langage de programmation 4 « LWEB3 » | 27

using System;
class Program
{
static void Main()
{
int a=10, b=0, c;
try
{
Console.WriteLine ("Avant division");
c = a/b;
Console.WriteLine ("Après division : c vaut " +
c);
}
catch (Exception exc)
{
Console.WriteLine("Erreur sur opération
arithmétique");
}
}
}

Comme pour le groupe try, les accolades sont obligatoires dans le groupe catch
même si celui-ci ne contient qu’une seule instruction. Le groupe catch pourrait même ne
contenir aucune instruction : cas où l’on se contente d’intercepter l’erreur, sans action
spéciale (le programme se poursuit comme si rien ne s’était passé. On ferme tout
simplement les yeux sur le problème, ce qui n’est évidemment pas sans danger. Comme
nous n’avons pas fait ici usage de l’objet Exception passé au catch, nous aurions pu ne
pas donner de nom à l’argument Exception.
Analysons le déroulement du programme précédent. Le programme entre dans le
bloc try qui contient notamment une instruction à risque, à savoir une division. Après un
premier affichage (aucun problème ne peut survenir à ce stade), le programme est
suspendu lors de l’exécution de c = a/b qui provoque une division par zéro mais il n’est
pas éjecté du système. On a en effet effectué une tentative d’exécution mais nous avons
prévu une possibilité d’erreur (puisque nous sommes dans un groupe try). Suite à la
division par zéro, le contrôle est automatiquement transféré au bloc catch, sans exécuter
le second WriteLine. Si toutes les instructions du bloc try avaient été exécutées sans erreur
(dans le cas où b aurait été différent de zéro), le bloc catch n’aurait pas été exécuté. À
l’intérieur des parenthèses d’une clause catch, on doit trouver un objet de la classe
Exception ou d’une classe dérivée de celle-ci. Un nom d’objet est souvent spécifié en
argument, de manière à obtenir des informations complémentaires au sujet de l’erreur (par
exemple le champ Message de la classe Exception qui décrit clairement l’erreur, voir une
explication plus complète ainsi que les autres propriétés à la fin de ce chapitre). Plusieurs
 Langage de programmation 4 « LWEB3 » | 28

blocs catch peuvent être spécifiés pour prendre en compte plusieurs erreurs possibles.
Dans l’exemple suivant, différentes erreurs peuvent être générées en fonction des
contenus de i et j : division par zéro (ArithmeticException) et accès à un tableau en dehors
de ses bornes (IndexOutOfRangeException).
Le groupe finally
Un troisième bloc peut être spécifié : le bloc finally. Les instructions du bloc finally
sont toujours exécutées, quel que soit le cheminement du programme (l’exécution sans
problème et donc complète dans le groupe try ou l’entrée suite à une erreur dans le catch).
On est ainsi sûr de libérer dans tous les cas les ressources qui viennent d’être allouées.
Si plusieurs blocs catch peuvent être associés à un bloc try, un seul bloc finally peut être
associé à un bloc try. Comme pour les groupes try et catch, les accolades sont obligatoires
dans un groupe finally.
using System;
class Program
{
static void Main()
{
try
{
Console.WriteLine("Début du try de Main");
f();
Console.WriteLine("Fin du try de Main");
}
catch (Exception)
{
Console.WriteLine("Erreur");
}
}
static void f()
{
int a=10;
int[] t = new int[3];
..... // une ou plusieurs instructions initialisant i et j
try
{
Console.WriteLine("Début du try de f");
t[i] = a/j;
Console.WriteLine("Fin du try de f");
}
finally
{
Console.WriteLine("Finally de f");
}
}
}
 Langage de programmation 4 « LWEB3 » | 29

III. MANIPULATION DES DONNEES

3.1. Systèmes de fichier
Les classes permettant de gérer le système de ficher se trouvent dans l’espace de nom
System.IO
Grâce à ces classes nous pouvons manipuler les lecteurs, les dossiers et les fichiers.
1. La Classe DriveInfo
Elle fournit des membres permettant d’obtenir des informations sur les lecteurs d’une
machine. Parmi les méthodes de DriveInfo, nous avons :

Méthode Description
GetDrives Retourne un tableau d’objets DriveInfo correspondant aux
lecteurs de la machine sur laquelle est exécutée
l’instruction
AvailableFreeSpace Indique la quantité d’espace libre sur le lecteur en octets
DriveFormat Indique le format du système de fichiers du lecteur (NTFS,
FAT32, CDFS, …)
DriveType Indique le type du lecteur
IsReady Indique si le lecteur est prêt à être utilisé
Name Indique le nom du lecteur (lettre d’accès)

2. Les Classes Directory et DirectoryInfo

Ces deux classes sont utilisées pour manipuler les dossiers. La plupart des méthodes de
la classe DirectoryInfo sont implémentées également dans la classe Directory.
Création d’un dossier dans un lecteur
Avec la classe Directory
Directory.CreateDirectory(@ "C:\dossier") ;
Avec la classe DirectoryInfo
DirectoryInfo directory=new DirectoryInfo(@"")
directory.Create();
 Langage de programmation 4 « LWEB3 » | 30

Suppression d’un dossier

La classe DirectoryInfo expose une méthode Delete pour la suppression d’un dossier
existant.
Si le dossier à supprimer n’existe une exception de type DirectoryNotFoundException sera
levée. D’où une vérification préalable de l’existence du dossier sera nécessaire avant la
suppression.
if (Directory.Exists(@"D:\LWEB3")) Directory.Delete(@"D:\LWEB3")
Déplacement du dossier
Le déplacement de dossier se fait avec la méthode Move pour la classe Directory et
MoveTo pour la classe DirectoryInfo.
Obtention des sous-dossiers
Les méthodes GetDirectories ou EnumerateDirectories présentes dans les deux classes
permettent d’obtenir les sous-dossiers d’un dossier.
string [ ] dirs = Directory.GetDirectories(@"D:\LWEB3") ;
IEnumerable<string> enumDirs=Directory.EnumerateDirectories(@"D:\LWEB3");

DirectoryInfo directory= new DirectoryInfo(@"D:\LWEB3")

DirectoryInfo[ ] dirs. = directory.GetDirectories();
IEnumerable< DirectoryInfo > enumDirs= directory. EnumerateDirectories ();

3. Les Classes File et FileInfo

Les deux classes ont un mode de fonctionnement similaire aux classes Directory et
DirectoryInfo. La classe File est statique et la classe FileInfo doit être instanciée. Le choix
de l’une ou l’autre classe est fonction du nombre d’opérations à effectuer.
Une opération unique sera plus rapidement réalisée avec la classe File alors qu’une
multitude d’opérations nécessitera la classe FileInfo.
Ces deux classes permettent d’une part, de créer, de déplacer, de supprimer des fichiers
ainsi que de modifier leurs propriétés et d’autre part, de lire et écrire dans les fichiers.
 Langage de programmation 4 « LWEB3 » | 31

Création du fichier
La création d’un fichier retourne un objet du type FileStream associe. L’écriture de
données dans ce flux entraînera l’écriture dans le fichier. Exécuter la méthode d’un fichier
sur un fichier déjà existant écrasera l’ancien fichier.
FileStream fileStream=File.Create(@"C:\Lweb3\test.txt") ;

FileInfo fichier = new FileInfo(@"C:\Lweb3\test.txt") ;

FileStream fileStream= fichier.Create() ;
fileStream.Dispose();
Pour lire ou écrire des données dans un fichier existant, il faut utiliser les methods Open,
OpenRead, OpenText ou OpenWrite:
FileStream fs=File.Open(@"C:\Lweb3\test.txt",FileMode.Open) ;
Fs.Dispose();

FileInfo fichier= new FileInfo(@"C:\Lweb3\test.txt",FileMode.Open) ;

FileStream fileStream= fichier.Open(FileMode.Open) ;
fileStream.Dispose();

Suppression
Comme pour Directory et DirectoryInfo, la suppression d’un fichier se fait avec la méthode
Delete. Si le fichier qui est tenté d’être supprimé n’existe pas, aucune expression n’est
levée.
Copie et déplacement des fichiers
Pour la classe File la copie se fait avec la méthode Copy et le déplacement avec la
méthode Move tandis que pour la classe FileInfo la copie est réalisée par la méthode
CopyTo et le déplacement par MoveTo.
File.Copy(@"C:\Lweb3\test.txt",@"C:\ test.txt")
File.Move (@"C:\Lweb3\test.txt",@"C:\ test.txt")
 Langage de programmation 4 « LWEB3 » | 32

FileInfo fichier = new FileInfo(@"C:\Lweb3\test.txt",@"C:\ test.txt");

Fichier.CopyTo(@"C:\ test.txt");
Fichier.MoveTo(@"C:\ test.txt");
La copie ou le déplacement d’un fichier vers un emplacement contenant le même nom de
fichier générera une exception de type IOException.
4. La Classe Path
Path est une classe statique exposant des méthodes essentielles pour des opérations sur
les chemins des dossiers et des fichiers.

Méthode Description Exemple d’utilisation

ChangeExtensions Modifie l’extension string
d’un fichier result=Path.ChangeExtension(@"C:\
test.txt”,”doc”)
Combine Combine plusieurs Path.Combine(@"C:\
chemins LWeb3”,”MonProjet”,”Program.cs”);
GetDirectoryName Retourne le chemin du
répertoire relatif au
chemin spécifié
GetExtension Retourne l’extension
du fichier dans le
chemin spécifié
GetFileName Retourne le nom du
fichier avec son
extension
GetPathRoot Retourne le répertoire
racine du chemin
spécifié
 Langage de programmation 4 « LWEB3 » | 33

Lecture d’un fichier texte

a) Avec la classe File
La classe File exposent des méthodes permettant de lire des données dans un
fichier.
 ReadAllText : cette méthode prend en paramètre le chemin d’un fichier à lire.
La méthode lit le contenu du fichier passé en paramètre et le ferme puis renvoie
le contenu lu dans un objet de type string.
string fichier = File.ReadAllText(@"C:\ test.txt") ;
ReadAllText dispose d’une surcharge permettant de spécifier le type
d’encodage utilisé
string fichier = File.ReadAllText(@"C:\ test.txt", Encoding.ASCII) ;
 ReadAllLines : elle fonctionne de la même manière que la méthode ReadAllText
à la seule différence que le contenu est retourné sous forme d’un tableau de
type string. Chaque élément du tableau correspondant à une ligne du fichier
string [] fichier = File.ReadAllLines (@"C:\ test.txt") ;
 ReadLines : Cette méthode retourne un objet générique IEnumerable dont
chaque élément représente une ligne du fichier
IEnumerable<string> fichier = File.ReadLines (@"C:\ test.txt")
a) Avec la classe File
La classe StreamReader est utilisée pour lire des fichiers texte.
StreamReader stream= new StreamReader(@"C:\ test.txt”) ;
Des surcharges du constructeur de la classe StreamReader permettent de specifier
l’encodage avec un objet Encoding.
StreamReader stream= new StreamReader(@"C:\ test.txt”,Encoding.ASCII) ;
La méthode ReadLine retourne un objet de type string correspondant à la ligne du
curseur et positionne celui-ci à la ligne suivante :
string ligne = stream.ReadLine() ;
La propriété EndOfStream envoie la valeur true si la fin du fichier est atteinte.
 Langage de programmation 4 « LWEB3 » | 34

While ( !stream.EndOfStream)
{
string s=stream.ReadLine() ;
}
La méthode ReadToEnd retourne un objet de type string contenant la totalité du
fichier entre la position du curseur et la fin du fichier.
Après les opérations de lecture sur le fichier, l’objet StreamReader doit fermer avec
la méthode Close()
Ecriture dans un fichier texte
a) Avec la classe File
Plusieurs méthodes dont exposées par la classe File pour l’écriture dans un fichier
texte.
 WriteAllText : La méthode WriteAllText prend en paramètre le chemin du fichier
et le contenu à écrire.
File.WriteAllText(@"C:\ test.txt”,”Texte à écrire”)
La accepte une surcharge pour préciser le type d’encodage
File.WriteAllText(@"C:\ test.txt”,”Texte à écrire”,Encoding.ASCII)
b) Ecriture avec la classe StreamWriter
L’écriture avec streamwriter implique d’instancier un nouvel objet streamwriter, en
lui passant en paramètre le fichier à écrire, et faire appel aux méthodes nécessaires pour
l’écriture des données.
StreamWriter stream= new Stream (@"C:\ test.txt”) ;
Les méthodes à utiliser sont Write et WriteLine.
Sérialisation et désérialisation
La sérialisation et la désérialisation sont utiles lorsque nous souhaitons envoyées
vers une autre application les données relatives à des objets. La sérialisation convertit un
objet en un flux. Il est ainsi possible d’enregistrer ce flux dans un fichier ou de le
transmettre à une autre application.
La récupération de ce flux et sa transformation en objet sont appelées la
désérialisation.
 Langage de programmation 4 « LWEB3 » | 35

Pour qu’une classe soit sérialisable elle doit être précédée de l’attribut [serializable]
sans quoi le compilateur va générer une erreur.
Le framework .Net nous offre deux techniques de sérialisation :
 La sérialisation binaire : Elle crée une copie exacte de l’objet sérialisé ;
 La sérialisation XML : crée une représentation des propriétés et des champs
publics uniquement.
Nous allons nous intéresser à la première technique, la sérialisation binaire.
Les bases
Comme dit précédemment, la classe sérialisable doit être marquée par m’attribut
[Serializable] sans quoi une exception de type SerializationException.
La sérialisation utilise un formateur binaire du type BinaryFormatter de l’espace de
noms System.Runtime.Serialization.Formatters.Binary. Pour effectuer la transformation, il
suffit pour cela d’appeler la méthode Serialize de cet objet en lui passant en paramètre le
flux dans lequel écrire les données et l’objet à sérialiser.
Soit à sérialiser la classe Etudiant ci-après :
public class Etudiant
{
public Matricule ;
public NomEtudiant ;
public Adresse ;
}
1) Ajout de l’attribut serialisable à la classe Etudiant
[Serializable]
public class Etudiant
{
public Matricule ;
public NomEtudiant ;
public Adresse ;
}
 Langage de programmation 4 « LWEB3 » | 36

2. Instanciation d’un objet de la classe Etudiant et sérialisation

Etudiant et1=new Etudiant() ;
et1.Matricule="788520" ;
et1.Adresse="250, Boulevard du 30 Juin" ;
3. Création du formateur binaire
IFormatter formatter =new BinaryFormatter() ;
4. Création du flux
Stream stream = new FileStream(@"C:\ test.txt", FileMode.Create,FileAccess.Write) ;
5. Sérialisation de l’objet
formatter.Serialize(stream,et1) ;
stream.Close() ;
stream.Dispose() ;
La désérialisation suit le même schéma que la sérialisation. Elle utilise également
un formateur binaire sur lequel il faut appeler la méthode deserialize.
1. Création du formateur binaire
IFormatter formatter= new BinaryFormatter() ;
2. Création du flux
Stream stream =new FileStream ((@"C:\ test.txt", FileMode.Open)
3. Désérialisation
Etudiant et1=(Etudiant) formatter.Deserialize(stream);
stream.Close() ;
stream.Dispose() ;
 Langage de programmation 4 « LWEB3 » | 37

Sérialisation Xml
Xml (Extensible Markup Language) est un langage de balisage. Il est utilisé pour
faciliter l’échange automatique des contenus entre systèmes d’information hétérogènes.
La sérialisation Xml contrairement à la sérialisation binaire ne sérialise que les
éléments dont la portée est définie publique. Elle ne concerne pas également des objets
graphiques (images, …).
Etapes
1) Rendre la classe sérialisable
2) Créer un flux vers un fichier devant contenir les données à sérialiser
3) Instancier la classe Xmlserializer qui se trouve dans l’espace de nom
System.Xml.Serialization
4) Appeler la méthode Serialise pour sérialiser ou Deserialize pour désérialiser

Etudiant et1=new Etudiant () ;

FileStream fichier=File.Open(fileName,FileMode.Create) ;
XmlSerializer s = new XmlSerialize(typeof(Etudiant));
s.Serialize(fichier,et1);
 Langage de programmation 4 « LWEB3 » | 38

3.2. Persistance avec la base des données ado.net

Sous .NET, l'accès aux données s'effectue à l'aide du bloc de services ADO.NET.
ADO.NET est un ensemble de classes qui exposent les services d'accès aux
données pour les programmeurs .NET Framework. ADO.NET propose un large ensemble
de composants pour la création d'applications distribuées avec partage de données. Partie
intégrante du .NET Framework, il permet d'accéder à des données relationnelles, XML et
d'application. ADO.NET répond à divers besoins en matière de développement, en
permettant notamment de créer des clients de bases de données frontaux et des objets
métier de couche intermédiaire utilisés par des applications, outils, langages ou
navigateurs Internet.
ADO.NET sépare l'accès aux données de leur manipulation en composants
distincts qui peuvent être utilisés individuellement ou en tandem. ADO.NET comprend des
fournisseurs de données .NET Framework pour la connexion à une base de données,
l'exécution de commandes et l'extraction de résultats. Ces résultats sont traités
directement, placés dans un objet DataSet ADO.NET pour pouvoir être exposés à
l'utilisateur de manière adéquate, combinés aux données de différentes sources ou
passées entre couches. L'objet DataSet peut également être utilisé indépendamment d'un
fournisseur de données .NET Framework pour gérer des données locales pour
l'application ou provenant de XML.
3.2.1. Composants d'ADO.NET
Les deux principaux composants d’ADO.NET pour l’accès aux données et leur
manipulation sont les fournisseurs de données .NET Framework et DataSet.
A. Fournisseurs de données
Les fournisseurs de données .NET Framework sont des composants explicitement
conçus pour la manipulation des données et pour un accès rapide aux données. Les objets
des fournisseurs de données .NET Framework
 Connection : il assure la connectivité avec une source de données ;
 Command : il permet d'accéder aux commandes de base de données en vue
de retourner des données, de modifier des données, d'exécuter des procédures
stockées et d'envoyer ou récupérer des informations sur les paramètres ;
 DataReader : il fournit un flux très performant de données en provenance
de la source de données.
 DataAdaptater : il établit une passerelle entre l'objet DataSet et la source de
données. Il utilise des objets Command pour exécuter des commandes SQL au
 Langage de programmation 4 « LWEB3 » | 39

niveau de la source de données afin d'une part de charger le DataSet avec des
données, et d'autre part afin de répercuter dans la source de données les
modifications apportées aux données contenues dans le DataSet.
Outre les objets ci-hauts présentés, un fournisseur de données .NET Framework
contient également les classes répertoriées dans le tableau suivant.
Object Description
Transaction
Inscrit des commandes dans des transactions au niveau de la
source de données. La classe de base pour tous les
objets Transaction est la classe DbTransaction . ADO.NET
fournit aussi la prise en charge pour les transactions à l'aide
des classes dans l'espace de noms System.Transactions .
CommandBuilder
Objet d'assistance qui génère automatiquement les
propriétés de commande d'un DataAdapter ou dérive les
informations sur les paramètres à partir d'une procédure
stockée et remplit la collection Parameters d'un objet Command .
La classe de base pour tous les objets CommandBuilder est la
classe DbCommandBuilder .
ConnectionStringBuilder
Objet d'assistance qui offre une manière simple de créer et
de gérer le contenu de chaînes de connexion utilisées par les
objets Connection . La classe de base pour tous les
objets ConnectionStringBuilder est la
classe DbConnectionStringBuilder .
Parameter
Définit les paramètres des valeurs d'entrée, de sortie et de
retour pour les commandes et les procédures stockées. La
classe de base pour tous les objets Parameter est la
classe DbParameter .
Exception
Retourné en cas d'erreur au niveau de la source de données.
Pour une erreur rencontrée sur le client, les fournisseurs de
données .NET Framework lèvent une exception .NET
Framework. La classe de base pour tous les
objets Exception est la classe DbException .
Error
Expose les informations provenant d'un avertissement ou
d'une erreur retournée par une source de données.
ClientPermission
Fourni pour les attributs de sécurité d'accès du code du
fournisseur de données .NET Framework. La classe de base
pour tous les objets ClientPermission est la
classe DBDataPermission .
 Langage de programmation 4 « LWEB3 » | 40

Le tableau suivant répertorie les fournisseurs de données inclus dans le .NET

Framework.
fournisseur de Description
données .NET
Framework
Fournisseur de Fournit l'accès aux données pour Microsoft SQL Server. Utilise
données .NET l'espace de noms System.Data.SqlClient .
Framework pour SQL
Server
Fournisseur de Pour les sources de données exposées à l'aide de OLE DB.
données .NET Utilise l'espace de noms System.Data.OleDb .
Framework pour OLE
DB
fournisseur de Pour les sources de données exposées à l'aide de ODBC.
données .NET Utilise l'espace de noms System.Data.Odbc .
Framework pour
ODBC
fournisseur de Pour les sources de données Oracle. Le fournisseur de
données .NET données .NET Framework pour Oracle prend en charge le
Framework pour logiciel client Oracle version 8.1.7 et ultérieure, et utilise
Oracle l'espace de noms System.Data.OracleClient.
fournisseur Fournit un accès aux données pour les applications EDM
EntityClient (Entity Data Model). Utilise l'espace de
noms System.Data.EntityClient .
Fournisseur de Fournit l'accès aux données pour Microsoft SQL Server
données .NET Compact 4.0. Utilise l’espace de
Framework pour noms System.Data.SqlServerCe .
SQL Server Compact
4.0.

B. Le DataSet
Le DataSet ADO.NET est explicitement conçu pour un accès aux données
indépendamment de toute source de données. Il peut donc être utilisé avec plusieurs
sources de données différentes, utilisé avec des données XML ou utilisé pour gérer des
données locales de l'application. Le DataSet contient une collection d’un ou plusieurs
objets DataTable constitués de lignes et de colonnes de données, ainsi que des
informations concernant les contraintes de clé primaire, de clé étrangère et des
informations relationnelles sur les données contenues dans les objets DataTable.
 Langage de programmation 4 « LWEB3 » | 41

Utilisez un DataSet pour effectuer les opérations suivantes :

 Mettre des données en cache localement dans votre application afin de
pouvoir les manipuler. Fournir un accès distant entre couches ou à partir
d'un service Web XML.
 Interagir dynamiquement avec les données par le biais par exemple de la
liaison à un contrôle Windows Forms ou de la combinaison et la mise en
relation de données de diverses sources.
 Réaliser un traitement complet des données sans qu'une connexion ouverte
à la source de données soit nécessaire, ce qui libère la connexion pour
d'autres clients.
Si par contre, notre besoin est de lire uniquement les résultats d'une requête,
le DataReader serait le meilleur choix.
3.2.2. LINQ
LINQ (Language INtegrated Query) apporte une syntaxe de requête au langage
C#. Il fournit un niveau d’abstraction permettant d’accéder à différentes sources de
données en utilisant une seule et même syntaxe.
LINQ utilise une syntaxe avec des mots clés prédéfinis tels que from, where,
orderby ou select pour extraire les données d’une collection d’objets.
LINQ utilise deux syntaxes :
 La syntaxe méthode : fait appel à des méthodes, elle est la syntaxe la plus
utilisée ;
 La syntaxe query : elle ressemble à sql
Quelques exemples :
var etudiant = from etud in Etudiants
where etud.promotion == “L2”
orderby etud.Matricule
select etud;
var etudiant = Etudiants
.Where(c=>c.Matricule=="L2")
.OrderBy(d=>d.Matricule);
 Langage de programmation 4 « LWEB3 » | 42

Cette requête retourne une liste d’objets de type Etudiants ayant la valeur L2 pour
la propriété promotion et les ordonne par la propriété matricule.
Une requête LINQ doit commencer par la clause from et finir par la clause select
ou group. Et peut comprendre entre ces deux clauses des clauses where, orderby ou join
ou encore des clauses from supplémentaires.
Il existe plusieurs domaines d'applications pour LINQ :
 Linq To Entities ou Linq To SQL qui utilisent ces extensions de langage sur
les bases de données.
 Linq To XML qui utilise ces extensions de langage pour travailler avec les
fichiers XML.
 Linq To Object qui permet de travailler avec des collections d'objets en
mémoire.
3.2.2.1. Les opérateurs de requêtes
A. Filtrer
Where
Comme avec sql, la méthode permet une collection selon un ou plusieurs critères.
var query = from ms in Etudiant
where ms.Matricule==”788523”
select ms;
L’expression ci-haut sélectionne dans la collection Etudiant la ou les lignes dont la
propriété matricule est égale à 788523.
Skip et Take
Ces deux méthodes sont utilisées pour effectuer la pagination des résultats. La
méthode Skip permet d’ignorer un certain nombre d’éléments. Quant à la méthode Take,
elle permet de spécifier le nombre d’éléments à retourner.
var query = (from ms in Etudiant
where ms.Matricule==”788523”
select ms)
.Skip(5)
.Take(10);
 Langage de programmation 4 « LWEB3 » | 43

A. Ordonner
OrderBy
La méthode permet d’ordonner les éléments suivant un ou plusieurs critères
spécifiés.
var query = from ms in Etudiant
orderby ms.Matricule
select ms;
ThenBy
Dans le cas où plus d’un critère de tri doit être utilisé, on fait recours aux méthodes
ThenBy et ThenByDescending.
C. Ordonner
Cette méthode permet de regrouper les résultats en se basant sur la valeur d’une
clé.
var query = from ms in Etudiant
group ms by ms.promotion into g
select new
{
Matricule=g.Matricule,
Nom=g.Nom,
Adresse=g.Adresse
};
D. Join
La clause join permet de faire une jointure de deux sources basée sur un critère
spécifique.
 Langage de programmation 4 « LWEB3 » | 44

ENTITY FRAMEWORK
C’est un ORM (Objet Relationnal Mapping) puissant fourni par Microsoft. Il permet
d’interagir avec la base de données sans avoir besoin d’utiliser du SQL.
Avec EF on peut gérer la structure de la base de données en se servant de
migration.
Procédure :
Package nuget :
 Créer une classe DbContext, classe d’interaction avec la base de données
 Overrider la méthode OnConfiguring pour spécifier la chaîne de connexion,
 Lire et écrire dans la BDD à l’aide d’EF Core,
dotnet add package Microsoft.EntityFrameWorkCore.SqlServer
Créer une nouvelle classe MyDbContext qui héritera de la classe DbContext
public class MonDbContext : DbContext
{
public DbSet<TableName> Personnes {get ; set ;}=default ;
protected override void OnConfiguring(DbContextOptionsBuilder
optionsBuilder)
{
optionBuilder.UserSqlServer(“stringConnection”);
base.OnConfiguting(optionsBuilder);
}
}
 Langage de programmation 4 « LWEB3 » | 45

Deuxième partie : La programmation web

Langage de programmation 4 « LWEB3 » | 46