Menu

Formation C#

Apprenez C#, un langage de programmation moderne et puissant

Faire un don

Créez un compte gratuitement

Suivez votre progression, sauvegardez vos avancées et obtenez des certificats de complétion. Rejoignez des milliers d'apprenants qui développent leurs compétences avec nous !

Suivi de progression détaillé
Certificats téléchargeables
Badges et accomplissements

Introduction à C#

C# est un langage de programmation orienté objet moderne, développé par Microsoft en 2000. C# fait partie de la plateforme .NET et est utilisé pour développer des applications Windows, web, mobiles et cloud.

⚙️ Qu'est-ce que C# ?

C# est un langage de programmation orienté objet, type-safe, et géré (managed). C# est compilé en bytecode qui s'exécute sur la machine virtuelle .NET (CLR).

💡 Pourquoi C# est si important ?

  1. Écosystème .NET - Accès à une vaste bibliothèque de frameworks et outils
  2. Multi-plateforme - .NET Core permet le développement cross-platform
  3. Productivité - Syntaxe moderne et fonctionnalités avancées (LINQ, async/await)
  4. Industrie - Très utilisé dans le développement d'applications d'entreprise
  5. Unity - Langage principal pour le développement de jeux avec Unity
  6. Microsoft - Supporté et développé activement par Microsoft

🚀 Pourquoi apprendre C# ?

C# est un langage moderne et polyvalent qui offre de nombreuses opportunités professionnelles. Voici pourquoi vous devriez apprendre C# :

  • ✅ Applications Windows - Développement d'applications desktop modernes
  • ✅ Développement web - ASP.NET Core pour applications web performantes
  • ✅ Jeux vidéo - Unity utilise C# comme langage principal
  • ✅ Mobile - Xamarin permet le développement mobile cross-platform
  • ✅ Cloud - Azure et services cloud Microsoft
  • ✅ Carrière - Très demandé dans l'industrie, particulièrement pour les applications d'entreprise

📋 Prérequis pour apprendre C#

Pour apprendre C# efficacement, il est recommandé d'avoir une base en programmation (variables, conditions, boucles).

  • ✅ Base en programmation - Comprendre les concepts de base (variables, conditions, boucles)
  • ✅ Programmation orientée objet (optionnel) - Avoir des bases en OOP facilite l'apprentissage
  • ✅ Visual Studio ou VS Code - IDE recommandé pour développer en C#

💡 Note importante : Pour compiler du code C#, vous avez besoin de .NET SDK. Téléchargez-le depuis le site officiel de Microsoft. Visual Studio Code avec l'extension C# est également une excellente option.

🎯 Cas d'utilisation de C#

C# est utilisé dans de nombreux domaines :

  • 🖥️ Applications Windows - Développement d'applications desktop
  • 🌐 Développement web - ASP.NET Core pour applications web
  • 🎮 Jeux vidéo - Unity utilise C# comme langage principal
  • 📱 Mobile - Xamarin pour applications cross-platform
  • ☁️ Cloud - Azure et services cloud Microsoft
  • 💼 Applications d'entreprise - Solutions d'entreprise robustes
  • 🔧 API et services - Développement d'API REST
  • 🤖 Machine Learning - ML.NET pour l'apprentissage automatique

📝 Syntaxe de base

C# est un langage de programmation orienté objet. C# utilise des accolades {} pour définir les blocs de code et nécessite un point-virgule ; à la fin de chaque instruction.

// Premier programme C#
using System;

class Program {
    static void Main() {
        Console.WriteLine("Bonjour, monde !");
        
        // Variables
        int age = 25;
        string nom = "NiangProgrammeur";
        
        // Affichage formaté
        Console.WriteLine($"Je m'appelle {nom} et j'ai {age} ans");
        
        // Opérations simples
        int resultat = 10 + 5;
        Console.WriteLine($"10 + 5 = {resultat}");
    }
}

💡 Points importants sur la syntaxe C# :

  • C# utilise des accolades {} pour définir les blocs de code
  • Les commentaires utilisent // pour une ligne ou /* */ pour plusieurs lignes
  • Point-virgule requis ; à la fin de chaque instruction
  • Les chaînes utilisent des guillemets doubles "
  • Chaque programme C# a une classe avec une méthode Main()
  • Les noms de classes commencent par une majuscule (convention PascalCase)

🔍 Exemple de syntaxe détaillée

Voici un exemple complet montrant plusieurs aspects de la syntaxe C# :

using System;

// Définition d'une méthode
static double CalculerMoyenne(int[] nombres) {
    if (nombres.Length == 0) {
        return 0;
    }
    int somme = 0;
    foreach (int n in nombres) {
        somme += n;
    }
    return (double)somme / nombres.Length;
}

// Méthode principale
class Program {
    static void Main() {
        int[] notes = {15, 18, 12, 20, 16};
        double moyenne = CalculerMoyenne(notes);
        Console.WriteLine($"La moyenne est : {moyenne}");
    }
}

🔤 Variables

En C#, les variables peuvent être déclarées avec un type explicite ou avec var (inférence de type). C# est un langage à typage statique.

using System;

class Program {
    static void Main() {
        // Déclaration de variables
        int age = 30;                    // Entier
        float prix = 19.99f;             // Nombre décimal (simple précision)
        double decimalValue = 3.14159;   // Nombre décimal (double précision)
        char lettre = 'A';               // Caractère unique
        string nom = "C#";                // Chaîne de caractères
        
        // Affichage avec Console.WriteLine
        Console.WriteLine($"Age: {age}");
        Console.WriteLine($"Prix: {prix:F2}");
        Console.WriteLine($"Decimal: {decimalValue}");
        Console.WriteLine($"Lettre: {lettre}");
        Console.WriteLine($"Nom: {nom}");
        
        // Déclaration puis assignation
        int nombre;
        nombre = 10;
        Console.WriteLine($"Nombre: {nombre}");
        
        // Constantes avec const
        const double PI = 3.14159;
        const int MAX_SIZE = 100;
        const int TAILLE = 50;
        const string MESSAGE = "Bonjour";
        
        // Noms de variables valides
        int ageUtilisateur = 25;
        string nomUtilisateur = "Bassirou";
        float _prive = 3.14f;  // Possible mais non recommandé
        
        // Inférence de type avec var
        var nombre2 = 42;
        var texte = "Hello";
    }
}

📌 Règles pour les noms de variables :

  • Doivent commencer par une lettre ou un underscore _
  • Peuvent contenir des lettres, chiffres et underscores
  • Ne peuvent pas contenir d'espaces ou de caractères spéciaux
  • Sont sensibles à la casse (age ≠ Age)
  • Ne peuvent pas être des mots-clés C# (if, for, int, class, etc.)
  • Convention : utilisez camelCase pour les variables et PascalCase pour les classes

📊 Types de données

C# a plusieurs types de données de base (primitifs). Voici les principaux types disponibles en C# :

using System;

class Program {
    static void Main() {
        // Types entiers
        char c = 'A';              // 16 bits (Unicode)
        short s = 100;              // 16 bits
        int i = 1000;               // 32 bits
        long l = 100000L;           // 64 bits
        
        // Types entiers non signés
        byte b = 200;               // 8 bits (0 à 255)
        ushort us = 5000;           // 16 bits non signés
        uint ui = 5000U;            // 32 bits non signés
        ulong ul = 100000UL;        // 64 bits non signés
        
        // Types décimaux
        float f = 3.14f;            // 32 bits (simple précision)
        double d = 3.14159;         // 64 bits (double précision)
        decimal dec = 3.141592653589793m;  // 128 bits (haute précision)
        
        // Type booléen
        bool estVrai = true;
        bool estFaux = false;
        
        // Chaînes de caractères
        string chaine = "Hello";    // Chaîne de caractères
        string texte = "World";     // Chaîne de caractères
        
        // Affichage avec Console.WriteLine
        Console.WriteLine($"char: {c}");
        Console.WriteLine($"int: {i}");
        Console.WriteLine($"float: {f:F2}");
        Console.WriteLine($"double: {d}");
        Console.WriteLine($"bool: {estVrai}");
        Console.WriteLine($"chaine: {chaine}");
        
        // Taille des types (en octets)
        Console.WriteLine($"Taille de int: {sizeof(int)} octets");
        Console.WriteLine($"Taille de float: {sizeof(float)} octets");
        Console.WriteLine($"Taille de double: {sizeof(double)} octets");
    }
}

📚 Types de données C# :

  • int - Entier (4 octets)
  • float - Nombre décimal simple précision (4 octets)
  • double - Nombre décimal double précision (8 octets)
  • decimal - Nombre décimal haute précision (16 octets)
  • char - Caractère (2 octets, Unicode)
  • string - Chaîne de caractères
  • bool - Booléen (true/false)
  • byte - Octet non signé (0 à 255)
  • object - Type de base pour tous les types

🔢 Opérateurs

C# supporte les opérateurs arithmétiques, de comparaison, logiques, d'assignation et de pointeurs :

using System;

class Program {
    static void Main() {
        int a = 10, b = 3;
        
        // Opérateurs arithmétiques
        Console.WriteLine($"{a} + {b} = {a + b}");      // Addition: 13
        Console.WriteLine($"{a} - {b} = {a - b}");      // Soustraction: 7
        Console.WriteLine($"{a} * {b} = {a * b}");      // Multiplication: 30
        Console.WriteLine($"{a} / {b} = {a / b}");      // Division entière: 3
        Console.WriteLine($"{a} % {b} = {a % b}");      // Modulo (reste): 1
        
        // Division avec double
        double resultat = (double)a / b;
        Console.WriteLine($"{a} / {b} = {resultat:F2}"); // Division: 3.33
        
        // Puissance (nécessite System.Math)
        double puissance = Math.Pow(a, b);
        Console.WriteLine($"{a}^{b} = {puissance:F0}");  // Puissance: 1000
        
        // Opérateurs de comparaison
        Console.WriteLine($"{a} > {b} = {a > b}");      // true
        Console.WriteLine($"{a} < {b} = {a < b}");      // false
        Console.WriteLine($"{a} >= {b} = {a >= b}");    // true
        Console.WriteLine($"{a} <= {b} = {a <= b}");    // false
        Console.WriteLine($"{a} == {b} = {a == b}");     // false
        Console.WriteLine($"{a} != {b} = {a != b}");    // true
        
        // Opérateurs logiques
        bool x = true, y = false;
        Console.WriteLine($"{x} && {y} = {x && y}");    // ET logique: false
        Console.WriteLine($"{x} || {y} = {x || y}");    // OU logique: true
        Console.WriteLine($"!{x} = {!x}");              // NON logique: false
        
        // Opérateurs d'assignation
        int c = 5;
        c += 3;  // Équivalent à c = c + 3 (c devient 8)
        c -= 2;  // Équivalent à c = c - 2 (c devient 6)
        c *= 2;  // Équivalent à c = c * 2 (c devient 12)
        c /= 3;  // Équivalent à c = c / 3 (c devient 4)
        c %= 3;  // Équivalent à c = c % 3 (c devient 1)
        
        // Opérateurs d'incrémentation/décrémentation
        int i = 5;
        Console.WriteLine($"i = {i++}");  // Post-incrémentation: affiche 5, puis i = 6
        Console.WriteLine($"i = {++i}");  // Pré-incrémentation: i = 7, puis affiche 7
    }
}

🔀 Structures conditionnelles

Le langage C# utilise if, else if et else pour les conditions. Les blocs de code sont délimités par des accolades {}.

using System;

class Program {
    static void Main() {
        // Structure if simple
        int age = 20;
        
        if (age >= 18) {
            Console.WriteLine("Vous êtes majeur");
        } else {
            Console.WriteLine("Vous êtes mineur");
        }
        
        // Structure if/else if/else
        age = 15;
        
        if (age >= 18) {
            Console.WriteLine("Vous êtes majeur");
            Console.WriteLine("Vous pouvez voter");
        } else if (age >= 13) {
            Console.WriteLine("Vous êtes adolescent");
        } else if (age >= 6) {
            Console.WriteLine("Vous êtes enfant");
        } else {
            Console.WriteLine("Vous êtes un bébé");
        }
        
        // Conditions multiples
        int note = 85;
        string mention;
        
        if (note >= 90) {
            mention = "Excellent";
        } else if (note >= 80) {
            mention = "Très bien";
        } else if (note >= 70) {
            mention = "Bien";
        } else if (note >= 60) {
            mention = "Assez bien";
        } else {
            mention = "Insuffisant";
        }
        
        Console.WriteLine($"Votre mention : {mention}");
        
        // Opérateur ternaire (expression conditionnelle)
        age = 20;
        string statut = age >= 18 ? "Majeur" : "Mineur";
        Console.WriteLine(statut);
        
        // Conditions avec &&/||
        age = 25;
        bool permis = true;
        
        if (age >= 18 && permis) {
            Console.WriteLine("Vous pouvez conduire");
        } else {
            Console.WriteLine("Vous ne pouvez pas conduire");
        }
    }
}

🔄 Boucles

Le langage C# propose plusieurs types de boucles : for (pour itérer un nombre défini de fois), while (pour répéter tant qu'une condition est vraie), do-while (exécute au moins une fois) et foreach (pour parcourir des collections) :

using System;

class Program {
    static void Main() {
        // Boucle for
        for (int i = 0; i < 5; i++) {
            Console.WriteLine(i);  // Affiche 0, 1, 2, 3, 4
        }
        
        // for avec début et fin
        for (int i = 1; i <= 5; i++) {
            Console.WriteLine(i);  // Affiche 1, 2, 3, 4, 5
        }
        
        // for avec pas
        for (int i = 0; i < 10; i += 2) {
            Console.WriteLine(i);  // Affiche 0, 2, 4, 6, 8
        }
        
        // Boucle foreach avec liste
        string[] fruits = {"pomme", "banane", "orange"};
        foreach (string fruit in fruits) {
            Console.WriteLine($"J'aime les {fruit}");
        }
        
        // Boucle for avec index
        string[] fruits2 = {"pomme", "banane", "orange"};
        for (int index = 0; index < fruits2.Length; index++) {
            Console.WriteLine($"{index}: {fruits2[index]}");
        }
        
        // Boucle while
        int compteur = 0;
        while (compteur < 5) {
            Console.WriteLine(compteur);
            compteur++;
        }
        
        // Boucle while avec break
        compteur = 0;
        while (true) {
            Console.WriteLine(compteur);
            compteur++;
            if (compteur >= 5) {
                break;  // Sortir de la boucle
            }
        }
        
        // continue (passer à l'itération suivante)
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {  // Si i est pair
                continue;      // Passer au suivant
            }
            Console.WriteLine(i);  // Affiche seulement les impairs: 1, 3, 5, 7, 9
        }
        
        // Boucle do-while
        int j = 0;
        do {
            Console.WriteLine(j);
            j++;
        } while (j < 5);
    }
}

⚙️ Méthodes

Les méthodes permettent de réutiliser du code. En C#, on définit une méthode avec son type de retour, son nom et ses paramètres. Les méthodes peuvent prendre des paramètres et retourner des valeurs avec return.

using System;

class Program {
    // Méthode simple (sans paramètres)
    static void DireBonjour() {
        Console.WriteLine("Bonjour !");
    }
    
    // Méthode avec paramètres
    static string Saluer(string nom) {
        return $"Bonjour, {nom} !";
    }
    
    // Méthode avec plusieurs paramètres
    static int Additionner(int a, int b) {
        return a + b;
    }
    
    // Méthode avec paramètres par défaut
    static string SaluerPersonne(string nom, string message = "Bonjour") {
        return $"{message}, {nom} !";
    }
    
    // Méthode avec params (arguments variables)
    static int AdditionnerNombres(params int[] nombres) {
        int somme = 0;
        foreach (int n in nombres) {
            somme += n;
        }
        return somme;
    }
    
    static void Main() {
        DireBonjour();  // Appel de la méthode
        
        string message = Saluer("C#");
        Console.WriteLine(message);  // "Bonjour, C# !"
        
        int resultat = Additionner(5, 3);
        Console.WriteLine(resultat);  // 8
        
        Console.WriteLine(SaluerPersonne("Bassirou"));              // "Bonjour, Bassirou !"
        Console.WriteLine(SaluerPersonne("Bassirou", "Salut"));     // "Salut, Bassirou !"
        
        Console.WriteLine(AdditionnerNombres(1, 2, 3, 4, 5));  // 15
    }

    }
}

🏛️ Classes et objets

En C#, tout est orienté objet. Les classes permettent de créer des types personnalisés avec des propriétés et des méthodes.

using System;

// Définition d'une classe
public class Personne {
    // Propriétés
    public string Nom { get; set; }
    public int Age { get; set; }
    public double Taille { get; set; }
    
    // Constructeur
    public Personne(string nom, int age, double taille) {
        Nom = nom;
        Age = age;
        Taille = taille;
    }
    
    // Méthode
    public void Afficher() {
        Console.WriteLine($"Nom: {Nom}, Age: {Age}, Taille: {Taille}m");
    }
}

class Program {
    static void Main() {
        // Création d'objets
        Personne p1 = new Personne("Bassirou", 25, 1.75);
        Personne p2 = new Personne("Aminata", 30, 1.65);
        
        p1.Afficher();
        p2.Afficher();
    }
}

📦 Collections

C# offre plusieurs types de collections : List, Dictionary, HashSet, Queue, Stack, etc.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        // List - Liste dynamique
        List nombres = new List {1, 2, 3, 4, 5};
        nombres.Add(6);
        nombres.Remove(3);
        
        foreach (int n in nombres) {
            Console.WriteLine(n);
        }
        
        // Dictionary - Dictionnaire clé-valeur
        Dictionary ages = new Dictionary();
        ages["Bassirou"] = 25;
        ages["Aminata"] = 30;
        
        foreach (var kvp in ages) {
            Console.WriteLine($"{kvp.Key}: {kvp.Value} ans");
        }
        
        // HashSet - Ensemble unique
        HashSet noms = new HashSet {"Alice", "Bob", "Alice"};
        Console.WriteLine($"Nombre d'éléments: {noms.Count}"); // 2 (Alice en double)
    }
}

🔗 Héritage

L'héritage permet à une classe de dériver d'une autre classe et d'hériter de ses membres.

using System;

// Classe de base
public class Animal {
    public string Nom { get; set; }
    
    public virtual void FaireDuBruit() {
        Console.WriteLine($"{Nom} fait un bruit");
    }
}

// Classe dérivée
public class Chien : Animal {
    public Chien(string nom) {
        Nom = nom;
    }
    
    public override void FaireDuBruit() {
        Console.WriteLine($"{Nom} aboie");
    }
}

class Program {
    static void Main() {
        Chien chien = new Chien("Rex");
        chien.FaireDuBruit(); // "Rex aboie"
    }
}

🔌 Interfaces

Les interfaces définissent un contrat que les classes doivent implémenter. Une classe peut implémenter plusieurs interfaces.

using System;

// Définition d'une interface
public interface IVoler {
    void Voler();
}

public interface INager {
    void Nager();
}

// Classe implémentant plusieurs interfaces
public class Canard : IVoler, INager {
    public void Voler() {
        Console.WriteLine("Le canard vole");
    }
    
    public void Nager() {
        Console.WriteLine("Le canard nage");
    }
}

class Program {
    static void Main() {
        Canard canard = new Canard();
        canard.Voler();
        canard.Nager();
    }
}

🔍 LINQ (Language Integrated Query)

LINQ permet d'interroger des collections de manière déclarative et expressive.

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    static void Main() {
        List nombres = new List {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        // Filtrer les nombres pairs
        var pairs = nombres.Where(n => n % 2 == 0);
        
        // Calculer la somme
        int somme = nombres.Sum();
        
        // Trouver le maximum
        int max = nombres.Max();
        
        // Trier
        var trie = nombres.OrderByDescending(n => n);
        
        // Sélectionner et transformer
        var carres = nombres.Select(n => n * n);
        
        Console.WriteLine($"Somme: {somme}, Max: {max}");
    }
}

⚡ Programmation asynchrone

C# supporte la programmation asynchrone avec async/await pour les opérations non-bloquantes.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        await TéléchargerDonnées();
    }
    
    static async Task TéléchargerDonnées() {
        using (HttpClient client = new HttpClient()) {
            string resultat = await client.GetStringAsync("https://api.example.com/data");
            Console.WriteLine(resultat);
        }
    }
}

💡 Note importante : C# utilise un garbage collector (GC) pour gérer automatiquement la mémoire. Vous n'avez pas besoin de libérer manuellement la mémoire comme en C/C++. Le GC s'occupe de libérer les objets non utilisés automatiquement.

🎓 Prochaines étapes

Félicitations ! Vous avez maintenant une solide base en C#.

✅ Ce que vous avez appris :

  • Syntaxe C# et variables
  • Types de données (int, float, double, string, bool)
  • Opérateurs (arithmétiques, comparaison, logiques)
  • Structures conditionnelles (if, else if, else, switch)
  • Boucles (for, while, do-while, foreach)
  • Méthodes (définition, paramètres, return)
  • Classes et objets (encapsulation, constructeurs)
  • Héritage et interfaces
  • Collections (List, Dictionary, etc.)
  • LINQ et async/await

🚀 Pour aller plus loin :

  • 📚 ASP.NET Core - Développement web avec C#
  • 🔧 Entity Framework - ORM pour bases de données
  • 📦 NuGet - Gestionnaire de packages .NET
  • 🌐 API REST - Création d'API avec ASP.NET Core
  • 📊 LINQ avancé - Requêtes complexes
  • 🤖 Unity - Développement de jeux avec C#
❮ Précédent: C++ Pratiquer avec des exercices ❯
Cliquer pour discuter avec NiangProgrammeur
NiangProgrammeur
En ligne

Bonjour ! 👋

Comment puis-je vous aider aujourd'hui ?

Ouvrir WhatsApp