C# - Encapsulation: A Beginner's Guide

Bonjour là, future superstar du codage ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde du C# et explorer l'un de ses concepts fondamentaux : l'encapsulation. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - je suis là pour vous guider à chaque étape. Alors, plongeons dedans !

C# - Encapsulation

Qu'est-ce que l'encapsulation ?

Avant de rentrer dans les détails, comprenstons ce qu'est l'encapsulation. Imaginez que vous avez une boîte magique qui peut faire des choses incroyables, mais vous n'avez pas besoin de savoir comment elle fonctionne à l'intérieur - vous avez juste besoin de savoir comment l'utiliser. Voilà, en substance, ce qu'est l'encapsulation !

En C#, l'encapsulation consiste à regrouper des données (variables) et les méthodes qui opèrent sur ces données au sein d'une unité ou d'un objet unique. C'est comme créer une capsule protectrice autour de votre code, d'où le nom "encapsulation".

Maintenant, explorons comment le C# met en œuvre l'encapsulation à travers les spécificateurs d'accès.

Spécificateurs d'accès en C

Les spécificateurs d'accès sont des mots-clés qui définissent l'accessibilité d'une classe, d'une méthode ou d'une propriété dans votre code. Pensez-y comme à différents niveaux de sécurité. Le C# fournit cinq principaux spécificateurs d'accès :

Public
Privé
Protégé
Interne
Protégé Interne

Reprenons-les un par un.

Spécificateur d'accès Public

Le mot-clé public est comme un "pass d'accès total". Lorsque vous déclarez un membre comme public, il peut être accessible depuis n'importe quelle partie de votre programme.

public class Personne
{
public string Nom { get; set; }

public void DireBonjour()
{
Console.WriteLine($"Bonjour, mon nom est {Nom}!");
}
}

class Program
{
static void Main(string[] args)
{
Personne personne = new Personne();
personne.Nom = "Alice";  // Accès à une propriété publique
personne.DireBonjour();  // Appel d'une méthode publique
}
}

Dans cet exemple, Nom et DireBonjour() sont publics, donc nous pouvons y accéder directement depuis la méthode Main.

Spécificateur d'accès Privé

Maintenant, private est comme une zone "personnel du personnel". Les membres privés ne peuvent être accessibles que dans la même classe.

public class CompteBancaire
{
private double solde;

public void Déposer(double montant)
{
if (montant > 0)
{
solde += montant;
}
}

public double GetSolde()
{
return solde;
}
}

class Program
{
static void Main(string[] args)
{
CompteBancaire compte = new CompteBancaire();
compte.Déposer(100);
// compte.solde = 1000000;  // Cela provoquerait une erreur !
Console.WriteLine($"Solde : {compte.GetSolde()}");
}
}

Ici, solde est privé, donc nous ne pouvons pas y accéder directement depuis l'extérieur de la classe CompteBancaire. Nous devons utiliser des méthodes publiques comme Déposer() et GetSolde() pour interagir avec elle.

Spécificateur d'accès Protégé

Les membres protected sont accessibles à l'intérieur de la même classe et par les classes dérivées. C'est comme une section "réservée à la famille".

public class Animal
{
protected string nom;

public Animal(string nom)
{
this.nom = nom;
}

protected void Manger()
{
Console.WriteLine($"{nom} mange.");
}
}

public class Chien : Animal
{
public Chien(string nom) : base(nom) { }

public void Aboyer()
{
Console.WriteLine($"{nom} aboie !");  // Peut accéder au membre protégé
Manger();  // Peut appeler la méthode protégée
}
}

class Program
{
static void Main(string[] args)
{
Chien chien = new Chien("Buddy");
chien.Aboyer();
// chien.nom = "Max";  // Cela provoquerait une erreur !
// chien.Manger();  // Cela provoquerait également une erreur !
}
}

Dans cet exemple, Chien peut accéder au nom protégé et à la méthode Manger() de sa classe parente Animal, mais nous ne pouvons pas y accéder directement depuis Main.

Spécificateur d'accès Interne

Les membres internal sont accessibles à l'intérieur du même assembly (pensez à un assembly comme un fichier compilé .dll ou .exe). C'est comme une zone "réservée aux employés de l'entreprise".

// Dans AssemblyOne.cs
internal class ClasseInterne
{
internal void MéthodeInterne()
{
Console.WriteLine("Ceci est une méthode interne.");
}
}

// Dans Program.cs (même assembly)
class Program
{
static void Main(string[] args)
{
ClasseInterne obj = new ClasseInterne();
obj.MéthodeInterne();  // Cela fonctionne !
}
}

// Dans un assembly différent, cela ne fonctionnerait pas :
// ClasseInterne obj = new ClasseInterne();  // Erreur !

Spécificateur d'accès Protégé Interne

Enfin, protected internal est une combinaison de protected et internal. Il est accessible à l'intérieur du même assembly ou par les classes dérivées dans d'autres assemblies.

// Dans AssemblyOne.cs
public class ClasseDeBase
{
protected internal void MéthodeProtégéeInterne()
{
Console.WriteLine("Ceci est une méthode protégée interne.");
}
}

// Dans AssemblyTwo.cs
public class ClasseDérivée : ClasseDeBase
{
public void AppelMéthodeProtégéeInterne()
{
MéthodeProtégéeInterne();  // Cela fonctionne !
}
}

// Dans Program.cs (AssemblyTwo)
class Program
{
static void Main(string[] args)
{
ClasseDérivée obj = new ClasseDérivée();
obj.AppelMéthodeProtégéeInterne();
// obj.MéthodeProtégéeInterne();  // Cela ne fonctionnerait pas !
}
}

Résumé des spécificateurs d'accès

Voici un tableau pratique résumant les niveaux d'accès :

Spécificateur d'accès	Même Classe	Classe Dérivée (Même Assembly)	Classe Non Dérivée (Même Assembly)	Classe Dérivée (Assembly Différent)	Classe Non Dérivée (Assembly Différent)
Public	Oui	Oui	Oui	Oui	Oui
Privé	Oui	Non	Non	Non	Non
Protégé	Oui	Oui	Non	Oui	Non
Interne	Oui	Oui	Oui	Non	Non
Protégé Interne	Oui	Oui	Oui	Oui	Non

Et voilà ! Vous avez maintenant fait vos premiers pas dans le monde de l'encapsulation en C#. Souvenez-vous, l'encapsulation consiste à contrôler l'accès à votre code et à vos données. Elle vous aide à écrire des programmes plus sécurisés, plus faciles à maintenir et plus flexibles.

Alors, continuez à vous entraîner, restez curieux, et bon codage !

Credits: Image by storyset