Chapitre 1 - Introduction :

- Comment exécuter un programme ?

 L’ordinateur exécuter les séquences de code source pour créer un programme binaire
c’est le langage assembleur.
 Les programmes binaires fonctionnent seulement dans l’environnement dans lequel ils
ont été compilés.
 Avec C# vous pouvez créer distribués à tous les SE malgré que la compilation s’effectue
sur une version Windows.

C# CIL (Langage intermédiaire)  Binaire

NB : C# est un langage de programmation orienté objet
(ressemble à java) fournit par Microsoft.
C  C++  C#
 Exemple des applications qui créer avec C# (- Paint -)

Les variables :

Sert à réserver une case mémoire, un variable C# à un nom, type et initialisation :

Exemple :

Int a=5 ; string nom=’Développement Informatique’;

Bool l=true ; char c=’f’ ;

 Pour savoir le type d’un variable utiliser type of()

 Pour savoir la taille mémoire utiliser size of()

Les opérations logiques :

Not : ! Xor : ^ And : && Or : ||

Les conditions :

If(condition)

istruction

}
 If(condition)

Instruction

Else

If(condition)

{ Instruction}

Présentation du programme C# :

Console.WriteLine(……….) ; // = printf dans la langage C

Console.ReadLine() ; // =pause

Int a = int.parse(Console.ReadLine()) ; // = scanf dans C ou lire dans l’algorithme

Les notions de base en C# :

 Les conversations des types de données :

1) Implicite : entre les variable de même type et de taille différente.

Int i= 10 ;

Long j =i+2 ;

2) Implicite : entre les variables de type diffèrent. Ce type de conversation s’effectur des
fonction.

Methode1 Methode2 Methode3

Double i=7,1 ; String s= ‘’500’’ String s = ‘’a’’ ;
Int j=(int) i ; Int i = int.parse(s) ; Char s = convert.tochar(s) ;
Int j = as int ;

Les méthodes :

1- Définition : c’est un regroupement d’instruction entre deux{ }, avec nom et un type de

retour.
2- Déclaration :
- Static void(string nom){Console.WriteLine(nom) ;} // pour les procedure
- Static int somme (int x,int y){return x+y ;}
 Nb : la surcharge d’une méthode permet de déclarer
une méthode plusieurs fois avec des signatures
différentes.

Les tableaux :

1- Définition : Un regroupement de donnée de même type.

2- Déclaration :

Type[] nomtableau[] = new type[taille] ;

Nb : la propriété lenght permet de déterminer le

nombre des éléments dans un tableau.

Toujours le premier élément dans un tableau à l’indice

0. Et le dernier à l’indice (lentgh-1).

Les matrices :

 Déclaration :
Type [ , ] nom tableau = new type[n,m] ;
Type [ ][ ] nom tableau = new type[n][ ] ;
- Exemple :
Int [ , ] exp1 = new int[6,3] ;

Nb :
 pour convertir un tableau de char en string :
char [ ] t= new char [ ]{‘a’,’b’} ;
String s = new string (t) ;
 pour diviser un tableau à leur lettre :
string s = ‘’abc ‘’ ;
char[] t ;
t=s.tochararray() ;

Les collections : rassemble des données avec plusieurs présentations.

1) List : rassembler des données de même type, mais les listes travaillent avec les
valeurs au lieu des références.
 Déclaration :
List<type> nom liste = new List<type>(initialisation) ;
List<string> list1 = new List<string>() ;
 Ajout des données :
 Nom list.Add(objet) ;
Nom list. AddRang(collection) ;

 Affichage des données :

Foreach(type x in nom list)
{
Console.WriteLine(x) ;
}
For(int i=0 ;i<nom list.count ;i++)
{
Console.WriteLine(nom liste[i]) ;
}

Nb :
 Count : nombre des données dans la liste.
 Capacity : nombre possible de donnée dans la liste.

Autre méthodes :
Insert : ajouter un élément à une position.
Nom List. Insert( indice, objet ) ;
Remove : supprimer un élément.
Nom List. Remove(objet) ;
 RemoveAt : supprimer un élément avec sa position.
Nom List.RemoveAt(indice) ;

2) ArrayList : rassembler des données de diffèrent types.

ArrayList nom = new ArrayList() ;

Nom.Add( ‘’ABC’’ ) ;

Nom.Add( 1 ) ;

Nom.Add( ‘A’ ) ;

 L’affichage :
Foreach(objet o in nom){Console.Writeline( o ) ;}

Chapitre 2 – Programmation Orienté Objet (POO) :

Introduction :

 Un langage procédurale est composé de procédure, ce qui va permettre au programme

de traiter une suite d’information, c -à-d , exécuter par instruction.
 Un langage orienté objet est composé d’objet, ce qui rend le code mois lourd et facile
pour le développer.
 Un programmation orienté objet amélioré la performance et utilise la notion d’héritage.
Les termes :

 Objet :
 Dans le monde réel, nous sommes entouré d’objet (chaise, table, voiture …)
 Un objet possède de propriétés (couleur ...)
 Un objet possède des actions ou méthodes (voiture roule ….)
 Les objets peuvent interagir (un conducteur démarre la voiture )
 Un objet est une structure composée de propriétés et action.
 On peut instancier ou initialiser plusieurs objets .
 Classe :
 Création de champs :
* Accessibilité type nom ;(public/protected/private...)
 les méthodes : [static] Accessibilité type de retour Nom (paramètres){ }
* Exemple :
public string identifier () {return prénom+""+Nom+"a"+Age+"ans";}
 Constructeur : c'est une méthode appelé à chaque fois que vous voulez instancier un
nouveau objet à partir d'une classe
* le constructeur est la méthode ayant le même non que la classe et qui ne retourne
jamais rien (void), par contre pouvez lui passez des arguments

Déclaration :
Public Nom class (Paramètre)
{
Instruction
.....
}

 Les types de constructeur :

Constructeur par défaut : c'est le constructeur qui ne prend pas de paramètres ou
dont tous les paramètres ont une valeur par défaut

NB : si aucun constructeur n'est déclaré, on utilise

le constructeur par défaut.

Exemple :
public personne (){
_Nom="karimi";_
prénom="karim";
_age=20;
}
 Constructeur d'initialisation : c'est un constructeur qui permet d'afficher des valeurs
aux champs de la classe au moment de l'inisialisation

Exemple :
public personne (string Nom ,String prenom,int Age)
{
_Nom=Nom ;
_prenom=prénom ;
 _age=Age ;
}
 Constructeur par copie : c’est un constructeur qui permet d'istancier un objet à partir
d'un autre objet

Exemple :
Public personne (personne p)
{
_Nom=p. Nom ;
_prenom=p. Prenom ;
_Age=p. Age ;
}

 Encapsulation :

 Définition :
- l'encapsulation est l'idée de protéger les informations d'un objet et proposer des
méthodes de modifications de cet objet.

Niveau d'encapsulation :
- par défaut /private :les attributs privés sont accessibles seulement par la classe elle-
même.
- Public : les attributs publics sont accessibles par toutes les classes.
- Protected : les attributs protèges sont accessibles par la classe elle-même, et les classes
dérivés (héritage).
- Internal : les attributs internal sont accessibles par la classe elle-même et les classes
dérivés.

 Les accesseurs et les mutateurs :

Définition :
--> Accesseur : une méthode qui prendre aucun paramètre qui aura comme type de
retour le type du champ à récupérer (Get).
--> Mutateur : méthode sans type de retour prenant en paramètre la nouvelle valeur à
affecter.
--> Syntaxe :
Public string GetNom () {return _nom ;} //lecture seule
Public void set Nom (string s) {_nom=s ;} //Ecriture seule
*Exemples*
Public string nom () {get {return _nom ;}set {_nom=value ;}}

NB: Ce type d'accesseur avec mutateur est appelé

proprety.
NB : vous pouvez ajouter les accesseurs et les
mutateurs comme suit :
public int age {get;set;}.
  Static :
Si vous créez une classe static, vous n'avez pas besoin d'instancier la classe

 Classe. Méthode ()

La méthode Main () est static, pas besoin d'instancier la classe program pour l'exécuter
=> Les variables déclarés par static, sont des variables de la classe partagés entre les
méthodes de la classe, ne sont pas liés à un objet

 Passage par valeur ou passage par référence

** le mot clé ref permet de passer par référence **

*** Exemple ***

Void switch (ref Int i, ref Int j)

Int c=i ;

I=j ;

J=c ;

* lors de l'appel de ce type de méthode vous devez précéder toujours par ref. Suivé par la valeur

* le mot clé out permet de passer par référence pour les méthodes qui n'attend pas à recevoir des
variables initialisées

String s= "az";

Bool b= int.tryparse(s, out i) ;

Static void affecter (ref Int a)

a=30 ;

Static void affecter2 (out in a)

a=30 ;

Static void main ()

Int age ;

Affecter (ref age)

affecter2 (out age) ;

Nb :
this : référence de l’objet actuel il est utilisé
obligatoirement dans le cas de conflit d'identificateur .
Exemple

Class personne {public string nom ; public string prenom ;}

Public personne (string nom ; string p)

This. Nom=nom ;

Prenom=p ;

Chapitre 3 – Héritage :
1 - Définition :

 Représente le mécanisme de réutilisation du code et la gestion de son évolution.

 c'est une relation entre deux classes une classe mère (super class) et une classe fille (sous
classe, classe dérivé) qui hérite le code de la classe mère.

2 - déclaration :

Class A class B : A

{ {

} }

La classe B fille de la classe A.

B hérite de A.

NB : une classe peut hérite d'une seule classe mère.

3 - Exemple :

Class Humain

{
 Private Int _Age ;

Private string _Nom ;

Private string _Prenom ;

public humain (string nom, string prenom,int age)

This. _Nom=nom ;

This._prenom=prenom ;

this._ Age=age ;

Class Enfant : Humain

Private string Niveau_Scolaire ;

Public Enfant (string nom, string prenom, Int age, string niveau_scol)

: Base (Nom, Prenom, Age)

This. Niveau_Scolaire=niveau_scol ;

 Polymorphisme

a - définition :

le polymorphisme est l'idée de permettre à un même code ( méthode , champ, propriété)d'être

utilisé dans le différents classes dérivé.

* Substitution : Redéfinir les caractéristiques et les actions d'un attribut père

Class A

Public Virtual void afficher ()

{
}

Class B : A

Public override void afficher ()

 Masquage :

- Le masquage par héritage se produit lorsque les classes déclarant des noms qui ont été hérités de la
classe mère.

- Le masquage est utilisé pour une constante, un champ, une propriété ou une méthode.

-->Exemple1 :
Class A

Public void f ()

}}

Class B : A

New public void f ()

}}

--> Exemple 2 :
Class humain

Public string afficher ()

{

Return string. Format ("le nom {0}, prenom {1}", Nom, Prenom) ;

}}

Class Adulte : humain

New public string Afficher ()

Return Base. Afficher () +diplôme ;

}}

 les types de classes

a - Abstraite :

* définition : une classe abstraite est une classe dont l'implémentation n'est pas complète et qui
n'est pas distanciable

Elle sert comme base de l’autre classe dérivée

b - déclaration

Abstract class Nom class {- - -}

* Exemple :

Abstract class personne

Public string nom ;

Public string prenom ;

Public Virtual string afficher ()

{ Return nom+" "+prenom ;}

Public abstract Int age (date time naissance) ;

NB :
* les méthodes d'une classe abstract sont tous déclarer
Virtual ou abstract

* pour redéfinir une méthode abstract dans une classe

dérivé utiliser override
* une méthode abstract ne contient pas des instructions.

 SEALED :

*la class sealed est un type de class déclaré pour Eviter l'héritage à partir de cette class

*les méthodes sealed sont des méthodes que vous ne pouvez pas redéfinir avec une substitution ou
masquage

-Déclaration :

Sealed class nom class {---}

--> Exemple

1) classe :
Sealed class Exemple1 {

Public Int x ;

Public Int y ;

Public Int ajouter () {return x+y ;}

--> Main ()

exemple1 e = new exemple1 () ;

e.x=10 ;

e. y=20 ;

console.writeline (e. ajouter()) ;

Class hérite : Exemple1

Public Int z ;

2) Méthodes :
Class x

Protected Virtual void f1 () {console.writeline ("f1") ;}

Protected Virtual void f2 () {console.writeline ("f2") ;}

Class y : x

{
Sealed protected override f1 () {console.writeline ("y.f1") ;}

Protected override f1 () {console.writeline ("y.f2") ;}

Class z : y

Protected override f1 () {console.writeline ("z.f1") ;}

Protected override f2 () {console.writeline ("z.f2") ;}

 La classe partiale :

* définition : ce sont des classes créés par parties, une classe partiale permet d'hériter de plusieurs
classes au même temps

* déclaration :

Partial class nom classe {---}

Partial class nom classe {---}

*Exemple :
Partial class code

Public Int x ;

Public Int y ;

public code (Int x ,Int y)

thist.x=x ;

this. y=y ;

Partial class code

Public Int somme () {return x+y ;}

Interface

a - Définition :
- une interface contient uniquement les signatures des méthodes, des propriétés

- une classe qui implémente une interface, doit redéfinir les membres de l'interface

- une classe peut implanter plusieurs interfaces à la fois

b - déclaration :

Interface Nom Interface

NB : par défaut une interface est toujours public.

c - Exemple :
1- interface Isimple

Void simple () ;

* class csimple : Isimple

Public void Isimple. Simple ()

console.writeline ("première interface") ;

* main ()

Isimple s = new csimple () ;

s.simple () ;

2- interface IPoint

Int x

{get ; set ;}

Int y {get ; set ;}}

Class cpoint : IPoint

Private Int _x ;

Private Int _y ;

Public Int x {get {return _x ;}

Set {_x=value ;}

3- interface Ix {

Void afficher () ;

Interface Iy {

Void afficher () ;}

Class z : Ix, Iy

Void afficher () {console.writeline ("Deux interfaces") ;}

Les exceptions : Gestion des erreurs

A/ Intérêt : dans un programme sans gestion des exceptions, certains actions imprévues peuvent
compromettre la fiabilité de l'application

- En effet une simple division par zéro peut plancer l'application

B/ Déclaration : Syntaxe

Try {} ==> le bloc de code à risque, c-a-d essayer d'exécuter ce code

Catch {} ==> le bloc de code au cas d’erreur, en général est un message explication la nature de
l'erreur

Finally {} ==> le bloc de code qui s’exécute dans tous les cas, ce bloc est facultatif

C/ Exemple :

Exemple 1 :
console.writeline (" donner votre age") ;

Int age=0 ;

TRy {age= int.parse (console.readline()) ;

console.writeline ("votre age est"+age) ;}

Catch {console.writeline ("vous devez saisir un entier") ;}

Exemple 2 :
Int x=0;

console.writeline ("donner un entier") ;

x=int.parse (console.readline()) ;

Try {

x=int.parse (console.readline()) ;

console.writeline ("le résultat est "+ (1/x)) ;}

Catch (exception e) {console.writeline (e. message) ;}

Finally {console.writeline(Fin) ;}

Exemple 3 :
Int x=0 ;

console.writeline ("donner un entier") ;

x=int.parse (console.readline()) ;

Try {

If(x==0)

Throw new exception ("c'est une division par0") ;

console.writeline ("1/x = {0}",1/x) ;

Catch (divide byZeroException ex)

console.writeline (ex. Message) ;

Exemple 4 :
console.writeline ("donner le premier nbr") ;

Try {unit a = unit.parse (console.readline()) ;

console.writeline ("donner le deuxième nbr") ;

Unit b = unit.parse (console.readline()) ;

Unit c = a/b ;

console.writeline ("le résultat est "+c);}

Catch (overflowexception)

console.writeline ("vous devez entrer des nbrs positifs") ;

}

Catch (divideByzeroException)

console.writeline ("c'est une division par 0") ;

Catch (Format Exception)

console.writeline ("les chaines de caractères ne sont pas autorisés") ;

==> Exemple 5 :
Class Monexception : Exception

Public Monexception () : base ("Erreur Monexception") ;{}

Class Monexception : exception

Public Monexception () : base ("Erreur")

this.helplink="TDI.ma";

==> Exemple 6 :
Class Monexception : application Exception

Private string _message ;

Public string message {get {return _message ;}set {_message=value ;}}

Public monexception (string message)

this. Message=message ;

Public monexception (exception e)

this. Message=e. message ;

}}
Gestion des fichiers

 la bibliothèque : Using systèm.IO ;

1/ Gestion d'un fichier :

a - StreamWriter :

¤ StreamWriter sw = new streamWriter (string path) ;

Path => chemin d'accès\Nom fichier.txt

¤ Exemple1 :
If (File.Exists (path) ==False)

StreamWriter sw1 =new StreamWriter (@"D:\test.txt") ;

console.writeLine ("Fichier crée") ;

Else

console.writeLine ("Fichier est déjà existe");

b - Create :
string path = Environnement.GetFolderPath(Environnement.SpecialFolder.DeskTop);

String fichier = path+@"\Tp1.txt";

If (File.Exists (fichier)==False)

file.create (fichier) ;

console.writeLine ("Fichier crée") ;

Else

console.writeLine ("Fichier est déjà existe");

c - CreateDirectory :
String path = Environnement.GetFolderPath(Environnement.SpecialFolder.DeskTop);

string dossier = path+@"\TP";

If (Directory.Exists (dossier) ==False)

Directory.createDirectory(Dossier) ;
console.writeLine ("Dossier crée") ;

Else

console.writeLine ("Fichier est déjà existe");

2/ Ecrire dans un fichier :

a - StreamWriter :
if(File.exists(@"D:\cours\Exp.txt")==false)

StreamWriter sw = new streamWriter (@"D:\cours\Exp.txt") ;

sw.writeLine ("Bienvenue à TDI") ;

Else {console.writeLine ("fichier déjà Existe") ;}

b - File :
If (File.Exists (fichier) ==false)

string text ="première ligne dans le fichier"+Environment.NewLine;

File.WriteALLText (fichier, text);

else

string text1 ="Deuxième ligne dans le fichier");

File.AppendALLText(fichier,text1);

3/ lire un fichier :

a - StreamReader :
StreamReader sr= new StreamReader(fichier);

string ligne =NULL;

while((ligne=sr.Readline())!= NULL)

console.writeline(ligne);

sr. Close();
-NB : pour Stream Reader et StreamWriter vous devez arrêter l'exécution des deux à

La fin de l'écriture ou de la lecture avec la méthode close ().

b - File :

String [] lignes = file.ReadALLLines(fichier);

foreach(string s in lignes)

console.writeline(s);