La technologie.

Net
Meya HAROUNE

meye.haroune@gmail.com

Meya HAROUNE
PLAN

 Introduction

 Les principales caractéristiques de .Net

 Architecture .Net

 Les bases de C#

 Programmation orienté objet en C#

Meya HAROUNE 2 2
 Introduction

 Microsoft .NET est une plate-forme commune de développement libre et open source ,

destinée à la construction de nombreux types d'applications dans l’environnement

fortement distribué.

 Proposé par la société Microsoft en 2002.

 Constitue la réponse de Microsoft à la plate-forme J2EE de Sun.

 Les applications développées pour cette plateforme sont indépendantes :

du système d'exploitation et du langage de programmation utilisé.

Meya HAROUNE 3 3
 Objectifs du .Net

Le Framework .NET est conçu pour remplir les objectifs suivants :

 Fournir un environnement cohérent de programmation orientée objet que le code objet soit
stocké et exécuté localement, mais distribué sur Internet ou exécuté à distance.
 Fournir un environnement garantit l'exécution sécurisée de code.
 Fournir aux programmeurs une grande variété de types d'applications comme les
applications Windows, les services Windows, et les applications Web, etc.
 Générer toutes les communications à partir des normes du secteur pour s’assurer que le
code basé sur le .NET Framework s’intègre à n’importe quel autre code.

Meya HAROUNE 3
4 4
Architecture du .Net
VB C++ C# JScript …

Visual Studio 2008

Common Language Specification

Windows
ASP.NET ADO.NET
Forms

Base Class Library

(CLR) Common Language Runtime

Operating System

Meya HAROUNE 5 3
5
 Architecture du .Net

Le Framework .NET possède une architecture composée de trois principales couches.

 La Common Language specification (CLS) : Assure l'interopérabilité des

langages de programmation en .NET.

 La bibliothèque de classes .NET (API.NET) : une bibliothèque cohérente et

orientée objet qui permet de développer des applications .NET.

 La Common Language Runtime (CLR) : Permet d'exécuter les applications. Le

terme utilisé est "machine virtuelle".

Meya HAROUNE 3
6 6
Common Language specification (CLS)

 La CLS est une normalisation qui doit être respecté et implémenté par tout langage de

programmation qui support la technologie .NET.

 La CLS a pour objectif de garantir l'interopérabilité entre les langages .NET. Il est

possible par exemple de créer une classe dans un langage conforme à la CLS qui hérite

d'une autre classe définie dans un autre langage conforme à la CLS.

Meya HAROUNE 7 3
7
 La bibliothèque .NET
La bibliothèque .NET est constituée de trois couches:
• La Base classes Library (BCL): rassemble des classes permettant d'effectuer les
opérations de base telles que la manipulation de chaînes de texte, la gestion des
entrées/sorties, des communications réseaux, des threads, etc.
• Les classes de données et XML est composée de deux bibliothèques de classes
d'accès aux données :
- La bibliothèque ADO.NET, permettant l'accès sous format XML aux interfaces de
bases de données SQL Server ODBC, OLEDB, ORACLE, et aux fichiers XML.
- Une bibliothèque de classes permettant de manipuler les données XML.
• Les services Web, les applications Web et les applications Windows

Meya HAROUNE 3
8 8
Common Language Runtime (CLR)
La CLR est la machine virtuelle qui assure l'exécution des programmes .NET. Elle assure :

 Interprétation des fichiers exécutables compilés en CIL,

 Allocation de mémoire et la ramasse miette,

 La gestion des exceptions et des threads,

 Sécurité de l'exécution des programmes.

 Supporte plus de 36 langages de programmation:

• C#.NET, VB.NET, C++.NET, J#.NET, JSCRIPT.NET, etc.

• Python, Cobol,Perl, CAML,Pascal, APL, CAML, Scheme, etc.

Meya HAROUNE 3
9 9
Exécution en CLR
Source VB C# C++
code
Compiler Compiler Compiler

Managed Assembly Assembly Assembly

code IL Code IL Code IL Code

Common Language Runtime

JIT Compiler

Native Code

Operating System Services

Meya HAROUNE 3
1010
L'assemblage
 Le CLR transforme le code CIL en assemblage (fichier exe ou dll)

 Toutes les classes d'une application sont compilées dans un même assemblage (assembly).

 Au moins un de ces assemblages doit contenir un point d'entrée pour démarrer l'application

(fonction principale)

 Un assemblage contient:

 la liste de l'ensemble des fichiers (exe, dll, données, images, ressources)

 les méta données (informations descriptives)

 L'énumération des autres assemblages dont l'application dépend et leurs dépendances.

 L'ensemble des autorisations requises pour que l'assemblage fonctionne correctement.

Meya HAROUNE 3
11 11
EDI pour .Net

L’environnement de développement intégré (EDI) de Microsoft est Visual Studio, est

un outil permettant de développer des applications .NET à l'aide de langages de

programmation tels que VB, C#, C++ .Net, J# .Net, etc. Il est disponible dans plusieurs

éditions.

Meya HAROUNE 3
12 12
C# (C Sharp)

 C# est simple et complètement orienté objet → pas de possibilité d’écrire des fonctions

en dehors des classes, pas de variables globales.

 Permet l’écriture des programmes plus surs et plus stables grâce à la gestion automatique

de la mémoire à l’aide du ramasse miette et à la gestion des exceptions.

 Un programme C # est compilé en tant que code managé (managed code).

 Combine les meilleures fonctionnalités de Visual Basic, C ++ et Java.

 La bibliothèque est fortement structurée – utilisation d'espaces de nommages, – accès via

la directive « using ».

Meya HAROUNE 3
13 13
Les bases de C#

Meya HAROUNE 3
14 14
 Bonjour tout le monde

• Un programme C# comporte obligatoirement une

using System ;
fonction Main (M majuscule).
// Classe de l'application
class Prog
• Main doit être obligatoirement membre d’une {
// Fonction principale
classe. static void Main()
{
• Le point virgule à la fin de la définition d’une classe // Équivalent de
System.Console.WriteLine
est optionnel. Console.WriteLine(“Bonjour”);
}
}
• Les entrées/sorties de base sont accessibles via

l'objet Console (espace de nommage System).

Meya HAROUNE 3
15 15
 Les commentaires
/*

using System ;
class Prog
{
static void Main()
{
// commentaire sur une seule ligne
/* Je suis un commentaire sur
plusieurs lignes. */

Console.WriteLine(“Bonjour”); /// Le reste de la ligne

est considéré comme commentaire

}}

Meya HAROUNE 3
16 16
Les variables

Il existe deux genres de types en C# :

 les types valeur: contiennent directement leurs données, les types de valeur de
C# sont divisés entre types simples, types enum, types struct et types valeur
nullable.

 Les types référence : contiennent des références à leurs données, connues sous
le nom d’objets, les types de référence de C# sont encore divisés en types de
classes, types d’interfaces, types de tableaux et types délégués

Déclaration:
Type NomVariable (ex int age);
Déclaration et affectation:
Int age = 30;

Meya HAROUNE 3
17 17
Types de données
Les types fournit par C# :
• bool (booléens),
• char (caractère Unicode 16 bits),
• string (chaîne de caractères Unicode),
• types intégraux non signés (byte, ushort, uint, ulong),
• types intégraux signés (sbyte, short, int, long),
• types flottants (float, double),
• Decimal (decimal : 128 bits)
• object (type de base de tous les objets),
• void (type vide, pour les procédures).

Meya HAROUNE 3
1818
 Conversion/Transtypage
Conversions implicites: peut être effectuée quand la valeur à stocker peut tenir dans la
variable sans être tronquée ni arrondie
Decimal nombreDecimal = 1234.12m; double nombreDouble = 14.12;
int nombreEntier = 1234; char caractere = 'A';
nombreDecimal = nombreEntier; // un int vers un decimal
nombreDecimal = 25; // un int vers un decimal
nombreEntier = caractere; // un char vers un int

Conversions explicites: Lorsque qu'une conversion implicite est impossible, il faut

transtyper (caster). Il peut y avoir une perte de précision

nombreDecimal = (decimal) nombreDouble; // nombreDecimal =

//nombreDouble est impossible

pour transformer une chaîne en nombre ou un nombre en chaîne. Il faut utiliser les
méthodes Parse() et ToString().
Meya HAROUNE 3
19 19
 Les instructions conditionnelles (if)
L’instruction if (si en français) permet d’exécuter du code si une condition est vérifiée.

static void Main(string[] args)

{
if (args.Length == 0)
{
Console.WriteLine("No arguments");
}
else
{
Console.WriteLine("One or more arguments");
}
}

Meya HAROUNE 3
2020
 Les instructions conditionnelles
Les opérateurs de comparaison

Opérateur Description
== Egalité
!= Différence
> Supérieur à
< Inférieur à
>= Supérieur ou égal
<= Inférieur ou égal
&& ET logique
|| OU logique
! Négation

Meya HAROUNE 3
21 21
Les instructions conditionnelles (Switch)
L’instruction switch peut être utilisée lorsqu’une variable peut prendre beaucoup de valeurs

switch (i)
{
case 1:
case 2:
// Traitement si i vaut 1 ou 2. break;
// Obligatoire.
case 5:
// Traitement si i vaut 5.
default:
// Traitement pour les autres cas.
break;
}
// Contrairement au C, switch fonctionne aussi avec
//les chaînes.

Meya HAROUNE 3
2222
Les boucles conditionnelles
permettent de répéter des actions tant que certaines conditions sont satisfaites

while" veut dire « tant que » :

while (i < 10)

{
// Traitement effectué tant que i
//est inférieur à 10.
//En cas de besoin de sortir prématurément
d'un boucle, utilisez break.
}

Meya HAROUNE 3
2323
Les boucles conditionnelles
permettent de répéter des actions tant que certaines conditions sont satisfaites.

do ... While:

do
{
// Permet d’exécuter le code une 1ère fois
//obligatoirement et ensuite en boucle tant
//que lacondition est satisfaite.
}
while (condition);

Meya HAROUNE 3
2424
Les boucles conditionnelles
permettent de répéter des actions tant que certaines conditions sont satisfaites.

for:

// test de condition de boucle, opération d'incrémentation.

// La condition est évaluée en premier :

for (int i = 0; i < 10; ++i)

{
// Code exécuté tant que i < 10, en partant de i = 0
// avec incrémentation de i à chaque itération.
}
// La variable muette i n'est plus définie après la
//boucle.

Meya HAROUNE 3
2525
Les boucles conditionnelles
permettent de répéter des actions tant que certaines conditions sont satisfaites.

foreach:

foreach (int nom_de_variable in nom_de_l'ensemble)

{
// Code exécuté pour chaque valeur contenue dans
//nom_de_l'ensemble
}

Meya HAROUNE 3
2626
Les tableaux

 Un tableau permet de stocker un ensemble d’éléments de même nature.

 leur taille est fixée au moment de l’allocation mémoire.

 Le dépassement de capacité d’un tableau est une erreur de programmation

classique (IndexOutOfRangeException).

 Déclaration d’un tableau :

typeElement[] nomTableau;

 Allocation mémoire:

nomTableau = new int[5];

Meya HAROUNE 3
2727
Les tableaux

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi",

"Jeudi", "Vendredi", "Samedi", "Dimanche" };
Array.Sort(jours); // fait un tri sur les éléments du tableau
for (int i = 0; i < jours.Length; i++)
{
Console.WriteLine(jours[i]);
}
jours[0] = "Lundi";

Meya HAROUNE 3
2828
Les listes

 Une liste offre plus de fonctionnalités qu’un tableau

 Une liste se redimensionne automatiquement lors de l’ajout d’un nouvel élément

 Déclaration:

List<typeelements> nomdelaliste;

 Instanciation :

nomdelaliste = new List<typeelements>();

Meya HAROUNE 3
2929
Les listes

List<double> valeurs = new List<double>();

double total = 0;
for (int i = 0; i < valeurs.Count; i++)
{
total = total + valeurs[i];
}
Console.WriteLine(total);

Meya HAROUNE 3
3030
Les classes
 Une classe est une structure de données qui combine l’état (champs) et les actions
(méthodes et autres fonctions membres).
 Les classes sont déclarées avec le mot clé « class »
 Les données membres se déclarent comme des variables, appelées objets ou
instances
 Les instances de classes sont créées à l’aide de l’opérateur new
 Plusieurs types de mode d'accès possibles:
– private (accessibles dans la classe),
– public (accessibles de tout le monde),
– protected (accessibles par les instances des classes dérivées),
– internal ( accessibles uniquement dans les fichiers d’un même assembly).

Meya HAROUNE 3
31 31
Exemple de classe

class Point
{
public int x, y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
}
//Création d’objets :instanciation de
//classe

Point p1 = new Point(0, 0);

Point p2 = new Point(10, 20);

Meya HAROUNE 3
3232
Exemple de classe

class Point
{
public int x, y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
}
//Création d’objets :instanciation de
//classe

Point p1 = new Point(0, 0);

Point p2 = new Point(10, 20);

Meya HAROUNE 3
3333
Méthodes et paramètres
• Une méthode est un bloc de code qui contient une série d'instructions.
• En C# les méthodes sont déclarées dans une classe ou un struct.
• Déclaration d’une méthode :
public static void nomdelamethode(int nomDu1erParae, string
nomDu2ePara){
// Code à exécuter quand la méthode est appelée.}

• Les méthodes peuvent être surchargées.

• Les paramètres d’une méthodes peuvent être passés par valeur ou par références.
Par défaut, sont toujours passés par valeur.
• pour un passage par référence, utiliser « ref » ou « out », out impose à la méthode
d'assigner une valeur au paramètre avant de se terminer.
• Le mode de passage des paramètres doit être fourni à l'appel explicitement

Meya HAROUNE 3
3434
 Passages de paramètres(par valeur)
void Changeparametres(int monparametre)
{
Console.WriteLine("Le paramètre formel monparametre : " + monparametre);
monparametre = 5;
Console.WriteLine("Le paramètre formel monparametre : " + monparametre);
}

L’utilisation:
int monnvparametre = 10;
Console.WriteLine("Le paramètre effectif monnvparametre : " + monnvparametre );
Changeparametres(monnvparametre);
Console.WriteLine("Le paramètre effectif monnvparametre : " + monnvparametre);

Résultat d’éxécution:

Le paramètre effectif monnvparametre : 10

Le paramètre formel monparametre : 10
Le paramètre formel monparametre : 5
Le paramètre effectif monnvparametre : 10

Meya HAROUNE 3
3535
 Passages de paramètres (par ref)
void Changeparametres(ref int monparametre)
{
Console.WriteLine("Le paramètre formel monparametre : " + monparametre);
monparametre = 5;
Console.WriteLine("Le paramètre formel monparametre : " + monparametre);
}

L’utilisation:
int monnvparametre = 10;
Console.WriteLine("Le paramètre effectif monnvparametre : " + monnvparametre );
Changeparametres(ref monnvparametre);
Console.WriteLine("Le paramètre effectif monnvparametre : " + monnvparametre);

Résultat d’éxécution:

Le paramètre effectif monnvparametre : 10

Le paramètre formel monparametre : 10
Le paramètre formel monparametre : 5
Le paramètre effectif monnvparametre : 5

Meya HAROUNE 3
3636
 Les constructeurs et Les destructeurs
 Le constructeur est une méthode appelée lors de la création d’un objet à partir
d’une classe.

 Le constructeur porte le nom de la classe, et ne retourne rien.

 Pour chaque classe il peut y avoir:

 Aucun constructeur : dans ce cas le compilateur fournit automatiquement un
constructeur par défaut, qui n’accepte aucun argument.
 Un seul constructeur : dans ce cas, ce sera toujours lui qui sera appelé. Le
compilateur ne fournit pas de constructeur par défaut.
 Plusieurs constructeurs : dans ce cas ils diffèrent selon leurs signatures.

 Le destructeur est une méthode appelée lors de la destruction d'un objet d’une
classe.

 Son nom est celui de la classe, précédé d'un tilde '~'.

Meya HAROUNE 3
3737
Les constructeurs et Les destructeurs
public class Livre
{
private string Auteur;
private int Prix;
// Constructeur 1
public Livre() { Auteur = ‘Sidi’;
Prix= 500; }
// Constructeur 2
public Livre(string Auteur) { this.Auteur =Auteur; }
// Constructeur 3
public Livre(string Auteur, int Prix){
this.Prix = Prix;
this.Auteur = Auteur;}
~Livre(){ /* rien à désallouer!*/ } // destructeur 1
}
class Prog
{
static void Main(string[] args)
{
Livre A = new Livre(); // Appelle le Constructeur 1.
Livre B = new Livre(‘Ali’); // Appelle le Constructeur 2.
Livre C = new Livre(‘Ali’,‘400’); // Appelle le Constructeur 3.
}
// le ramasse miettes appelle le destructeur sur les objets A B et C
// avant la terminaison du programme
}
Meya HAROUNE 3
3838
 Les accesseurs
 Permet de définir des fonctions d'écriture et de lecture de la valeur d'un champ privé en utilisant une
propriété,

 L’accesseur get doit retourner une valeur du type de la propriété,

 L’accesseur set son type de retour est vide, et utilise un paramètre implicite nommé value son type est
celui de la propriété.

class Person {
private string name; // le champs nom
string Name // the Name property
{
get { return name; }
set { name = value; }
} }
L’utilisation:
Person P = new Person();
ushort personName = P.Name;
P.Name = ‘Fatma’;

Meya HAROUNE 3
3939
Les exceptions
 Une exception est créée et lancée quand une erreur survient.

 Les Exceptions disponibles dans C# sont généralement dérivées de SystemException.

 Elles contiennent les informations sur l'erreur et son contexte.

 il est possible de lancer une exception en utilisant le mot clé throw.

 Le bloc try peut être suivi ou non d'un nombre quelconque de bloc catch attrapant
différents types d'exception.

 Le bloc finally (optionnel) sera toujours exécuté. utilisé généralement pour la

libération des ressources.

Meya HAROUNE 3
4040
Les exceptions
try
{
Console.Write("Entrez un nombre : ");
int n = int.Parse(Console.ReadLine());
Console.WriteLine("120/nombre = {0}",
120/n);
}
catch (DivideByZeroException dbzEx)
{
Console.WriteLine("Erreur : division par zéro.");
}
catch (Exception ex)
{
Console.WriteLine(
"Une autre exception a eu lieu : {0}.",
ex.Message);
}
finally
{
Console.WriteLine("Quel que soit le résultat, ceci est affiché.");
}

Meya HAROUNE 3
41 41
 Exceptions courantes
Type d'exception Description Exemple
Exception Classe de base pour toutes les Aucun (utilisez une classe dérivée de
exceptions. cette exception).
IndexOutOfRangeException Levée par le runtime uniquement Indexation d’un tableau en dehors de
en cas d’indexation incorrecte du sa plage valide :
tableau. arr[arr.Length+1]
NullReferenceException Levée par le runtime uniquement object o = null;
si un objet Null est référencé. o.ToString();
InvalidOperationException Levée par les méthodes en cas Appel de Enumerator.MoveNext()
d’état non valide. après la suppression d’un élément de
la collection sous-jacente.
ArgumentException Classe de base pour toutes les Aucun (utilisez une classe dérivée de
exceptions d’argument. cette exception).
ArgumentNullException Levée par les méthodes qui String s = null;
n’acceptent pas la valeur Null pour "Calculate".IndexOf(s);
un argument.

Meya HAROUNE 3
4242
 L’héritage (1/2)
 Il permet de créer de nouvelles classes qui réutilisent et modifient le comportement défini dans les
autres classes.

 La classe dont les membres sont hérités sont appelées classe de base et la classe qui hérite de ces
membres sont des classe dérivée.

 En .NET une classe dérivée ne peut avoir qu'une seule classe de base directe (pas d’héritage multiple).

 L’héritage est transitif ( i.e. si la classe C est dérivée de la classe B et la classe B est dérivée de la classe A,
la classe C hérite des membres déclarés dans la classe B et la classe A).

 L'accès à la classe de base se fait via le mot-clef « base ».

Meya HAROUNE 3
4343
L’héritage (2/3)
Véhicule
#marque: Chaine
#modèle: Chaine
#année: Entier
#VitesseMax: Entier
#distanceParcourue: Entier
#durée: Entier

Voiture Vélo
puissanceFiscale: Entier Occupation: Entier

Propriétés communes protégées regroupées dans Véhicule Pour être accessibles par les sous-
classes, leur modificateur d’accès est protected.

Meya HAROUNE 3
4444
L ’héritage (3/3)
using System;
class Employé {
protected string nom;
public Employé(string nom)
{this.nom = nom;}}

class Ingénieur: Employé{

private double Salaire;
public Ingénieur(string nom, double Salaire):
base(nom){this.Salaire = Salaire;}
}
class Prog
{
public static void Main(){
Employé E = new Ingénieur("Ahmed Sidi", "2500");}
}

Meya HAROUNE 3
4545
Polymorphisme (1/3)
 Le polymorphisme un mot grec qui signifie avoir plusieurs formes .

 Les membres virtuels et abstraits sont la base du polymorphisme.

 Lorsqu’une classe de base déclare une méthode comme étant virtuelle (virtual), une
classe dérivée peut substituer la méthode avec sa propre implémentation.

 Si une classe de base déclare un membre comme étant abstraite (abstract), la méthode
doit être substituée dans toutes les classes non abstraites qui héritent directement de cette
classe.

 Le membre dérivé doit utiliser le mot clé override pour indiquer explicitement que la
méthode est conçue pour participer à l’appel virtuel.

Meya HAROUNE 3
4646
Polymorphisme (2/3)
public class Employé {
protected string nom;
public Employé(string nom) {nom = nom;}
public virtual void GetDescription()
{ Console.Write("Nom: {0}",nom);} }

class Ingénieur : Employé{

public Ingénieur(string nom):base(nom) {}
public override void GetDescription(){
// Appel de la méthode GetDescription() de Employé.
base.GetDescription();
Console.Write(", Fonction: Ingénieur\n");}}
class Secrétaire : Employé{ // Secrétaire hérite de Employé.
public Secrétaire(string Nom):base(Nom) {}
public override void GetDescription(){
// Appel de la méthode GetDescription() de Employé.
base.GetDescription();
Console.Write(", Fonction: Secrétaire\n");}
}
Meya HAROUNE 3
4747
Polymorphisme (2/3)
class Prog
{
static void Main(string[] args)
{
Employé [] Tab = new Employé[3];
Tab[0] = new Ingénieur("Mina");
Tab[1] = new Secrétaire("Mouhamed");
Tab[2] = new Ingénieur("Aya");
foreach( Employé employe in Tab )
e.GetDescription();
}}

Résultat d’exécution :

Nom: Mina, Fonction: Ingénieur

Nom: Mouhamed, Fonction: Secrétaire
Nom: Aya, Fonction: Ingénieur

Meya HAROUNE 3
4848