Cours DotNet C# Part1

Plateforme Microsoft .
NET
et
Langage C#
Pr. Abderrahim BENABBOU
abderrahim.benabbou@gmail.com
Partie I
La plateforme Microsoft .NET
2
© A. Benabbou
Présentation
 Le .NET est une plateforme de développement de logiciels, créée par

MicroSoft en 2001 sous le nom .Net Framework.
 La version stable de .Net Framework 1.0 a été publiée en 2002.
 Le .Net Framework était principalement dédiée au développement de logiciels
sous Windows.
 La dernière version du .Net Framework est .Net Framework 4.8
 En 2014, Microsoft a commencé à écrire un successeur multiplateforme et
open source pour .NET Framework.
 Cette nouvelle implémentation de .NET était nommée .NET Core.
 A partir de la version .NET Core 3.1, la nomination a été simplifiée en .NET 5
pour marquer que .Net Core est devenue la principale implémentation de .Net
 La version actuelle est .Net 7
3
© A. Benabbou
Présentation
 Le .NET offre un Kit de développement logiciel (SDK) comprenant un

ensemble de bibliothèques et d’outils (APIs) permettant de développer et
d’exécuter des applications .Net.
 NuGet est un gestionnaire de packages spécialement conçu pour .NET qui
contient plus de 90 000 packages permettant d’étendre les APIs de .Net.
 Le .NET prend totalement en charge les technologies Internet indépendantes
des plates formes tels que HTTP, XML, Json, SOAP, WSDL, etc.
 Le .NET est multi langages, mais C# est le langage le plus utilisé dans la
plateforme
4
© A. Benabbou
Présentation
 Le .NET est aujourd’hui une plate-forme de développement open source, libre

et multiplateforme
 La plateforme .NET fournit l’ensemble des technologies et APIs nécessaires à
la création de différents types d’applications et pour différentes plateformes :
Windows, Linux, MacOS, Android, iOS, tvOS et watchOS.
 Il existe trois implémentations différentes de .Net:
– .Net Core
– .Net MAUI (Multi-platform App UI)
– .Net Framework
5
© A. Benabbou
.NET Core
.NET Core est une implémentation .NET multiplateforme pour les

applications bureaux, Web, Web distribuées, mobiles, applications dans le
cloud, l’IA, des jeux et des IoT.
– sites Web, les serveurs et les applications console sous Windows, Linux et macOS.
6
© A. Benabbou
.NET MAUI
MAUI est une API qui permet de créer une application multi
plateformes avec un seul projet sous visual studio : le code métier et
le design de l’IU est partagé par toutes les plateformes
7
© A. Benabbou
.NET Framework
 Le .Net Framework permet de développer les applications consoles,

desktop, Web, ou les services pour toutes les versions de Windows.
 La version basique de .NET Framework possède une architecture structurée
en plusieurs couches :
VB.NET VC++ C# JScript Perl …
Common Language Specification
ASP.NET: Web Forms Windows Forms

& Web Services & Windows Services
ADO.NET: Data and XML
.NET Framework Base Classes
Common Language Runtime

8
© A. Benabbou
.NET Framework
 Le .NET Framework facilite la création des services web
 Le .NET Framework supporte le Remoting
 Le .NET Framework intègre largement le standard XML
 Utilisation des assemblages (assembly) qui remplacent les DLLs
• Facilité d’installation et de désinstallation des assemblages (simple copie), une DLL
classique nécessite une entrée dans la base des registres et une copie dans le système
• Les assemblages acceptent la gestion des versions
• Possibilité de partager du code entre plusieurs assemblages
 Interopérabilité des langages
– Les programmes développés en des langages différents (VB.Net, VC++.Net, VC#, etc.)
ont le même code IL
– un programme écrit en un langage peut faire appel à une méthode écrite en un autre
langage
– Une classe écrite dans un langage peut hériter d'une autre classe d'un autre langage
– Une classe peut contenir une instance d'une autre classe peu importe le langage employé
– Un objet peut appeler une méthode d'un autre objet peu importe le langage
9
© A. Benabbou
Architecture de .NET Framework
Evolution .NET Framework:
10
© A. Benabbou
Common Language Runtime (CLR)
 Le CLR est l'environnement d'exécution du .NET Framework
 Le CLR est la machine virtuelle de Microsoft
 Le CLR est indépendant de l'architecture physique de la machine
 Le CLR exécute un bytecode écrit dans un langage intermédiaire
nommé MSIL (Microsoft Intermediate Language ) ou simplement
IL
 Les tâches essentielles de CLR sont :
• le chargement des classes,
• la vérification de types,
• la gestion de la mémoire (Garbage Collector), des exceptions et
de la sécurité,
• l’exécution du code IL
12
© A. Benabbou
 L’exécution par le CLR se traduit par une compilation JIT (Just-
In-Time) : traduction à la volée du code IL appelé aussi code
managé, en code natif
Compilateur CLR
Assembly
Code Source Code natif
Code IL
.DLL ou .EXE
C#, C++ managé, VB.NET
ou un autre langage
 Bien que se terminant par l’extension .exe, un programme issu

d'une compilation sous .NET n'est pas un exécutable en code natif,
mais un bytecode en IL
 Le CLR peut aussi être hébergé par des composants non managés
qui peuvent le charger dans leurs processus et lancer l'exécution
d’un code managé (exemple l’Internet Explorateur)
13
© A. Benabbou
 Assembly
C’est une unité logique de déploiement (un archive) auto descriptive
qui contient :
– Le Manifest : un fichier de description de l’assemblage qui
contient des Metadata décrivant les composants présents dans
un assembly (version, types, dépendances, etc.)
– Les Metadata Types : Définition complète de tous les types
présent dans l’assembly : attributs, méthodes, paramètres,
ressources, etc.
– Le Code IL : le code managé
– Les Ressources : fichiers xml, bmp, jpg, etc. utilisés par
l’assembly
14
© A. Benabbou
C’est un ensemble complet de classes permettant de développer :
 des applications de bureau
-Applications consoles
-Applications à interface graphique utilisateur (GUI, Graphical User Interface) : les
Windows Foms
 des applications web qui utilisent l’ASP.NET et exploitent les services
Web XML et les Web Forms
 des applications hébergées ou à base de scripts
Ces classes sont accessibles par tous les langages de la plate forme .NET et de
tout langage conforme à la norme CLS (Common Language Specification)
Les classes les plus couramment utilisées sont regroupées dans l’espace de noms
nommé : System
15
© A. Benabbou
System
Collections IO Security Runtime
Configuration Net ServiceProcess InteropServices
Diagnostics Reflection Text Remoting
Globalization Resources Threading Serialization
System.Web System.Windows.Forms
Services UI Form Button
Description HtmlControls MessageBox ListControl
Discovery WebControls
Protocols System.Drawing
Caching Security Drawing2D Printing
Configuration SessionState Imaging Text
System.Data System.Xml
OLEDB SQL XSLT Serialization
Design SQLTypes XPath
16
© A. Benabbou
Exemples de classes
– System : types de base (Object, Byte, Char, etc.) et la la
classe Console
– System.Collections : Collections d'objets (ArrayList,
Dictionary, SortedList, Stack, etc.)
– System.Data : Interaction avec les bases de données
(DataRow, DataSet, DataTable, DataSource, etc.)
– System.IO : Accès aux fichiers (File, FileStream,
StreamReader, StreamWriter, etc.)
17
© A. Benabbou
– System.Net : Accès au réseau (WebRequest, WebResponse,

TcpClient, TcpListener, UdpClient, Sockets, etc.)
– System.Security : Gestion de la sécurité (Permissions,
Cryptography, etc.)
– System.Web.UI.WebControls : Composants Web
(BorderStyle, DataGrid, HyperLink, ListBox, Panel,
RadioButton, Table, etc.)
– System.Windows.Forms : Composants graphiques classiques
(Button, RichEdit, CheckBox, Form, ListBox, MainMenu,
MonthCalendar, ToolBarTreeView, FileDialog, etc.)
18
© A. Benabbou
Common language Specification
Le CLS est composé de spécifications communes à tous les langages
qui veulent produire ou coopérer à travers des applications .NET
Le CLS exclut les langages procéduraux, l’héritage multiple et le
typage automatique
L’interopérabilité entre les langages respectant le CLS sera assuré par
un mapping des types utilisés par ces langages vers des types
communs offerts par le .NET Framework : CTS (Common Type System)
Le CLS est complètement respecté par le nouveau langage C#, ainsi
que par les langages améliorés VC++.NET, VB.NET
Avec VC++.NET, on peut créer à la fois des applications
« managées » compilées en IL et des applications « non managées »
compilées en code natif
19
© A. Benabbou
ASP.NET : Web Forms & Web Services
ASP (Active Server Pages) est une technologie de MicroSoft
permettant de créer des pages Web dynamiques
Une page ASP contient du HTML, du code VBScript à exécuter
par le serveur et du code JavaScript à exécuter par les clients
ASP.NET est la nouvelle génération de ASP
ASP.NET offre deux fonctionnalités principales :
• Les Web Forms (System.Web.Services) : permettent de construire des
pages Web efficaces basées sur les formulaires et intégrant des contrôles
ASP.NET
• Les Web Services (System.Web.UI) : sont le mécanisme par lequel les
applications communiquent et échangent des services, des traitements et
des données (les données sont véhiculées en XML) sur le Web
« Un service Web est un composant Web programmable et partageable
par des applications sur le réseau Internet ou Intranet »
20
© A. Benabbou
Window Forms & Windows Services
Windows Forms sont un ensemble de classes
(System.Windows.Forms et System.Drawing) extensible
permettant de développer des applications Windows élaborées
Windows Forms peut aussi faire office d'interface utilisateur locale
dans une application distribuée multicouches
Les services Windows sont conçus pour s’exécuter comme tâche
en arrière plan
Ces services peuvent être lancés automatiquement lors du
démarrage de l'ordinateur, suspendus puis redémarrés et ne
possèdent pas généralement d'interface utilisateur
Les services Windows permettent de créer des applications à
période d'activité longue s'exécutant dans leurs propres sessions
Windows
21
© A. Benabbou
ADO.NET : Data & XML
ADO.NET (ActiveX Data Objects) est un ensemble de classes
(System.Data et System.Xml) permettant l'accès à des données
relationnelles, à des données XML et à des données d'application
ADO.NET propose un ensemble de composants pour la création
d'applications distribuées avec partage de données
Le composant principal d’ADO.NET est le DataSet, un modèle
XML déconnecté des données
Un objet DataSet effectue des requêtes sur la base et traduit les
résultats en XML
22
© A. Benabbou
ADO.NET : Data & XML
23
© A. Benabbou
Partie II
Le langage C#
24
© A. Benabbou
Introduction
C# est un langage à objets récent disponible officiellement depuis février 2002
Evolution:
– C# 1.0 : très proche de Java, mais reste syntaxiquement semblable au
langages C et C++
– C# 2.0 : apporte la notion des classes génériques, des classes partielles, des
méthodes anonymes, etc.
– C# 3.0 : intègre Linq, l’inférence des types locaux, les types anonymes, les
initialiseurs d’objets, etc.
– C# 4.0 : apporte les fonctionnalités de la programmation dynamique et de
la coévolution des langages
– …
– C# 11: la dernière version (bientôt la version 12)
25
© A. Benabbou
Introduction
C# est une amélioration de C++ et ressemble à Java en divers points

C# fonctionne uniquement sur la plateforme .NET
C# ne contient pas ses propres bibliothèques de classes, il utilise les
classes du .NET Framework
Le compilateur csc.exe de C# peut générer divers formats de sortie:
 Un module : csc /target:module prog.cs  prog.netmodule
 Une DLL : csc /target:library prog.cs  prog.dll
 Un exécutable console : csc /target:exe prog.cs  prog.exe
 Un exécutable Windows : csc /target:winexe prog.cs  prog.exe
26
© A. Benabbou
Caractéristiques
Syntaxe proche de C/C++ et de Java
La classe contient sa définition et son implémentation, dans un
même fichier d’extension «.cs»
Utilisation des espaces de noms pour le groupement de plusieurs classes
Tout est classe même les types de base int , float, etc.
Toutes les classes héritent de la classe racine object
(System.Object)
Seul l’opérateur d’accès aux membres . est utilisé
Le compilateur C# peut générer un fichier de documentation XML à
partir de commentaires spéciaux inclus dans le programme
Généralisation de la gestion des exceptions
L’héritage est simple mais une classe peut implémenter plusieurs
interfaces
Support natif des threads
27
© A. Benabbou
Structure générale d’une application C#
Une application C# est composé d’une ou plusieurs classes

Ces classes peuvent être réparties sur un ou plusieurs fichiers sources
d’extension .cs
Une seule parmi ces classes doit contenir la méthode principale Main
Cette classe n’a pas forcément le même nom que le fichier source
On peut mettre les classes dans un ou plusieurs espaces de noms
Un espace de noms peut s’étaler sur un ou plusieurs fichiers sources
On peut référencer d’autres espaces de noms en utilisant using
Les using doivent précéder toutes les classes du fichier ou de
l’espace de noms
28
© A. Benabbou
Syntaxe
//espaces de noms utilisés
using espace1;
using espace2.espace3;
using espace4;
//Déclaration d’un espace de noms
namespace NomEspace{
class Class1{
...
}
...
class ClassPrincipale{
...
static void Main(String[] args){
...
}
}
}
29
© A. Benabbou
La méthode Main représente l’entrée à l’exécution de l’application

•doit être qualifiée static
•peut retourner int ou void
•peut avoir ou non des arguments
Les identificateurs en C# acceptent les lettres accentuées et les
caractères ‘$’ , ‘_’ et ‘µ’
En général, les espaces de noms, les classes et les méthodes
commencent par une majuscule (C# respecte la casse)
using permet l'utilisation non qualifiée des classes qui appartiennent
à l'espace de noms (mais pas les classes des espaces de noms internes)
30
© A. Benabbou
Exemple : prog.cs
//espaces de noms utilisés
using System; //contient la classe Console
//Déclaration d’un espace de noms
namespace MonEspace{
class Test{
public static void Main(String[] args){

Console.WriteLine("Bonjour.");
}
}
}
Compilation sur la ligne de commande: csc prog.cs

Résultat : prog.exe
31
© A. Benabbou
Les commentaires
Les mêmes qu’en C++
Nouveau commentaire :
///ligne de texte
Ce type de commentaires contient des balises XML qui permettront de générer
un fichier de documentation XML lors de la compilation par l’option /doc
Exemple :
// prog.cs
using System;
///<remarks>
///description générale sur une classe</remarks>
public class Test {
/// <summary>
/// déscription d’un membre </summary>
…
Compilation : csc prog.cs /doc:document.xml
32
© A. Benabbou
Les E/S standards : classe System.Console
Méthodes d'écriture sur l'écran :
Write(expression); : affiche une expression de tout type qui
peut être converti en chaîne de caractères
Exemple : System.Console.Write(“ x= "+125);
ou : System.Console.Out.Write(" x= " +125);
WriteLine(expression); : affiche et revient à la ligne
Méthodes de lecture à partir du clavier :
Read( ); : Lit un caractère et renvoie son code
Exemple : int i = System.Console.Read( );
ou : int i = System.Console.In.Read( );
ReadLine( ); : Lit une chaîne de caractères jusqu’au retour à la ligne
Exemple : string s = System.Console.ReadLine( );
N.B: Pas de fonctions de lecture d’entiers ou réels: utilisation de Parse
33
© A. Benabbou
Opérateurs de C#
Les opérateurs sont pratiquement les mêmes qu’en C++

Les opérateurs logiques utilisent le type booléen (true ou false) au lieu
de int
Nouveaux Opérateurs :
exp is nomType : renvoie true si l’expression exp est de type nomType
exp as nomType : renvoie un objet représentant la conversion de

l’expression exp en nomType ou null en cas d’échec
typeof(exp) : renvoie un objet de la classe System.Type permettant de

décrire le type de l’expression exp
operandeG ?? operandeD : l’operateur de fusion null ?? retourne
l’opérande gauche si elle n’est pas nulle, sinon il retourne l’opérande droite
34
© A. Benabbou
Structures de contrôle
Les structures de contrôle if-else, switch, for, while et do-while sont les
mêmes qu’en C++
Les structures de contrôle utilisent le type bool (true ou false) au lieu de int
Switch accepte les types entiers, énumérés et aussi le type string
Nouvelle structure de contrôle foreach pour parcourir les tableaux et les
collections
foreach(type variable in collection){
instructions;
}
variable prendra successivement tous les objets de collection
•collection est une collection d'objets (exemple un tableau, une liste, etc.)
•type est le type des objets de la collection
Exemple :
string[] T =new string[] {"X","Y","Z"};
foreach (string ch in T){
Console.WriteLine(ch);
}
35
© A. Benabbou
La gestion des exceptions
 Traiter les erreurs exceptionnelles d’exécution telles que les saisies
incorrectes, base de données inaccessible, fichier introuvable, etc.
 La classe de base des exceptions est la classe System.Exception
try {
//génération de l'exception
}
catch (TypeException e1) {
//traiter l'exception e1
}
…
catch (TypeException ek) {
//traiter l'exception ek
}
finally{ //facultative
//code exécuté qu’il y a exception ou non
© A. Benabbou
} 36
Exemple : exceptions lors de la saisie de données incorrectes
try{
int a = int.Parse(Console.ReadLine());
int b = int.Parse(Console.ReadLine());
int c = a/b;
Console.WriteLine("resultat:" + c);
}
catch (OverflowException e){
Console.WriteLine("erreur de saisie:"+e.Message);
}
catch (DivideByZeroException e){
Console.WriteLine("erreur de division:"+e.Message);
}
finally{
Console.WriteLine(’’Fin du programme");
}
37
© A. Benabbou
Remarques
- On peut utiliser catch sans paramètres si on n’a pas besoin de connaître des
informations sur l’exception :
catch{
…
}
- On peut générer explicitement une exception à l’aide de l’instruction :
throw new TypeException("message");
- On peut relancer une exception après sa capture dans une clause catch à l’aide
de l’instruction
throw;
38
© A. Benabbou
Types en C#
Tous les types de C# héritent de la classe racine object

Il existe deux catégories de types en C#:
Type valeur : une variable de ce type est un objet destinée à contenir
directement une valeur et comprend :
 Les types de base : int , float, char, etc. Type obj;
 Les classes enum Obj=valeur;
 Les classes struct
Type référence : une variable de type référence est une sorte de pointeur
destiné à contenir la référence vers un objet (l’adresse) ou null, et comprend :
 Les tableaux
 Les chaînes de caractères (string) Type reference;
refrence=new Type();
 Les classes et les interfaces (class, interface)
 Les délégués (delegate)
39
© A. Benabbou
Types valeur de C#
Types de base de C#
Type Désignation (taille)

char caractère en Unicode '\uXXXX ' (16 bits )
int, uint entier signé, non signé (32 bits)
long, ulong entier signé, non signé (64 bits)
sbyte, byte entier signé, non signé (8 bits)
short, ushort entier signé, non signé (16 bits)
float réel simple précision (32 bits)
double réel double précision (64 bits)
decimal réel large précision (128 bits)
bool booléen (1 bit )
40
© A. Benabbou
Types valeur de C#
Boxing/Unboxing
Le Boxing/Unboxing représente un concept principal dans le
système des types valeur de C#
Il fournit un mécanisme de conversion automatique entre les types
valeur de C# et les classes références .NET
–Le Boxing est la conversion d’une expression de type valeur en un objet
d’une classe .NET
–La conversion inverse s'appelle Unboxing
Exemple : Le type int est l’équivalent de la classe System.Int32
int i=132; //ou Int32 o=132;
Object obj=i;//boxing
int j= (int)obj;//unboxing
Remarque : pour les conversions entre types de C# on peut utiliser
les méthodes statiques de la classe System.Convert
41
© A. Benabbou
Types valeur de C#
Classes équivalentes dans .NET
Type valeur de C# Classe équivalente dans .NET
byte System.Byte
sbyte System.SByte
char System.Char
short System.Int16
ushort System.UInt16
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
float System.Single
double System.Double
decimal System.Decimal
bool System.Boolean
42
© A. Benabbou
Types valeur de C#
Type enum
Un type enum (énumération) est un type valeur qui permet de
définir une classe (ensemble) de constantes
Ces constantes sont des valeurs entières à partir de 0
Un type enum est équivalent à la classe System.Enum
Déclaration : enum nomType {Nom1, Nom2, …}
Exemple :
enum Etat{Fermé, Ouvert}//Ferme0 et Ouvert1
Etat etat0 = Etat.Fermé;
int val= (int)etat0 ; //val  0
Console.WriteLine( "état="+etat0); // état=Fermé
Remarque : Il est possible d'attribuer des valeurs personnalisées à
une ou à plusieurs constantes de l'énumération , exemple :
enum Climat { froid=-10, chaud=37}
43
© A. Benabbou
Types valeur de C#
Type struct
Un type struct définit une classe dont les instances sont des objets et
non des références (l’opération new n’est pas nécessaire)
On ne peut pas hériter à partir d’une classe struct
Les classes des types de base dans .NET comme int (System.Int32)
char, etc. sont des définies comme struct
Déclaration
struct nomType {
// attributs
// méthodes et constructeurs
}
44
© A. Benabbou
Types valeur de C#
Type struct
Exemple :
struct personne{
public string nom;
public int age;
}
public class test {
public static void Main() {
personne p1;
p1.nom = "Ali";
p1.age = 10;
personne p2 = p1; //recopie du contenu
}
}
45
© A. Benabbou
Types référence de C#
La classe object
object est la classe de base de toutes les classes en C#

object est l’équivalent de la classe System.Object
Les méthodes de la classe object :
public object() //constructeur
public string ToString() //conversion vers chaîne
public bool Equals(object)//teste l’égalité
public System.Type GetType()//renvoie le type de
//l’objet
…
46
© A. Benabbou
Les tableaux
Les tableaux dérive de la classe abstraite System.Array
Un débordement du tableau génère une exception
IndexOutOfRangeException
Tableau unidimensionnel
Type[] Tab = new Type[dimension];
 Initialisation lors de la déclaration :
Type[] Tab = new Type[]{val0,val1,val2,…};
ou: Type[] Tab = {val0,val1,val2,…};
ou: Type[] Tab;
Tab = new Type[] {val0,val1,val2,…};
 La propriété Length contient le nombre d'éléments
int l = Tab.Length;
47
© A. Benabbou
Les tableaux
Tableau à plusieurs dimensions
Chaque ligne contient le même nombre de cases
Type[,,,…] Tab=new Type [dim1,dim2,dim3,…];
Exemple : Tableau à deux dimensions
int[,] T1= new int[7,5];//7 lignes et 5 colonnes
int[,] T2= new int[3,2] {{0,1},{3,4},{6,7}};
int[,] T3= new int[,] {{0,1},{3,4},{6,7}};
int[,] T4= {{0,1}, {3,4}, {6,7}};
int n=T1.Length; //n35=7*5:nombre total de cases
int i=T2[1,0]; // i3:2ème ligne et 1ère colonne
int L1= T3.GetLength(1); /*L12 : nombre de
colonnes de la 2ème ligne */
48
© A. Benabbou
Les tableaux
Tableau de tableaux ( tableau en escalier )
- Chaque ligne contient son propre nombre de cases
- On ne doit spécifier que la 1ère dimension
Type[][]…[] Tab=new Type[dim1][]…[];
Exemple : Tableau à deux dimensions
int[][] T1= new int[2][ ];
int[][] T2= {new int[]{2,3,4},
new int[]{5,6,7,8,9}};
T1[0]=new int[3];
T1[0][0]=15;
T1[1]=new int[5];
49
© A. Benabbou
Les tableaux
Copie de tableaux
 La méthode Clone : renvoie une référence sur un nouveau objet copie d’un tableau tab1
Type [] tab2 = (Type[]) tab1.Clone();
 La méthode statique Copy de Array : permet de copier du tableau tab1 vers tab2 un nombre
d’éléments nbelements
Array.Copy (tab1, tab2, nbElements);
Syntaxe complète: Array.Copy (tab1,indice1,tab2,indice2, nbElements);
 La méthode CopyTo : permet de copier dans un tableau tab2 tous les éléments d’un tableau tab1 en
les stockant à partir de l’indice i de tab2
tab1.CopyTo (tab2, i);
Tri de tableaux
La méthode statique Array.Sort(tab) trie un tableau tab dans l’ordre croissant par défaut
Inversion des éléments d’un tableau
La méthode statique Array.Reverse(tab) inverse l’ordre des éléments de tout le tableau tab
Redimensionnement d’un tableau
La méthode statique Array.Resize(ref tab, newDim) redimensionne le tableau tab avec la
nouvelle dimension newDim en préservant le contenu
50
© A. Benabbou
Les tableaux
Plage d’éléments d’un tableau
 On peut accéder à une plage d’éléments d’un tableau:
- Tout le tableau:
tab1=tab2[..];
- Une plage entre deux indices du tableau:
tab1=tab2[indice1..indice2]; (indice1<=plage<indice2)
- A partir d’un indice jusqu’à la fin du tableau:
tab1=tab2[indice1..]; (indice1<=plage<tab1.Length):
Position à partir de la fin d’un tableau
- Un élément à la position pos à partir de la fin du tableau:
element=tab2[^pos]; (pos>=1, le dernier élément est à la 1ère position à partir de la fin)
-Plage d’éléments entre deux positions par rapport à la fin du tableau:
tab1=tab2[^pos2..^pos1]; (pos1<plage<=pos2)
-Plage d’éléments à partir d’une position par rapport à la fin du tableau (pos>=1):
tab1=tab2[^pos..];
51
© A. Benabbou
Les chaînes de caractères
Le type string
- Le type string est l’équivalent de la classe System.String
- Une chaîne de type string ne peut pas être modifiée
 Déclaration
string chaine;
 Déclaration avec initialisation
string chaine = "message";
ou: string chaine = new string(…);//plusieurs
//surcharges
 Affectation par l'opérateur = :
string chaine;
chaine = "message";
 Test d’égalité (inégalité) des chaînes par l’opérateur == (et !=) :
if (chaine1 == chaine2) …
 Comparaison des chaînes par la fonction CompareTo :
if (chaine1.CompareTo(chaine2)<0) … 52
© A. Benabbou
 Longueur d'une chaîne par la propriété Length :

int l = chaine.Length;
 Accès à un caractère de la chaîne par l'opérateur [ ] :
La chaîne est vue comme un tableau de char
Exemple :
string ch = "abcdef";
char c = ch[4] ; //c  ’e’
ch[5] ='x' ; //erreur:écriture interdite!
 Concaténation de deux chaînes par l’opérateur + et +=:
string str1, str2, str3;
str3 = str1 + str2;
str3 += "Test"; 53
© A. Benabbou
 Insertion d’une chaîne :
string str1, str2, str3;
str2 = str1.Insert(pos, str3);
 Recherche de la position de la 1ère occurrence d’une sous chaîne :
int pos = chaine.IndexOf ( sousChaine );
 Conversion d’un nombre en chaîne :
""+nombre ou variable.ToString() ou variable.ToString("format")
 Conversion d’une chaîne en nombre :
Tous les types de base possèdent la méthode Parse
int i = int.Parse(chaine);
ou: i=Int32.Parse(chaine);
float x = float.Parse(chaine);
54
© A. Benabbou
 Interpolation de chaines
-Le symbole $ permet d’injecter des variables grâce aux symboles { } dans une
chaîne de caractères
Exemple:
string str1;
int v=5;
float x=3.1445;
str1=$" v a pour valeur {v} et l’arrondie de x est {x:N2}";
-Le symbole @ permet d’inhiber les caractères d’échappement (\) dans une chaîne
Exemple:
string str1= @" le path est c:\Windows\System32",
str2= @"Bonjour
tout le monde";
55
© A. Benabbou
La classe StringBuilder
– Appartient à l’espace de noms System.Text
– Représente une chaîne de caractères dynamique et modifiable
– Peut être convertie en chaîne string
– Quelques méthodes :
 StringBuilder(.) : Les constructeurs permettent de créer une chaîne vide ou initialisée avec
une autre chaîne ou avec une capacité donnée en paramètre
 Append(x) : Ajoute à la fin de la chaîne la représentation sous forme de chaîne d'un objet x en
paramètre
 Insert(pos,x) : Insère à la position pos dans la chaîne, la représentation sous forme de chaîne
de l'objet x spécifié
 Remove(pos,n) : Supprime de la chaîne n caractères à partir de la position pos
– Quelque propriétés :
 Capacity : obtient ou définit la taille maximale réservée pour la chaîne en mémoire
 Opérateur [i] : Obtient ou définit le caractère à la position i de la chaîne
 Length : Obtient ou définit la longueur de la chaîne
56
© A. Benabbou
Les classes
Une classe en C# est accessible par défaut partout dans l’assemblie où elle a été
définie, elle est implicitement déclarée internal class
Toutes les classes héritent automatiquement de la classe object
class NomClasse{
//attributs ou champs
…
//propriétés
…
//méthodes
…
}
L’instanciation de la classe permet de créer un objet en mémoire qui sera
référencé par une variable appelée référence (pointeur):
NomClasse ref; //ref est égale à null ici
ref = new NomClasse();
57
© A. Benabbou
Les classes
Les attributs ou champs
class NomClasse {
type1 nomAttribut1;
//attributs initialisés directement
type2 nomAttribut2=new type2(listValeurs);
//attributs constants  implicitement statiques
const type3 nomAttribut3 = new type3(listValeurs);
/*attributs en lecture seule
 peuvent être affectés une seule fois */
readonly type4 nomAttribut4=new type4(listValeurs);
readonly type5 nomAttribut5;
public NomClasse(…){ //constructeur
nomAttribut1 = new type1(listValeurs);
nomAttribut5 = new type5(listvaleurs);
...
}
58
© A. Benabbou
Les classes
Exemple
class Employe{
int matricule;
String nom;
int heureTravail;
String pays=˝Maroc˝;
const double taxeIGR = 17.00;
//erreur:
//readonly double salaire=calculSalaire(heuresTravail);
readonly double salaire;
public Employe(){
…
salaire= calculSalaire(heuresTravail);
}
…
}
59
© A. Benabbou
Les classes
Visibilité d’une classe
•Une classe C# est internal par défaut càd accessible dans tout le projet
(assembly) où elle a été définie
class NomClasse{…} équivaut à : internal class NomClasse{…}
•Une classe qualifiée public est accessible même à l’extérieur de son assembly
•Une classe interne est définie à l’intérieur d’une autre classe conteneur
o Elle est private par défaut donc inaccessible de l’extérieur de la classe conteneur
o On peut modifier ce type d’accès par :
public: classe visible à partir d’une autre assembly où la classe conteneur est
visible aussi
protected : classe visible uniquement pour les classes qui héritent de la classe
conteneur
internal : classe visible aussi dans tous les namespace de l’assembly où la classe
© A. Benabbou
conteneur est visible aussi 60
Les classes
Visibilité des membres de la classe
•Les membres de la classe sont private par défaut et donc accessibles
uniquement à l’intérieur de la classe
[private] type NomMembre;
•On peut utiliser les modificateurs d’accès suivants :
protected : les membres sont visibles pour les classes dérivées
de cette classe
internal : ils sont visibles pour toutes les classes inclues dans la
même assembly
public : ils sont visibles pour les classes d’une autre assembly où
la classe est visible
61
© A. Benabbou
Les classes
Les constructeurs
–Même syntaxe et sémantique qu’en C++ ( mais pas de constructeur de copie)
–Exécutés lors de l’instanciation de la classe :
NomClasse refobjet= new NomClasse(list_valeurs);
– Un constructeur peut appeler un autre constructeur de la même classe en utilisant
this :
NomClasse(list_parametres):this(list_valeurs){
…
}
Remarque:
Dans le code des fonctions le mot clé this peut être utilisé pour accéder aux
membres de la classe (surtout lorsque les paramètres des fonctions ont le même
nom que les attributs): this.nomMembre
62
© A. Benabbou
Les classes
Le destructeur
– Même syntaxe et sémantique qu’en C++
– Appelé automatiquement lorsque le Garbage Collector détruit une instance de la
classe
– Le destructeur appelle automatiquement les destructeurs de toutes les classes de
base de manière ascendante
class NomClasse {
~NomClasse(){
…
}
}
63
© A. Benabbou
Les classes
Les propriétés
- Une propriété permet de faciliter l’accès à des attributs privés de la classe
- Une propriété permet d’éviter l’utilisation fastidieuse de getters et setters
- Une propriété permet d’extraire ou de spécifier la valeur d'un attribut, elle encapsule
deux méthodes get et set (ou juste l’une des deux)
public type nomPropriete {
get{ ...
return nomAttribut;
}
set{ ...
nomAttribut = value;
}
}
value représente automatiquement la valeur qui sera affectée à l’attribut
Remarque : On doit utiliser évidemment un appel à une fonction qui réalise
l’affectation si le type de l’attribut ne supporte pas l’opérateur =
64
© A. Benabbou
Les classes
Exemple
class PersonneAdulte{
// attributs
private string nom;
private int age;
// propriétés
public string Nom{
get{ return nom; }
set{ nom = value; }
}
public int Age{
get{ return age; }
set{ if(value>=18) age=value;
else age = 18;}
}
public static void main(){
PersonneAdulte p = new PersonneAdulte ();
p.Nom = "Ali"; // nom  "Ali";
p.Age = 30; // age  30
Console.WriteLine(p.Nom); // appel au get
}
}
65
© A. Benabbou
Les classes
–Si les méthodes get et set d'une propriété se contentent de lire et écrire
un champ privé sans aucun autre traitement, on peut utiliser une propriété
automatique déclarée par:
public Type NomPropriete{ get ; set ; }
Exemple
class PersonneAdulte{
// attributs
private int age;
// propriétés
public string Nom{get; set; }
public int Age{
get{ return age; }
set{ if(value>=18) age=value;
else age = 18;}
}
…
66
© A. Benabbou
Initialisation d’objet
 C’est une simplicité du langage permettant d’initialiser un objet en utilisant ses
propriétés publiques sans créer de constructeur particulier
Syntaxe
NomClasse variable= new NomClasse {Propriete1=valeur1,
Propriete2=valeur2,… } ;
 Les propriétés peuvent être données dans n’importe quel ordre

 Si aucune propriété n’est mentionnée alors l’initialisation sera effectuée par le
constructeur par défaut
Syntaxe
NomClasse variable= new NomClasse {} ;
67
© A. Benabbou
Initialisation d’objet
 Exemple
class Produit
{ int code;
String nom;
float prix;
public int Code{ get{ … }
set{ … }
}
…
}
Produit p1=new Produit{Code=100, Nom="TV", Prix=5000};

Produit p2=new Produit{Nom="PC",Code=200};
Produit p3=new Produit{}; //constructeur par défaut
68
© A. Benabbou
Inférence de type
 C’est une simplicité du langage qui peut être utilisée lors de la déclaration d’une
variable avec initialisation, on peut alors utiliser le mot clé var à la place du type.
Syntaxe
var variable = new Type();
var variable = expression;
Remarque: la variable ne peut pas être initialisée à la valeur null
 Exemple
var i = 1;
var s = "Bonjour";
var t = new[] { 0, 1, 2 };
var list = new List<Produit>();
foreach(var item in list){ ... }
69
© A. Benabbou
Les méthodes
L’indexeur
L’indexeur est défini comme une propriété de la classe
Pratiquement, c’est une surcharge de l’opérateur [], ce qui permet d’utiliser une
référence de la classe comme un tableau
Syntaxe:
class NomClasse
{ Typetab[] tableau;
public TypeTab this[int indice]
{
get { return tableau[indice]; }
set { tableau[indice] = value; }
}
}
Utilisation:
NomClasse x=new NomClasse();
x[i]=valeur;
Variable=x[i]; 70
© A. Benabbou
Les méthodes
L’indexeur
L’indice utilisé par l’indexeur peut être de n’importe quel type
On peut aussi utiliser plusieurs paramètres comme indexeurs (exemple pour les
tableaux à plusieurs dimensions)
Exemple:
class NomClasse
{ Type[][] tableau;
public Type this[int i, int j]
{
get { return tableau[i][j]; }
set { tableau[i][j] = value; }
}
}
Utilisation:
NomClasse x=new NomClasse();
x[i, j]=valeur;
Variable=x[i, j]; 71
© A. Benabbou
Les méthodes
Surcharge des opérateurs
Les opérateurs doivent être surchargés par des fonctions statiques
On peut surcharger uniquement :
–Les opérateurs arithmétiques, sauf les affectations étendues exemple += qui seront
automatiquement pris en compte
–Les opérateurs sur les bits,
–Les opérateurs de comparaison, mais par paire opposée exemple == et !=
–- Les opérateurs de conversion de type (implicitement ou explicitement)
Syntaxe:
class NomClasse
{
public static Type operator X(liste_paramètres)
{
}
© A. Benabbou
} Les paramètres seront constitués par les opérandes de l’opérateur 72
Les méthodes
Exemple :
class Complexe
{
public static Complexe operator + (Complexe a, Complexe b)
{
Complexe z=new Complexe(a.Re+b.Re,a.Im+b.Im);
return z;
}
}
Complexe z1=new Complexe(2,3),
z2=new Complexe(7,1),
z=new Complexe();
z = z1 + z2; //équivaut à : z= Complexe.operator+(z1,z2);
73
© A. Benabbou
Les méthodes
Exemple :
class Complexe
{
public static explicit operator string (Complexe a)
{
string s=a.Re+"i"+ a.Im;
return s;
}
}
Complexe z1=new Complexe(2,3),
Console.WriteLine("z1=" +(string)z1);
Si on utilise implicit au lieu de explicit, la mention du

casting devient facultative.
74
© A. Benabbou
Les méthodes
Passage de paramètres
Paramètre en entrée uniquement : par défaut, les paramètres d'une fonction sont
passés par valeur. Donc les modifications ne persistent pas à la sortie de la fonction
Paramètre en entrée/sortie : le passage par référence est obtenu en utilisant le mot
clé ref
Type methode(ref type1 param1,…){
}
Lors de l’appel il faut encore indiquer ref :
Methode(ref p1, …);
p1 doit cependant avoir une valeur initiale non nulle avant l’appel
Paramètre en sortie uniquement: on peut aussi utiliser le mot clé out similaire à
ref mais qui ne nécessite pas de valeur initiale pour le paramètre effectif
75
© A. Benabbou
Les méthodes
Paramètres variables
Le nombre de paramètres d’une fonction peut être variable en utilisant le

mot clef params
En fait c'est un tableau linéaire du type déclaré par params qui est passé
en paramètre.
TypeFonction NomFonction( paramètres, params nomType[ ] list)
{…}
Le mot clef params doit être le dernier de la liste des paramètres formels.
Un seul mot clef params est autorisé dans la liste des paramètres formels.
Le passage ne peut s’effectuer que par valeur (ni ref ni out)
La liste de paramètres passés par params peut être vide.
76
© A. Benabbou
Les méthodes
Paramètres variables
Exemple :
static int sum( int a , int b, params int [] liste) {
int s=a+b;
for(i=0; i<liste.Length; i++)
s+=liste[i];
return s;
}
public static void Main()
{
int x=10, y=20, z=0;
z = sum( x, y, 5, 8, -6);
z = sum( x, y);
z = sum( x, y, 89,45,78,26,58,102,47);
}
77
© A. Benabbou
Les méthodes
Paramètres optionnels et nommés
Les fonctions peuvent avoir des paramètres optionnels ayant des valeurs
par défaut (type valeur uniquement)
TypeFonct NomFonction(…,Type1 param1=v1, Typek paramk=vk) {
… }
Ces paramètres peuvent être omis lors de l’appel
Exemple :
void Reset(float t[], int pos=0, float val=0){
for(int i=pos;i<t.Length;i++)
t[i]=val;
}
Lors de l’appel :
float t[]=new float[10];
Reset(t); //pos=0 et val=0
Ou:
Reset(t,0 ,-1); //pos=0 et val=-1
Ou:
Reset(t,1,-1); //pos1 et val=-1
78
© A. Benabbou
Les méthodes
Paramètres optionnels et nommés
Les paramètres nommés permettent de ne pas respecter l’ordre des
paramètres de la fonction lors de l’appel
On utilise alors le nom du paramètre et sa valeur dans l’appel à la fonction :
param:valeur
Exemple :
void Inserer(double tab[], int pos, double val){
…
}
Lors de l’appel :
double t[]=new double[10];
Inserer(t,2,3.4);
Ou:
Inserer(val:3.4, pos:2,tab:t);
Ou:
Inserer(t,val:3.4,pos:2);
79
© A. Benabbou
Les collections
L'espace de noms System.Collections contient les classes représentant les structures de
données les plus couramment utilisées : ArrayList, Queue, Stack, et Hashtable.
Exemple: une liste ArrayList
ArrayList liste = new ArrayList();
for (int i=0;i<10;i++)
liste.Add(i*3.14);
liste.RemoveAt(3);//suppression par la position
Console.WriteLine(liste.Contains(6.28));
Console.WriteLine("pos="+liste.IndexOf(6.28));
foreach (var element in liste)
Console.WriteLine(element);
for (int j = 0; j < liste.Count; j++ )
{
Console.WriteLine(liste[j]);
}
80
© A. Benabbou
Les collections
 Exemples: pile, file d’attente et table de hash-codage
 Stack pile = new Stack();
pile.Push(3.14); //empiler
double x = (double)pile.Pop(); //depiler
 Queue file = new Queue();
file.Enqueue(3.24); //enfiler
double y = (double)file.Dequeue(); //defiler
 Hashtable t = new Hashtable();
t.Add("C567845", "Benali Ali"); //ajout d’une clé et sa valeur
t.Add("D567845", "Bensaid Said");
foreach(String clé in table.Keys)
Console.WriteLine(clé);
foreach (String valeur in table.Values)
Console.WriteLine(valeur);
String personne = (String)t["D567845"]; //accès par la clé
Console.WriteLine(personne);
81
© A. Benabbou
Les génériques
Même concept que les classes « template » de C++
Ce sont des classes paramétrées par une suite de types génériques
Syntaxe de classe générique
class NomClasse<T1,T2,…..,Tk>
{
….
}
Où T1, T2 à Tk sont des identifiants de type génériques
Les génériques évitent d’utiliser un casting et permettent donc d’avoir un

code plus sécurisé (code-safe) : un casting n’est analysé que lors de
l’exécution ce qui peut générer une exception.
Les génériques du C# peuvent être une Classe, Interface , Méthode ou
Délégué paramétrés par un ou plusieurs types génériques
82
© A. Benabbou
83
© A. Benabbou
Les génériques
Exemple
class Pile<T>{
public T Depiler(){
…
}
public void Empiler(T element){
…
}
…
}
Instanciation:
Pile<int> pile1=new Pile<int>();
Pile<String> pile2=new Pile<String>();
Remarque: L'espace de noms System.Collections.Generic contient plusieurs classes
collection génériques, exemple : List<T>, Stack<T>, Queue<T>, Dictionary<T1,T2>.
84
© A. Benabbou
Les génériques
On peut aussi spécifier des contraintes sur les types génériques en utilisant where de
manière à n’accepter lors de l’instanciation que les types concrets qui respectent ces
contraintes.
Syntaxe :
class NomClasse<T> where T : Contrainte
– where T: struct signifie le type T doit être un type par valeur
– where T : class signifie le type T doit être un type par référence
– where T : new() signifie le type T doit avoir un constructeur par défaut
– where T : NomClasse signifie le type T doit étendre la classe spécifiée
– where T : NomInterface signifie le type T doit implémenter l’interface spécifiée
 NB: Les contraintes peuvent aussi être combinées
85
© A. Benabbou
Les génériques
Exemple:
Class Pile<T> where T: class, IComparable
{
}
Donc seules les types références (classes) et qui implémentent l’interface IComparable
sont autorisés comme type concrets lors de l’instanciation
Pile<int> pile1; //erreur car int n’est pas un type référence

Pile<String> pile2; /*correct car la classe String implémente
l’interface Icomparable*/
86
© A. Benabbou

Cours DotNet C# Part1

Transféré par

Droits d'auteur :

Formats disponibles

Cours DotNet C# Part1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours DotNet C# Part1

Transféré par

Droits d'auteur :

Formats disponibles

Plateforme Microsoft .

 Le .NET est une plateforme de développement de logiciels, créée par

 Le .NET offre un Kit de développement logiciel (SDK) comprenant un

 Le .NET est aujourd’hui une plate-forme de développement open source, libre

.NET Core est une implémentation .NET multiplateforme pour les

 Le .Net Framework permet de développer les applications consoles,

VB.NET VC++ C# JScript Perl …

Common Language Specification

ASP.NET: Web Forms Windows Forms

ADO.NET: Data and XML

.NET Framework Base Classes

Common Language Runtime

Evolution .NET Framework:

 Bien que se terminant par l’extension .exe, un programme issu

Diagnostics Reflection Text Remoting

Globalization Resources Threading Serialization

– System.Net : Accès au réseau (WebRequest, WebResponse,

C# est une amélioration de C++ et ressemble à Java en divers points

 Un exécutable console : csc /target:exe prog.cs  prog.exe

 Un exécutable Windows : csc /target:winexe prog.cs  prog.exe

Une application C# est composé d’une ou plusieurs classes

La méthode Main représente l’entrée à l’exécution de l’application

public static void Main(String[] args){

Compilation sur la ligne de commande: csc prog.cs

Les opérateurs sont pratiquement les mêmes qu’en C++

exp as nomType : renvoie un objet représentant la conversion de

typeof(exp) : renvoie un objet de la classe System.Type permettant de

Tous les types de C# héritent de la classe racine object

Type Désignation (taille)

object est la classe de base de toutes les classes en C#

 Longueur d'une chaîne par la propriété Length :

 Les propriétés peuvent être données dans n’importe quel ordre

Produit p1=new Produit{Code=100, Nom="TV", Prix=5000};

Si on utilise implicit au lieu de explicit, la mention du

Le nombre de paramètres d’une fonction peut être variable en utilisant le

Les génériques évitent d’utiliser un casting et permettent donc d’avoir un

 NB: Les contraintes peuvent aussi être combinées

Pile<int> pile1; //erreur car int n’est pas un type référence

Vous aimerez peut-être aussi

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.