Modificateurs d'accès en C# : public, private, protected et internal

Les modificateurs d'accès déterminent quel code peut utiliser un type ou un membre. C'est ainsi qu'une classe sépare la partie sur laquelle s'appuie le reste du code (sa surface publique) de la partie qu'elle est libre de modifier (ses détails internes). C# en a six, plus les valeurs par défaut que vous obtenez quand vous n'en écrivez aucun.

Les six modificateurs

Un assembly est un projet compilé : le .dll ou le .exe qu'il produit. « Même assembly » signifie « même projet », c'est pourquoi internal fonctionne comme « visible pour mon code, caché pour les utilisateurs de ma bibliothèque ».

private et public : l'encapsulation

private est la valeur par défaut des membres et le bon choix pour la plupart des champs. La classe expose ce dont les appelants ont besoin via des méthodes et propriétés public, et ces méthodes gardent les données de l'objet cohérentes.

using System;

class Account
{
    private decimal balance;               // only Account can touch this
    private readonly string owner;

    public Account(string owner) { this.owner = owner; }

    public decimal Balance => balance;     // read-only view for everyone

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Deposit must be positive");
        balance += amount;
    }

    public bool TryWithdraw(decimal amount)
    {
        if (amount > balance) return false;
        balance -= amount;
        return true;
    }

    public override string ToString() => $"{owner}: {balance}";
}

class Program
{
    static void Main()
    {
        var acc = new Account("Priya");
        acc.Deposit(300m);
        Console.WriteLine(acc.TryWithdraw(500m));
        Console.WriteLine(acc.TryWithdraw(120m));
        Console.WriteLine(acc);
        // acc.balance = 1000000m; // error CS0122: 'Account.balance' is inaccessible due to its protection level
    }
}

Sortie :

False
True
Priya: 180

Comme balance est privé, les seuls moyens de le modifier sont Deposit et TryWithdraw, et les deux appliquent les règles. Aucun autre code du programme ne peut créer un solde négatif, quelle que soit la façon dont il est écrit. C'est ce qu'apporte l'encapsulation : les règles vivent à un seul endroit.

private s'applique par type, pas par objet. Une méthode d'Account peut lire other.balance sur une autre instance d'Account, et c'est ainsi que s'écrivent en général Equals et les méthodes de comparaison.

protected : visible pour les classes dérivées

Un membre protected est caché au monde extérieur mais disponible pour les classes qui héritent de la classe qui le déclare.

using System;

class Employee
{
    public string Name { get; }
    protected decimal baseSalary;

    public Employee(string name, decimal baseSalary)
    {
        Name = name;
        this.baseSalary = baseSalary;
    }

    public virtual decimal MonthlyPay() => baseSalary / 12;
}

class Manager : Employee
{
    private readonly int reports;

    public Manager(string name, decimal baseSalary, int reports) : base(name, baseSalary)
    {
        this.reports = reports;
    }

    // A derived class can read the protected field.
    public override decimal MonthlyPay() => baseSalary / 12 + reports * 100m;
}

class Program
{
    static void Main()
    {
        var staff = new Employee[]
        {
            new Employee("Sam", 48000m),
            new Manager("Rita", 72000m, 4),
        };

        foreach (var e in staff)
            Console.WriteLine($"{e.Name}: {e.MonthlyPay():F2}");

        // Console.WriteLine(staff[0].baseSalary); // error CS0122: inaccessible due to its protection level
    }
}

Sortie :

Sam: 4000.00
Rita: 6400.00

Une règle surprend. Dans Manager, vous pouvez utiliser baseSalary sur this ou sur un autre Manager, mais pas sur un Employee quelconque :

class Manager : Employee
{
    public decimal Compare(Employee other)
    {
        return baseSalary - other.baseSalary;
        // error CS1540: Cannot access protected member 'Employee.baseSalary' via a qualifier
        // of type 'Employee'; the qualifier must be of type 'Manager' (or derived from it)
    }
}

La raison : other pourrait être un Contractor qui dérive aussi d'Employee, et protected donne accès à votre propre branche de la hiérarchie, pas à celle de vos frères.

Un champ protégé lie pour toujours chaque classe dérivée à ce champ. Beaucoup de bases de code préfèrent une propriété ou une méthode protected, ou gardent les champs privés et ne donnent aux classes dérivées que ce dont elles ont besoin.

internal : visible dans l'assembly

Les membres et types internal peuvent être utilisés par n'importe quel code du même projet et par rien à l'extérieur. Une bibliothèque s'en sert pour les fonctions auxiliaires sur lesquelles reposent ses classes publiques :

// In the MyShop.Pricing library project
public class PriceCalculator
{
    public decimal Total(Cart cart) => TaxRules.Apply(cart.Subtotal);
}

internal static class TaxRules   // callers of the library cannot see this class
{
    internal static decimal Apply(decimal amount) => amount * 1.2m;
}

Les types de premier niveau sont internal quand vous n'écrivez aucun modificateur. C'est pourquoi une classe que vous avez oublié de marquer public dans une bibliothèque de classes « manque » dans le projet qui la référence.

Les projets de tests unitaires sont des assemblies séparés, ils ne peuvent donc pas voir le code internal non plus. La correction standard est un attribut dans la bibliothèque :

[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("MyShop.Pricing.Tests")]

protected internal et private protected

Ces deux modificateurs combinent les précédents, de façons opposées, et leurs noms se confondent facilement :

• protected internal signifie protected ou internal : tout code du même assembly, plus les classes dérivées d'autres assemblies. C'est le plus large des deux.
• private protected (C# 7.2) signifie protected et internal : seulement les classes dérivées qui sont aussi dans le même assembly. C'est le plus restreint, pour une classe de base dont les points d'extension doivent rester dans votre bibliothèque.

public class ReportBase
{
    protected internal string Title;      // same assembly, or subclasses anywhere
    private protected int RowLimit = 500; // subclasses in this assembly only (C# 7.2)
}

Valeurs par défaut quand vous n'écrivez rien

Être explicite coûte un mot et évite une question au lecteur suivant, c'est pourquoi la plupart des guides de style demandent le modificateur même quand il correspond à la valeur par défaut.

Accès au niveau des accesseurs

Une propriété ou un indexeur peut donner à l'un de ses accesseurs un modificateur plus restrictif que celui de la propriété elle-même :

using System;

class Download
{
    public string File { get; }
    public int Percent { get; private set; }

    public Download(string file) { File = file; }

    public void Advance(int step)
    {
        Percent = Math.Min(100, Percent + step);
    }
}

class Program
{
    static void Main()
    {
        var d = new Download("report.pdf");
        d.Advance(40);
        d.Advance(75);
        Console.WriteLine($"{d.File}: {d.Percent}%");
        // d.Percent = 5; // error CS0272: the set accessor is inaccessible
    }
}

Sortie :

report.pdf: 100%

Le modificateur de l'accesseur doit être plus restrictif que celui de la propriété, et un seul des deux accesseurs peut en avoir un.

Accessibilité incohérente

Un membre public ne peut pas exposer un type moins visible que lui, car les appelants recevraient quelque chose qu'ils n'ont pas le droit de nommer :

internal class Discount { }

public class Checkout
{
    public Discount Current() => null;
    // error CS0050: Inconsistent accessibility: return type 'Discount' is less accessible than method 'Checkout.Current()'
}

La même règle donne CS0051 pour les types de paramètres et CS0053 pour les types de propriétés. Corrigez en rendant le type aussi visible que le membre, ou le membre aussi caché que le type.

Choisir un modificateur

Commencez par le modificateur le plus restrictif qui fonctionne et n'élargissez que lorsqu'un appelant en a besoin. Rendre quelque chose plus visible plus tard est facile et ne casse jamais personne ; rendre quelque chose moins visible casse chaque appelant qui l'utilisait. En pratique : les champs private, les membres qui constituent la raison d'être de la classe public, les fonctions auxiliaires private, et les types propres à la bibliothèque internal.