Université de Gafsa

Institut Supérieur d'Administration des Entreprises de Gafsa

Framework .NET (C#)

Chapitre 1 : Introduction au langage C#

Enseignant : Boubaker KHMILI

Public : 2^ème année Licence Business Computing

Année universitaire 2026/2027

Objectifs du chapitre

À l'issue de ce chapitre, l'étudiant sera capable de :

Expliquer le rôle du Framework .NET et du CLR
Décrire et analyser la structure d'un programme C#
Identifier et utiliser les types de données primitifs
Déclarer et manipuler des variables et des constantes
Appliquer les opérateurs arithmétiques, logiques et de comparaison
Écrire des structures conditionnelles (if/else, switch)
Implémenter des boucles itératives (for, while, do-while, foreach)
Manipuler des tableaux unidimensionnels et multidimensionnels

Plan du chapitre

Introduction au C# et au Framework .NET
Structure d'un programme C#
Types de données primitifs
Variables et constantes
Opérateurs
Structures conditionnelles
Structures itératives (boucles)
Tableaux et matrices

1

Introduction au C# et au Framework .NET

1. Introduction au C# et .NET

1.1 Historique du langage C#

C# (prononcé "C sharp") est un langage de programmation moderne, orienté objet, développé par Microsoft en 2000.

Caractéristiques principales

Créé par Anders Hejlsberg (également créateur de Turbo Pascal et Delphi)
Langage fortement typé et orienté objet
Syntaxe inspirée du C, C++ et Java
Gestion automatique de la mémoire (Garbage Collector)
Évolution constante : C# 1.0 (2002) → C# 12 (2023)

Domaines d'application

Applications Windows (WinForms, WPF)
Applications web (ASP.NET)
Jeux vidéo (Unity)
Applications mobiles (Xamarin, MAUI)

1. Introduction au C# et .NET

1.2 Le Framework .NET

Le Framework .NET est une plateforme de développement qui fournit un environnement d'exécution et une bibliothèque de classes pour créer des applications.

Composants principaux

CLR (Common Language Runtime) : machine virtuelle qui exécute le code
BCL (Base Class Library) : bibliothèque de classes de base
FCL (Framework Class Library) : ensemble complet de bibliothèques

Évolution de .NET

.NET Framework (2002) : Windows uniquement
.NET Core (2016) : multiplateforme, open source
.NET 5/6/7/8 (2020+) : unification des plateformes

1. Introduction au C# et .NET

1.3 Processus de compilation

Le C# utilise une compilation en deux étapes :

Code source (.cs)
↓ Compilation (csc.exe)
Code MSIL (.exe/.dll)
↓ Compilation JIT (à l'exécution)
Code machine natif

Définitions

MSIL (Microsoft Intermediate Language) : code intermédiaire indépendant de la plateforme
JIT (Just-In-Time) : compilateur qui traduit le MSIL en code machine au moment de l'exécution
Assembly : unité de déploiement (.exe ou .dll) contenant le code MSIL et les métadonnées

2

Structure d'un programme C#

2. Structure d'un programme C#

2.1 Squelette minimal

using System;

namespace MonApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Bonjour le monde !");
        }
    }
}

Éléments constitutifs

using : directive d'importation d'espaces de noms
namespace : espace de noms (conteneur logique)
class : déclaration de classe
Main : méthode point d'entrée du programme

2. Structure d'un programme C#

2.2 La directive using

La directive using permet d'importer un espace de noms pour utiliser ses classes sans qualification complète.

Sans using

System.Console.WriteLine("Bonjour");

Avec using

using System;
// ...
Console.WriteLine("Bonjour");

Espaces de noms courants

System : types fondamentaux (Console, String, Math...)
System.Collections.Generic : collections génériques
System.IO : entrées/sorties fichiers
System.Linq : requêtes LINQ

2. Structure d'un programme C#

2.3 La méthode Main

La méthode Main est le point d'entrée obligatoire de toute application console C#.

Signatures possibles

static void Main()
static void Main(string[] args)
static int Main()
static int Main(string[] args)

Caractéristiques

static : méthode de classe (pas besoin d'instance)
void / int : type de retour (void = aucun, int = code de sortie)
string[] args : arguments de ligne de commande

2. Structure d'un programme C#

2.4 Entrées et sorties console

Affichage (sortie)

Console.Write("Texte sans retour à la ligne");
Console.WriteLine("Texte avec retour à la ligne");

// Concaténation
Console.WriteLine("Résultat : " + resultat);

// Interpolation de chaînes (C# 6+)
Console.WriteLine($"Résultat : {resultat}");

Lecture (entrée)

string saisie = Console.ReadLine();  // Lit une ligne
int touche = Console.Read();           // Lit un caractère
ConsoleKeyInfo key = Console.ReadKey(); // Lit une touche

2. Structure d'un programme C#

2.5 Les commentaires

Les commentaires sont ignorés par le compilateur et servent à documenter le code.

Types de commentaires

// Commentaire sur une seule ligne

/* Commentaire
   sur plusieurs
   lignes */

/// <summary>
/// Commentaire de documentation XML
/// </summary>

Bonnes pratiques

Commenter le "pourquoi", pas le "quoi"
Maintenir les commentaires à jour avec le code
Utiliser les commentaires XML pour la documentation

3

Types de données primitifs

3. Types de données primitifs

3.1 Types numériques entiers

Type	Taille	Plage de valeurs
`byte`	1 octet	0 à 255
`sbyte`	1 octet	-128 à 127
`short`	2 octets	-32 768 à 32 767
`ushort`	2 octets	0 à 65 535
`int`	4 octets	-2,1 milliards à 2,1 milliards
`uint`	4 octets	0 à 4,3 milliards
`long`	8 octets	±9,2 × 10¹⁸

3. Types de données primitifs

3.2 Types numériques à virgule flottante

Type	Taille	Précision	Suffixe
`float`	4 octets	~6-9 chiffres	f ou F
`double`	8 octets	~15-17 chiffres	d ou D (optionnel)
`decimal`	16 octets	28-29 chiffres	m ou M

Exemples de déclaration

float prix = 19.99f;
double distance = 3.14159265359;
decimal solde = 1234567.89m;  // Idéal pour les calculs financiers

3. Types de données primitifs

3.3 Autres types primitifs

Type booléen

bool estValide = true;
bool estTermine = false;

Type caractère

char lettre = 'A';         // Guillemets simples
char retour = '\n';         // Caractère d'échappement
char unicode = '\u0041';    // Code Unicode (= 'A')

Type chaîne de caractères

string nom = "Bonjour";      // Guillemets doubles
string chemin = @"C:\Users"; // Chaîne verbatim (@ ignore les échappements)
string vide = string.Empty;   // Chaîne vide

4

Variables et constantes

4. Variables et constantes

4.1 Déclaration de variables

Syntaxe

// Déclaration
int nombre;

// Déclaration avec initialisation
int age = 25;

// Déclaration multiple
int x, y, z;
int a = 1, b = 2, c = 3;

Règles de nommage

Commence par une lettre ou underscore (_)
Peut contenir lettres, chiffres et underscores
Sensible à la casse (age ≠ Age ≠ AGE)
Ne peut pas être un mot réservé
Convention : camelCase pour les variables locales

4. Variables et constantes

4.2 Constantes et inférence de type

Constantes (const)

const double PI = 3.14159;
const string NOM_APP = "MonApplication";

PI = 3.14;  // ERREUR : impossible de modifier une constante

Inférence de type (var)

var nombre = 10;          // int
var prix = 19.99;         // double
var message = "Bonjour";  // string
var actif = true;         // bool

var x;  // ERREUR : var nécessite une initialisation

Remarque : var est fortement typé, le type est déterminé à la compilation.

4. Variables et constantes

4.3 Conversions de types

Conversion implicite (automatique)

int entier = 100;
double decimal = entier;  // OK : int → double (pas de perte)

Conversion explicite (cast)

double pi = 3.14159;
int arrondi = (int)pi;  // arrondi = 3 (troncature)

Méthodes de conversion

// String vers numérique
int n = int.Parse("42");
double d = double.Parse("3.14");

// Avec gestion d'erreur
bool ok = int.TryParse("abc", out int result);  // ok = false

// Classe Convert
int x = Convert.ToInt32("123");
string s = Convert.ToString(456);

5

Opérateurs

5. Opérateurs

5.1 Opérateurs arithmétiques

Opérateur	Description	Exemple	Résultat
+	Addition	5 + 3	8
-	Soustraction	5 - 3	2
*	Multiplication	5 * 3	15
/	Division	7 / 2	3 (entière)
%	Modulo (reste)	7 % 2	1
++	Incrémentation	x++	x = x + 1
--	Décrémentation	x--	x = x - 1

int a = 7, b = 2;
Console.WriteLine(a / b);   // Affiche 3 (division entière)
Console.WriteLine(a / 2.0); // Affiche 3.5 (division réelle)

5. Opérateurs

5.2 Opérateurs de comparaison et logiques

Comparaison

Op.	Description
==	Égal à
!=	Différent de
<	Inférieur à
>	Supérieur à
<=	Inférieur ou égal
>=	Supérieur ou égal

Logiques

Op.	Description
&&	ET logique
\|\|	OU logique
!	NON logique

int age = 20;
bool estMajeur = age >= 18;                    // true
bool peutConduire = estMajeur && age <= 70;   // true

5. Opérateurs

5.3 Opérateurs d'affectation

Opérateur	Exemple	Équivalent
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x - 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3

Opérateur ternaire

// condition ? valeur_si_vrai : valeur_si_faux
int age = 20;
string statut = age >= 18 ? "Majeur" : "Mineur";

6

Structures conditionnelles

6. Structures conditionnelles

6.1 L'instruction if / else

// if simple
if (condition)
{
    // Instructions si condition vraie
}

// if / else
if (condition)
{
    // Instructions si condition vraie
}
else
{
    // Instructions si condition fausse
}

// if / else if / else
if (condition1)
{
    // Instructions si condition1 vraie
}
else if (condition2)
{
    // Instructions si condition2 vraie
}
else
{
    // Instructions par défaut
}

6. Structures conditionnelles

6.1 Exemple : Classification de notes

int note = 15;
string mention;

if (note >= 16)
{
    mention = "Très Bien";
}
else if (note >= 14)
{
    mention = "Bien";
}
else if (note >= 12)
{
    mention = "Assez Bien";
}
else if (note >= 10)
{
    mention = "Passable";
}
else
{
    mention = "Insuffisant";
}

Console.WriteLine($"Mention : {mention}");  // Affiche : Mention : Bien

6. Structures conditionnelles

6.2 L'instruction switch

L'instruction switch permet de tester plusieurs valeurs d'une variable de manière plus lisible qu'une série de if/else.

switch (expression)
{
    case valeur1:
        // Instructions
        break;
    case valeur2:
        // Instructions
        break;
    case valeur3:
    case valeur4:
        // Instructions pour valeur3 OU valeur4
        break;
    default:
        // Instructions par défaut
        break;
}

Important : Le break est obligatoire à la fin de chaque case.

6. Structures conditionnelles

6.2 Exemple : Jour de la semaine

int jour = 3;
string nomJour;

switch (jour)
{
    case 1:
        nomJour = "Lundi";
        break;
    case 2:
        nomJour = "Mardi";
        break;
    case 3:
        nomJour = "Mercredi";
        break;
    case 4:
        nomJour = "Jeudi";
        break;
    case 5:
        nomJour = "Vendredi";
        break;
    case 6:
    case 7:
        nomJour = "Week-end";
        break;
    default:
        nomJour = "Invalide";
        break;
}

Console.WriteLine(nomJour);  // Affiche : Mercredi

7

Structures itératives (Boucles)

7. Structures itératives

7.1 La boucle for

La boucle for est utilisée quand le nombre d'itérations est connu à l'avance.

Syntaxe

for (initialisation; condition; incrémentation)
{
    // Instructions à répéter
}

Exemple : Afficher les nombres de 1 à 5

for (int i = 1; i <= 5; i++)
{
    Console.WriteLine(i);
}
// Affiche : 1 2 3 4 5 (sur des lignes séparées)

Exemple : Compte à rebours

for (int i = 10; i >= 0; i--)
{
    Console.WriteLine(i);
}

7. Structures itératives

7.2 La boucle while

La boucle while répète des instructions tant qu'une condition est vraie. La condition est testée avant chaque itération.

Syntaxe

while (condition)
{
    // Instructions à répéter
}

Exemple : Somme des nombres de 1 à 10

int somme = 0;
int compteur = 1;

while (compteur <= 10)
{
    somme += compteur;  // somme = somme + compteur
    compteur++;
}

Console.WriteLine($"Somme = {somme}");  // Affiche : Somme = 55

Attention : Risque de boucle infinie si la condition ne devient jamais fausse !

7. Structures itératives

7.3 La boucle do-while

La boucle do-while exécute les instructions au moins une fois, puis répète tant que la condition est vraie.

Syntaxe

do
{
    // Instructions à répéter
}
while (condition);

Exemple : Validation de saisie

int nombre;
do
{
    Console.Write("Entrez un nombre positif : ");
    nombre = int.Parse(Console.ReadLine());
}
while (nombre <= 0);

Console.WriteLine($"Vous avez saisi : {nombre}");

Différence avec while

La boucle do-while garantit au moins une exécution du bloc, contrairement à while.

7. Structures itératives

7.4 La boucle foreach

La boucle foreach parcourt tous les éléments d'une collection sans gérer d'indice.

Syntaxe

foreach (type element in collection)
{
    // Utiliser element
}

Exemple : Parcourir un tableau

string[] prenoms = { "Alice", "Bob", "Charlie" };

foreach (string prenom in prenoms)
{
    Console.WriteLine($"Bonjour {prenom} !");
}
// Affiche :
// Bonjour Alice !
// Bonjour Bob !
// Bonjour Charlie !

Remarque : On ne peut pas modifier les éléments avec foreach.

7. Structures itératives

7.5 Instructions break et continue

break : sortir de la boucle

for (int i = 1; i <= 10; i++)
{
    if (i == 5)
        break;  // Sort de la boucle
    Console.WriteLine(i);
}
// Affiche : 1 2 3 4

continue : passer à l'itération suivante

for (int i = 1; i <= 5; i++)
{
    if (i == 3)
        continue;  // Saute l'itération
    Console.WriteLine(i);
}
// Affiche : 1 2 4 5 (pas de 3)

7. Structures itératives

7.6 Tableau comparatif des boucles

Boucle	Utilisation recommandée
`for`	Nombre d'itérations connu, besoin d'un compteur
`while`	Nombre d'itérations inconnu, condition testée au début
`do-while`	Au moins une exécution garantie, validation de saisie
`foreach`	Parcours de collection, pas besoin de l'indice

Conseil : Choisissez la boucle la plus adaptée au problème. Utilisez foreach pour parcourir des collections, for quand vous avez besoin de l'indice, et while/do-while pour les conditions complexes.

8

Tableaux et matrices

8. Tableaux et matrices

8.1 Tableaux unidimensionnels : Déclaration

Un tableau est une structure de données qui stocke une collection d'éléments de même type, accessibles par un indice.

Syntaxes de déclaration

// Déclaration puis allocation
int[] nombres;
nombres = new int[5];  // Tableau de 5 entiers (initialisés à 0)

// Déclaration et allocation
int[] ages = new int[3];

// Déclaration et initialisation
int[] notes = new int[] { 15, 12, 18, 14 };

// Syntaxe simplifiée
int[] scores = { 10, 20, 30 };

// Avec var
var prenoms = new string[] { "Ali", "Sara", "Omar" };

Important : Les indices commencent à 0.

8. Tableaux et matrices

8.1 Tableaux unidimensionnels : Manipulation

Accès aux éléments

int[] notes = { 15, 12, 18, 14, 16 };

// Lecture
int premiere = notes[0];   // 15
int derniere = notes[4];   // 16

// Modification
notes[2] = 20;             // Remplace 18 par 20

// Propriété Length
int taille = notes.Length;  // 5

Parcours avec for

for (int i = 0; i < notes.Length; i++)
{
    Console.WriteLine($"Note {i + 1} : {notes[i]}");
}

Parcours avec foreach

foreach (int note in notes)
{
    Console.WriteLine(note);
}

8. Tableaux et matrices

8.2 Tableaux bidimensionnels (Matrices)

Déclaration et initialisation

// Déclaration et allocation
int[,] matrice = new int[3, 4];  // 3 lignes, 4 colonnes

// Déclaration et initialisation
int[,] grille = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

Accès aux éléments

int element = grille[1, 2];  // Ligne 1, Colonne 2 → 6
grille[0, 0] = 10;            // Modifie le premier élément

// Dimensions
int lignes = grille.GetLength(0);    // 3
int colonnes = grille.GetLength(1);  // 3

8. Tableaux et matrices

8.2 Parcours d'une matrice

int[,] matrice = {
    { 1, 2, 3 },
    { 4, 5, 6 }
};

// Parcours avec boucles imbriquées
for (int i = 0; i < matrice.GetLength(0); i++)  // Lignes
{
    for (int j = 0; j < matrice.GetLength(1); j++)  // Colonnes
    {
        Console.Write(matrice[i, j] + " ");
    }
    Console.WriteLine();  // Retour à la ligne
}

/* Affiche :
   1 2 3 
   4 5 6 
*/

Rappel : GetLength(0) = nombre de lignes, GetLength(1) = nombre de colonnes

8. Tableaux et matrices

8.3 Tableaux en escalier (Jagged Arrays)

Un tableau en escalier est un tableau de tableaux où chaque ligne peut avoir une taille différente.

// Déclaration
int[][] escalier = new int[3][];

// Allocation de chaque ligne
escalier[0] = new int[] { 1, 2 };
escalier[1] = new int[] { 3, 4, 5 };
escalier[2] = new int[] { 6 };

// Accès
int element = escalier[1][2];  // 5

// Parcours
for (int i = 0; i < escalier.Length; i++)
{
    for (int j = 0; j < escalier[i].Length; j++)
    {
        Console.Write(escalier[i][j] + " ");
    }
    Console.WriteLine();
}

★

Exercices d'application

Exercice 1 : Analyse de code

Déterminez la sortie de chaque programme :

Question 1.1

int x = 10, y = 3;
Console.WriteLine(x / y);
Console.WriteLine(x % y);
Console.WriteLine(x / (double)y);

Question 1.2

int a = 5;
int b = a++;
int c = ++a;
Console.WriteLine($"a={a}, b={b}, c={c}");

Question 1.3

bool test = (5 > 3) && (10 < 8) || !(2 == 2);
Console.WriteLine(test);

Exercices d'application

Exercice 2 : Correction d'erreurs

Identifiez et corrigez les erreurs dans ce code :

using System

namespace MonApp
{
    class Program
    {
        static void main(string[] args)
        {
            int 2nombre = 10;
            Double prix = 19,99;
            string message = 'Bonjour';
            var x;
            const pi = 3.14;
            
            Console.Writeline(message);
        }
    }
}

Indice : Il y a 8 erreurs à trouver.

Exercices d'application

Exercice 3 : Structures conditionnelles

Question 3.1

Écrivez un code qui détermine si un nombre est positif, négatif ou nul.

Question 3.2

Écrivez un code qui affiche le nom du mois correspondant à un numéro (1-12) en utilisant switch.

Question 3.3 - Traçage

Déterminez la valeur finale de resultat :

int x = 15;
string resultat;
if (x < 10)
    resultat = "A";
else if (x < 20)
    resultat = "B";
else
    resultat = "C";
resultat += x > 12 ? "-Plus" : "-Moins";

Exercices d'application

Exercice 4 : Boucles

Question 4.1 - Traçage

Déterminez la sortie :

for (int i = 0; i < 5; i++)
{
    if (i == 2) continue;
    if (i == 4) break;
    Console.Write(i + " ");
}

Question 4.2

Écrivez une boucle while qui calcule la somme des entiers de 1 à N.

Question 4.3

Écrivez une boucle for qui affiche tous les nombres pairs de 2 à 20.

Question 4.4

Écrivez une boucle do-while qui demande un mot de passe jusqu'à ce que l'utilisateur entre "secret".

Exercices d'application

Exercice 5 : Tableaux

Question 5.1 - Traçage

Déterminez la sortie :

int[] tab = { 3, 7, 2, 9, 5 };
int somme = 0;
for (int i = 0; i < tab.Length; i += 2)
{
    somme += tab[i];
}
Console.WriteLine(somme);

Question 5.2

Écrivez un code qui trouve et affiche le maximum d'un tableau d'entiers.

Question 5.3

Écrivez un code qui inverse l'ordre des éléments d'un tableau.

Exercices d'application

Exercice 6 : Matrices

Question 6.1 - Traçage

Déterminez la sortie :

int[,] m = { {1,2,3}, {4,5,6} };
int total = 0;
for (int i = 0; i < m.GetLength(0); i++)
{
    total += m[i, i];
}
Console.WriteLine(total);

Question 6.2

Écrivez un code qui calcule la somme de chaque ligne d'une matrice 3×3.

Question 6.3

Écrivez un code qui calcule la somme des éléments de la diagonale principale d'une matrice carrée N×N.

Résumé du chapitre

Concepts fondamentaux

Structure d'un programme C#
Types primitifs et conversions
Variables et constantes
Opérateurs

Structures de contrôle

if / else if / else
switch / case
for, while, do-while, foreach
break, continue

Collections

Tableaux unidimensionnels
Matrices (tableaux 2D)
Tableaux en escalier

Prochain chapitre

Programmation orientée objet
Classes et objets
Encapsulation
Constructeurs

Fin du Chapitre 1

Questions ?

Enseignant : Boubaker KHMILI

ISAE Gafsa - 2026/2027