Modificateurs d'accès et portée

1. Les principaux modificateurs d'accès en C#

Quand tu codes, t'as souvent envie de contrôler clairement qui et d'où peut voir ou modifier tes variables et appeler tes méthodes. C'est un peu comme dans un immeuble : toutes les pièces ne sont pas ouvertes à tout le monde. Certaines sont accessibles qu'aux résidents, d'autres seulement aux techniciens.

En programmation, ce "contrôle d'accès" se fait via les modificateurs d'accès. Ils définissent si un membre de classe (variable, champ, méthode, propriété, etc.) est visible en dehors de la classe, dans une autre classe, dans un autre projet. C'est une des principales façons de faire de l'encapsulation en POO : on cache les détails d'implémentation, on expose juste ce qu'il faut comme "interfaces" vers l'extérieur.

Voilà un petit tableau avec les modificateurs principaux et une courte description :

public

private

(pas de modificateur)

Ça fait peur ? En vrai, c'est pas si compliqué. On va voir des exemples pour piger où utiliser quoi.

2. Modificateur public — accès libre pour tous

Le modificateur public rend ta variable ou ta méthode visible partout. Si tu déclares un membre de classe public, tu peux y accéder depuis n'importe quel autre code qui voit ta classe.

public class Person
{
    public string Name;
    public void SayHello()
    {
        Console.WriteLine($"Salut ! Je m'appelle {Name}");
    }
}

Maintenant, n'importe où (dans le même projet ou même ailleurs si tu ajoutes une référence à l'assembly), tu peux écrire :

Person p = new Person();
p.Name = "Alice";
p.SayHello();

Petit conseil : évite de tout mettre en public : c'est la base pour garder ton code safe.

3. Modificateur private — c'est privé !

Le modificateur private ferme l'accès au contenu de la classe : personne dehors ne verra ce qu'il y a dedans, ni ne pourra modifier les données. Par défaut, tous les champs et méthodes des classes en C# sont private, sauf si tu mets un autre modificateur.

public class Cup
{
    private double volume; // Ce champ est visible seulement par la classe Cup

    public void Fill(double value)
    {
        volume = value; // Utilisable à l'intérieur de la classe
    }

    public double GetVolume()
    {
        return volume; // Mais dehors, personne ne sait que volume existe
    }
}

Ici, volume est caché de tout le monde, mais n'importe quelle méthode dans Cup peut l'utiliser. Pour connaître le volume, on fournit une méthode publique GetVolume().

4. Portée : variables, méthodes et classes

La portée — c'est la zone du programme où ton nom (variable, méthode, classe) a du sens et est accessible.

• Variables locales (déclarées dans une méthode ou un bloc de code) : visibles seulement dans cette méthode ou ce bloc.
• Paramètres de méthodes : visibles seulement à l'intérieur de la méthode.
• Champs de classe : visibles partout dans la classe (selon le modificateur d'accès).
• Classes : une classe imbriquée est visible seulement dans la classe englobante si elle est private, etc.

Regarde un exemple de portée :

public class Counter
{
    private int count = 0; // visible partout dans la classe

    public void Increment()
    {
        count++;   // on peut utiliser le champ
        int temp = count * 2; // temp est visible seulement dans Increment
    }

    public int GetCount()
    {
        // temp n'est pas visible ici !
        return count;
    }
}

Si tu essaies d'accéder à temp dans GetCount() — tu vas avoir une erreur.

5. Shadowing des variables

Le shadowing — c'est quand, dans une portée, tu déclares une variable (ou un paramètre) avec le même nom qu'une variable dans une portée extérieure. Dans ce bloc, le “nouveau” nom masque l'ancien, et tu ne peux plus accéder directement à la valeur extérieure.

Exemple de shadowing :

class ShadowDemo
{
    int value = 10; // champ de classe

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 — champ de classe
        int value = 5; // variable locale masque le champ de classe
        Console.WriteLine(value); // affiche 5, pas 10
    }
}

Dans cet exemple, quand on écrit int value = 5;, ça masque le champ de classe du même nom dans la méthode. Quand tu utilises value dans PrintValue(), c'est la variable locale qui est utilisée, pas le champ de classe.

Si tu veux quand même accéder au champ de classe, tu utilises le mot-clé this :

class ShadowDemo
{
    int value = 10;

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 — champ de classe
        int value = 5;
        Console.WriteLine(value);      // 5 — variable locale
        Console.WriteLine(this.value); // 10 — champ de classe
    }
}

Le shadowing peut embrouiller, donc c'est mieux de donner des noms clairs et différents aux variables — surtout si tu bosses dans une grosse équipe.

1

Étude/Quiz

Fonctions, niveau 8, leçon 5

Indisponible

Fonctions

Introduction aux fonctions

Ouvrir