#Programmation Objet avec C

Avril 2022
 QU’EST-CE QUE C#
 Langage de programmation moderne qui combine la programmation orientée objet, fonctionnelle, et
générique

 Langage très similaire à Java, mais basé sur C++ et Visual Basic
 Combine les meilleures fonctionnalités de ces langages et élimine certaines de leurs faiblesses
 Offre une programmation plus facile et des syntaxes plus simplifiées.

 Crée par Microsoft en 2002, C# a évolué version par version

 C#1.0 fourni avec .NET Framework 1.0  C# 10 fourni avec .NET 6 ( 2021 )

 Conçu pour fonctionner avec .NET Framework, .NET core , .NET

2
POO
 .NET

 Plateforme sur laquelle vous pouvez construire toutes sortes d’applications

 Peut être considéré comme une boîte à outils qui vous aide à développer vos applications

 Prend en charge un large éventail de langages de programmation tels que C#, VB.NET, F# et C++/CLR.

 Vous pouvez utiliser n'importe quel langage pris en charge par .NET pour créer des applications
au-dessus du Framework .NET

 La plupart des systèmes Windows modernes ont .NET comme Framework intégré.

3
POO
 .NET
 .NET est une plateforme indépendante du langage utilisé, car c’est une plate-forme Common
Language Infrastructure (CLI)

 La CLI est une spécification qui décrit comment un environnement d'exécution peut être utilisé sur
différentes plates-formes informatiques sans être réécrit pour des architectures spécifiques.

 Quel que soit le langage que vous allez utiliser (C#, F#, VB.NET), la CLI permettra à votre
programme d'être exécuté sur n'importe quel système d'exploitation

 Lorsque vous compilez votre code, il sera convertit en un "langage intermédiaire" appelé CIL (Common
Intermediate Language). On peut voir le CIL comme une traduction dans la langue que parle .NET

 C’est ce code CIL qui sera ensuite exécuté par la CLR

4
POO
 CLI
 .NET Framework, .NET Core sont des plateformes
qui implémentent la CLI .
 .NET Framework: Pour le développement
d'applications .NET pour Windows. Distribué avec le
système d'exploitation Windows.
 .NET Core : multiplateforme (Windows, Linux ,Mac)
et open source, optimisé pour les exigences des
applications modernes .

5
POO
 CLR

 L’exécution d’un programme sur .NET est géré par un système

d'exécution virtuel appelé Common Language Runtime (CLR)
 À la compilation, le code source est convertit par le compilateur en un
langage intermédiaire appelé Commun Intermediate Langage(CIL)

 Le code CIL est exécuté ensuite par la machine virtuelle (CLR) qui effectue le
Just-In-Time (JIT) compilation pour changer le code CIL en code machine

6
POO
 QUE PEUT-ON FAIRE AVEC C#
 Applications bureau

 Applications WEB

 Applications mobiles

 Jeux

 Applications IA
 Services WEB
 …
7
POO
 PREMIER PROGRAMME EN C#

 Un programme C# peut contenir une ou plusieurs définitions de

classes.

 Il est recommandé de mettre chaque définition de classe dans un

fichier séparé, dont le nom correspond au nom de la classe.

 Un fichier C# a l’extension .cs

8
POO
 PREMIER PROGRAMME EN C#
 Le code ci-dessous représente le minimum qu'un programme C# doit contenir :

 Un seul fichier avec une seule classe ayant une seule méthode appelée Main.
using System;
namespace premier
{
class Program
{
public static void Main()
{
Console.WriteLine("Bonjour !\n");
}
}
}

 Après compilation et exécution le message Bonjour! sera affiché sur la console 9

POO
 PREMIER PROGRAMME EN C#
 using System;

 Indique que nous pouvons utiliser des classes du namespace System dans ce programme

 System est le namespace principal de la bibliothèque des classes de base de C#

 namespace premier

 On définit notre propre espace de noms, appelé premier.

 Un espace de noms est défini avec le mot-clé namespace.

 class Program

 Dans le namespace premier, on définit une seule classe appelée Program.

 Une classe est définit avec le mot-clé class

10
POO
 PREMIER PROGRAMME EN C#
 public static void Main()

 La classe Program contient une seule méthode appelée Main

 Cette méthode est le point d'entrée de notre application console.

 La méthode Main est une méthode statique

 Une application console en C# a une et une seule méthode Main.

 Console.WriteLine("Bonjour !\n");
 La méthode Main contient une seule ligne de code. On y utilise la méthode WriteLine de la classe
Console pour afficher Bonjour sur la console. Console est une classe du namespace System.

11
POO
#Les bases de C
Avril 2022
 COMMENTAIRES
 // Commentaire sur une seule ligne, style C++

 /* Commentaire sur plusieurs lignes, style C */

/*
Ma première classe en C#
*/
class Program
{
// Point d’entrée du programme
public static void Main()
{
Console.WriteLine("Bonjour !\n");

}
}
13
POO
 PRINCIPAUX TYPES DE DONNÉES

14
POO
 VARIABLES
 Vous devez déclarer une variable avant de l'utiliser dans votre programme. Pour cela :

• Spécifiez le type de données de la variable

• Spécifiez le nom de la variable

• Définissez la valeur initiale de la variable ( une variable doit recevoir une valeur avant de pouvoir être utilisée)

public static void Main()

{
string nom ="Ali"; // déclaration + initialisation

Console.WriteLine( $"Bonjour {nom} !\n");

}
15
POO
 VARIABLES

 C # a certaines règles concernant les noms de variables. Ces règles sont les suivantes :

 Vous pouvez utiliser un trait de soulignement (c'est-à-dire "_"), des lettres et des chiffres

 Vous ne pouvez pas commencer le nom d’une variable par un chiffre

 Vous ne pouvez pas utiliser de mots réservés de C# pour nommer vos variables

 Donnez un nom significatif qui permet de retrouver l’utilité de cette variable et il est préférable que le nom
débute par une minuscule.

16
POO
 CONSTANTES
using System;
namespace premier
{
class Program
{
public static void Main()
{
const float PI = 3.14f;
int r = 12;
Console.WriteLine("Perimètre = {0}" , PI * r * r);
}
}
} 17
POO
 CONVERSION DE TYPE
 On parle de conversion de type en C# lorsqu'une valeur d'un type de données est affectée à une
variable d’un autre type de données.

 Il existe deux types de conversion en C# :

 Conversion explicite : Convertit manuellement un type plus grand en un type de taille plus petite.

 double->float->long->int->char

 Conversion implicite : Convertit automatiquement un type plus petit en un type de taille plus grande.

 char->int->long->float->double

18
POO
 CONVERSION DE TYPE

 Conversion implicite : Cela se fait automatiquement.

19
POO
 CONVERSION DE TYPE

 Conversion explicite : Cela se fait explicitement en mettant le type entre parenthèses

20
POO
 CONVERSION DE TYPE
 Des méthodes prédéfinies peuvent être utilisées pour convertir explicitement des types de données
tels que : Convert.ToDouble, Convert.ToString, Convert.ToInt22, Convert.ToBoolean, …

21
POO
 LES CHAÎNES DE CARACTÈRES
 Le type string est utilisé pour stocker des chaînes de caractères, délimitées par des guillemets.

 string str = "String";

 Quelques opérations sur les chaînes :

 string s = str + " en C#"; // Concaténation  String en C#
 string b = str.Replace( "i" , "o" ); // remplace i par o  Strong
 b = str.Insert(0, "My " ); // insère la chaine "My" à la position 0 My String
 b = str.Remove(0, 3); // supprime les 3 premiers caractères ing
 b = str.Substring(0, 3); // extrait les trois premiers caractères Str
 b = str.ToUpper(); // En majuscules  STRING
 int i = str.Length; // taille de la chaîne 6
22
POO
 TABLEAUX
 Déclaration :
 Allocation + Initialisation
 int[] tab = new int[] { 12, 1, 5, -2 };
 int[] X;
 int[] tab = { 12, 1, 5, -2 };
 Allocation mémoire :
 int[] X = new int[3];
 Quelques opérations sur les tableaux :
 Array.Sort(tab); // tri le tableau tab
 Accès aux éléments :
 Array.IndexOf(tab, 5); // recherche 5 dans tab
 X[0] = 1;
 Array.Copy(tab , X, 3); // copie les 3 premiers
 X[1] = 2;
éléments de tab dans X
 X[2] = 3;
23
POO
 TABLEAUX
 Parcourir un tableau :

string[] voiture = { "Corrola", "Ford", "Lexus"};

/****************************************************/

for(int i = 0 ; i< voiture.Length; i++)

Console.WriteLine(voiture[i]);

/***************************************************/

foreach( string V in voiture)

Console.WriteLine(V);

24
POO
 TYPE VALEUR ET TYPE RÉFÉRENCE
 Les types de données C# se répartissent en deux catégories :

 Type valeur : Une variable de type valeur stocke directement la valeur

 Les types de base ( int , double , etc) sont des types valeurs

 L’allocation mémoire pour ces variables se fait dans la pile d’exécution du programme

 Type référence : Une variable de type référence stocke une référence qui est comme une adresse de
l'emplacement mémoire ou la valeur est stockée

 Les chaînes de caractères, les objets et les tableaux sont de type référence.

 L’allocation mémoire pour ces variables se fait dans le tas

25
POO
 TYPE VALEUR

int a = 20;
int b = a;
int b = 42;

26
POO
 TYPE RÉFÉRENCE
int[] a1 = new int[] { 42, 43 };
int[] a2 = a1; // a2 est { 42, 43}
a1[0] = 0; // a1 est { 0, 43 }, a2 est { 0, 43 }

Les modifications via la variable

a1, sont automatiquement
visibles par la variable a2 car a1
et a2 font référence au même
emplacement mémoire

27
POO
 ENTRÉES/SORTIES STANDARDS
 La classe Console propose :

 Deux méthodes WriteLine et Write que vous pouvez utiliser pour afficher sur écran

 Deux méthodes ReadLine et Read que vous pouvez utiliser pour lire des entrées du clavier

public static void Main()

{
Console.WriteLine(" Bonjour!");
Console.Write("Entrez votre nom: ");
string nom = Console.ReadLine();
Console.WriteLine($" Bienvenue {nom} ");
char car = Convert.ToChar(Console.Read());
Console.WriteLine(" Vous avez saisi: {0} " , car);
28
POO }
 OPÉRATEURS ARITHMÉTIQUES

29
POO
 OPÉRATEURS DE COMPARAISON

30
POO
 OPÉRATEURS LOGIQUES

31
POO
 LES TESTS
static void Main()
{ else
Console.WriteLine("Entrez un entier positif"); {
var val = Console.ReadLine(); Console.WriteLine("{0} est impair" ,n);
int n ; }
int.TryParse(val, out n); }
if (n % 2 == 0)
{
Console.WriteLine("{0} est pair" ,n);
}

int.TryParse : Convertit une chaîne de caractères (représentant un nombre) en un

nombre entier. Si la chaîne ne peut pas être convertie, la méthode renvoie false
32
POO
 LES TESTS
Console.WriteLine("Entrez un entier [1-10]"); case 4: case 6: case 8:
var val = Console.ReadLine(); Console.WriteLine("Entier pair");
int e; break;
int.TryParse(val, out e); case 9:
switch(e) Console.WriteLine("Entier impair");
{ break;
case 1: Case 10:
Console.WriteLine(" Borne inf "); Console.WriteLine("Borne sup");
break; break;
case 2: case 3: case 5: case 7: default:
Console.WriteLine("Entier premier"); Console.WriteLine("En dehors de l’intervalle");
break; break;
}
33
POO
 LES BOUCLES

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

{
if (i % 2 == 0)
{
Console.WriteLine("{0} est pair", i);
}
else
{
Console.WriteLine("{0} est impair", i);
}
}

34
POO
 LES BOUCLES

int i =0;
while(i <=10)
{
if (i % 2 == 0)
{
Console.WriteLine($"{i} est pair");
}
else
{
Console.WriteLine($"{i} est impair");
}
i++;
}

35
POO
 LES BOUCLES

int n;
string val;
do
{
Console.WriteLine("Saisir un entier");
val = Console.ReadLine();
}while(!int.TryParse(val, out n));

36
POO
 LES BOUCLES

string[] langages = { "Java", "C#", "Python", "C++","JavaScript" };

foreach (string lang in langages)
{
Console.WriteLine(lang);
}

37
POO
 MÉTHODES
 En C#, vous devez déclarer et implémenter les méthodes à l'intérieur d'une classe

 Chaque méthode appartient à une classe

 Voici les règles qu’on vous recommande de suivre lorsque vous nommez votre méthode :

 Assurez-vous que la lettre initiale est en majuscule.

 Commencez chaque mot par une lettre majuscule (par exemple, PlusGrand, LignePrincipale, etc.).

 Utilisez des verbes et des noms comme noms de vos méthodes.

38
POO
 MÉTHODES
 Ajoutons une méthode Perimetre à notre classe Program, puis appelons-la dans la méthode Main
using System;
namespace premier
{
public class Program
{
public static void Main()
{
int r = 123;
Console.WriteLine("Primetre = {0}", Perimetre(r));
}
static float Perimetre(int r)
{
const float pi = 3.14f;
return pi * r * r;
}

}
}
39
POO
 MÉTHODES : SURCHARGE

 La surcharge de méthodes nous permet de déclarer deux méthodes ou plus dans la même classe avec le même
nom mais des paramètres différents.

 Il peut s'agir soit d'un nombre différent de paramètres, soit de paramètres de types différents.

 Il est impossible de surcharger une méthode en modifiant uniquement son type de retour.

static int Multiple(int a, int b) static int Multiple(int a, int b, int c)

{ {
return a * b; return a * b * c;
} }

40
POO
 MÉTHODES : PASSAGE DES PARAMÈTRES

 Par défaut, tous les paramètres d’une méthode sont passés par valeur en C#.

 Dans le cas d'un type valeur, la valeur est copiée de l'argument vers le paramètre. Paramètre et argument
concernent des zones mémoires différentes. Les modifications du paramètre n'ont pas d'impact sur
l'argument.

 Dans le cas d'un type référence, la référence est copiée de l'argument vers le paramètre. Paramètre et
argument concernent la même zone mémoire. Les modifications du paramètre modifient aussi l'argument.

41
POO
 MÉTHODES : PASSAGE PAR RÉFÉRENCE

 Vous pouvez transmettre des arguments de type valeur par référence, il suffit
d’utiliser le mot clé ref
 ref vous permet de créer un mécanisme de transmission par référence.

 ref doit être spécifié lorsque vous déclarez et appelez la méthode.

 Avec ref le paramètre devient un alias pour l’argument passé à la méthode. Donc paramètre
et argument concernent la même zone mémoire

42
POO
 MÉTHODES : PASSAGE PAR RÉFÉRENCE
class Program
{
static void Swap(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}
static void Main()
{
int num1 = 10; // initialisation
int num2 = 20; //initialisation
Console.WriteLine($" Avant swap: num1={num1}, num2={num2}");
Swap(ref num1, ref num2);
Console.WriteLine($"Après swap: num1={num1}, num2={num2}");
}
}
43
POO
 MÉTHODES : RÉFÉRENCE EN LECTURE SEULE

 Le modificateur in permet aussi de transmettre un argument par référence (pour les types valeur
et référence). Toutefois, il empêche la méthode appelée de modifier la valeur de l’argument.

 L’utilisation du modificateur in permet de résoudre les deux problèmes suivants :

 Lorsqu’un argument de type valeur est transmis à la méthode, il est copié (en interne) par la
méthode appelée. Si l'objet est volumineux (comme une grande structure), la surcharge
supplémentaire liée à la création d'une copie pour une utilisation locale peut être importante.

 Lorsque un argument de type référence est transmis sans modificateur in, il peut être modifié
par la méthode appelée.
44
POO
 MÉTHODES : RÉFÉRENCE EN LECTURE SEULE
class Program
{
static int Somme(in int a, in int b)
{
return a + b;
}
static void Main()
{
int num1 = 10; //initialisation
int num2 = 20; //initialisation
int S = Somme(in num1, in num2);
Console.WriteLine(" {0} + {1} = {2}", num1,num2, S);
}
}

45
POO
 MÉTHODES : PASSAGE PAR RÉFÉRENCE

 Vous pouvez aussi transmettre des arguments de type valeur par référence en
utilisant le modificateur out

 Dans ce cas, un argument passé à un paramètre out peut ne pas être explicitement
initialisé avant d’être transmis à la méthode. Ce qui est obligatoire avec les paramètres ref
ou in

46
POO
 MÉTHODES : PASSAGE PAR RÉFÉRENCE

class Program
{

static void initialiser(out int num)

{
num = 5;
}
static void Main()
{
int num1; // pas d’initialisation
iniatiliser(out num1);
Console.WriteLine(" num = {0}", num1);
}
}

47
POO
C# : Namespaces
Avril 2022
 NAMESPACES

 Les namespaces sont utilisés pour organiser votre code en unités logiques.

 Un namespace définit un espace de déclaration qui contient des types (classes,

structures, énumérations)

 Un namespace a un nom qui fait partie du nom complet du type

 Par exemple, le type String est définit dans le namespace System. Le nom complet de ce type est
System.String

49
POO
 NAMESPACES
 Pour simplifier on peut voir les namespaces comme des répertoires.

 Par exemple pour afficher sur l’écran, on utilise l’instruction :

System.Console.WriteLine

 Nous utilisons la méthode WriteLine de la classe Console qui se situe dans le

namespace System

 Au fait, on peut voir Console comme un fichier rangé dans le répertoire System et donc
pour accéder au fichier Console, il suffit de fournir le chemin complet à savoir
System.Console
50
POO
 NAMESPACES
 La directive using
 En règle générale, nous n'utilisons jamais le nom complet d’un type dans nos programmes, car
nous utilisons la directive using pour pouvoir utiliser directement le type dans la portée actuelle à
partir d’un namespace particulier.

 Par exemple pour pouvoir utiliser la classe Console, directement sans avoir à préciser son nom
complet qui est System.Console il suffit d’utiliser using en précisant le namespace System
comme suit :
using System;
……
Console.WriteLine("Bienvenue");
51
POO
 NAMESPACES
 Les namespaces sont utilisés :
 Pour aider à organiser le code.

 Généralement, les types qui vont ensemble sont déclarés dans le même namespace.

 Pour éviter d'éventuelles conflits de noms pour les types.

 Un programme peut s'appuyer sur différentes bibliothèques et il n'est pas improbable que des types
portant le même nom existent dans deux ou plusieurs de ces bibliothèques. En utilisant des espaces de
noms, le risque de conflits de noms est considérablement réduit.

52
POO
 NAMESPACES
 Un namespace est définit avec le mot-clé namespace.

 Il est implicitement public

 Il peut contenir n'importe quel nombre de types (classes, structures, énumérations).

namespace NomEspace
{
class MyClass{ }
struct MyStruct{}
enum MyEnum{}
} 53
POO
 NAMESPACES

 Un namespace peut contenir d'autres namespaces

namespace premier namespace premier.test

{ {
namespace test class MyClass { }
{ }
class MyClass{ }
}
}

54
POO
 NAMESPACES
 Pour déclarer une instance du type MyClass, vous devez utiliser son nom complet, comme suit :

namespace premier
{
class Program
{
static void Main()
{
var f = new premier.test.myClass();
}
}
}

55
POO
 NAMESPACES
 Pour éviter cela, vous pouvez utiliser using, en spécifiant le nom du namespace (où le type a été
définit) comme suit :

using premier.test;
namespace premier
{
class Program
{
static void Main()
{
var f = new MyClass();
}
}
}
56
POO
#Les exceptions en C
Avril 2022
 LES EXCEPTIONS
 Il arrive que notre code produit une erreur en raison d'un problème logique dans le code, comme :

 Une tentative de division par zéro

 Accès à un élément dans un tableau au-delà des limites du tableau.

 Des erreurs peuvent également se produire en raison de facteurs externes, tels que :

 La tentative de lecture d'un fichier qui n'existe pas sur un disque

 Une base de données inaccessible

 Pour gérer ces erreurs le programmeur doit mettre en place un mécanisme de gestion des exceptions.

58
POO
 LES EXCEPTIONS
 Une exception est un évènement exceptionnel et imprévisible qui apparaît pendant le déroulement d'un
programme et qui empêche la poursuite normale de son exécution. La syntaxe de gestion des exceptions est la
suivante :
try
{
// instructions;
}
catch (type_Execption ex)
{
// code pour la gestion de l’erreur
}
finally // facultatif
{
// code qui s’exécute après la gestion d’erreur
}
59
POO
 LES EXCEPTIONS
class Program {
static void Main()
{
int a = 10;
try
{
int b = a / 0;
}
catch (Exception ex)
{
Console.WriteLine(ex) ;
}
}
}

60
POO
 LES EXCEPTIONS
 Lorsqu'une erreur se produit à l'intérieur du bloc try, le programme crée une instance de la classe Exception et
lève l'exception.

 Dans le bloc catch, l’exception est gérée grâce à l’argument de type Exception :

 Il fournit des informations sur l’exception levée comme un message d'erreur, l'endroit où l'erreur s'est produite (nom de
fichier et chemin)

 Pour afficher juste le message associé à l'exception, nous pouvons utiliser la propriété Message de la classe
Exception. Comme suit :

catch (Exception ex)

{
Console.WriteLine(ex.Message);
} 61
POO
 LES EXCEPTIONS
 Les exceptions peuvent être levées avec l'instruction throw. Vous devez alors créer
une instance de la classe System.Exception ou une classe dérivée de celle-ci.

 C# définit un certain nombre de classes exceptions qui dérivent toutes de la classe

de base System.Exception. Ces classes peuvent être utilisées telles quelles ou

servir de classes de base à des classes d'exceptions personnalisées par le
développeur

62
POO
 LES EXCEPTIONS
 Les exceptions les plus souvent levées (à l’aide de throw) sont :

 ArgumentNullException : Utilisé au début d'une méthode pour valider les paramètres de la méthode. Comme les types de
référence peuvent prendre la valeur null, il est utilisé pour informer l'appelant que null n'est pas une valeur acceptable
pour la méthode.

 ArgumentException : il s'agit d'une autre exception utilisée au début d'une méthode. Sa signification est plus large et est
levée lorsque la valeur du paramètre n'est pas valide.

 IndexOutOfRangeException : Utilisée chaque fois qu'un paramètre pointe en dehors de la plage attendue d'un conteneur,
tel qu'un tableau ou une collection.

 InvalidOperationException : Utilisée pour rejeter l'invocation de la méthode chaque fois que l'état de l'objet n'est pas
valide pour l'action demandée.

 FormatException : Utilisée pour signaler une chaîne mal formatée ou pour l’ analyse du texte à d'autres fins.
63
POO
 LES EXCEPTIONS

 Plusieurs blocs catch peuvent exister pour le même bloc try.

 L'ordre dans lequel ils sont répertoriés est important car ils sont évalués dans cet ordre donné.

 Vous ne devez intercepter que les exceptions que vous savez gérer et récupérer

 Lorsqu'une exception se produit, le Common Language Runtime (CLR) vérifie s'il existe un bloc catch pour la gérer
dans la méthode en cours d'exécution. S'il n'en existe pas, il regarde dans la méthode qui a appelé la méthode
actuelle, et ainsi de suite dans la pile des appels. Si aucun bloc catch correspondant n'est trouvé, un message
d'exception non gérée s'affiche et l'exécution du programme est interrompue.

64
POO
 LES EXCEPTIONS
 La méthode suivante doit vérifier son argument d'entrée avant d’effectuer le traitement.
static void MyFct(object O)
{
if (O is null) throw new ArgumentNullException(nameof(O));
if (!(O is string)) throw new ArgumentException("Une chaine est requise");
// traitement
}
• Si l’argument O est nul, on lève une exception du type ArgumentNullException.
• Si l'argument n'est pas nul mais d'un type autre que string, on lève une exception du type
ArgumentException. Il s'agit de la classe de base de ArgumentNullException.

65
POO
 LES EXCEPTIONS
try
{
Console.WriteLine("Exécution");
MyFct(40);
}
catch (ArgumentNullException e)
{
Console.WriteLine($"Argument null: {e.Message}");
}
catch (ArgumentException e)
{
Console.WriteLine($"Argument incorrect: {e.Message}");
}
catch (Exception e)
{
Console.WriteLine($"Erreur: {e.Message}");
}
finally
{

}
Console.WriteLine("Gestion erreur effectuée");
66
POO
 LES EXCEPTIONS
 Lors de l'appel de la méthode MyFct, les exceptions suivantes peuvent être levées :

 ArgumentNullException

 ArgumentException

 Exception

 L'ordre est important car il commence par la classe la plus dérivée et se termine par la classe de base
de toutes les exceptions.

 Un bloc finally permet d'afficher un message une fois l’erreur a été gérée. 

67
POO