Modificatori di accesso in C#: public, private, protected e internal

I modificatori di accesso decidono quale codice può usare un tipo o un membro. Sono il modo in cui una classe separa la parte su cui fa affidamento il resto del codice (la sua superficie pubblica) da quella che è libera di cambiare (i suoi dettagli interni). C# ne ha sei, più i valori predefiniti che ottieni quando non ne scrivi nessuno.

I sei modificatori

Un assembly è un progetto compilato: il .dll o .exe che produce. "Stesso assembly" significa "stesso progetto", ed è per questo che internal funziona come "visibile al mio codice, nascosto a chi usa la mia libreria".

private e public: l'incapsulamento

private è il valore predefinito per i membri e la scelta giusta per la maggior parte dei campi. La classe espone ciò che serve ai chiamanti tramite metodi e proprietà public, e quei metodi mantengono coerenti i dati dell'oggetto.

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
    }
}

Output:

False
True
Priya: 180

Dato che balance è privato, gli unici modi per modificarlo sono Deposit e TryWithdraw, ed entrambi fanno rispettare le regole. Nessun altro codice del programma può creare un saldo negativo, in qualunque modo sia scritto. Ecco cosa ti dà l'incapsulamento: le regole stanno in un solo posto.

private vale per tipo, non per oggetto. Un metodo di Account può leggere other.balance su un'altra istanza di Account, ed è così che di solito si scrivono Equals e i metodi di confronto.

protected: visibile alle classi derivate

Un membro protected è nascosto al mondo esterno ma disponibile per le classi che ereditano dalla classe che lo dichiara.

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
    }
}

Output:

Sam: 4000.00
Rita: 6400.00

C'è una regola che sorprende molti. Dentro Manager puoi usare baseSalary su this o su un altro Manager, ma non su un Employee qualsiasi:

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)
    }
}

Il motivo: other potrebbe essere un Contractor che deriva anch'esso da Employee, e protected concede l'accesso al tuo ramo della gerarchia, non a quello dei tuoi fratelli.

Un campo protected lega per sempre ogni classe derivata a quel campo. Molti progetti preferiscono una proprietà o un metodo protected, oppure tengono i campi privati e danno alle classi derivate solo ciò che serve.

internal: visibile dentro l'assembly

I membri e i tipi internal possono essere usati da qualsiasi codice dello stesso progetto e da niente al di fuori. Una libreria lo usa per le funzioni di supporto su cui si basano le sue classi pubbliche:

// 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;
}

I tipi di primo livello sono internal quando non scrivi alcun modificatore. Ecco perché una classe che hai dimenticato di marcare public in una libreria di classi "manca" nel progetto che la referenzia.

Anche i progetti di unit test sono assembly separati, quindi nemmeno loro vedono il codice internal. La soluzione standard è un attributo nella libreria:

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

protected internal e private protected

Questi due combinano i modificatori precedenti, in modi opposti, e i loro nomi si confondono facilmente:

• protected internal è protected oppure internal: qualsiasi codice nello stesso assembly, più le classi derivate in altri assembly. È il più ampio dei due.
• private protected (C# 7.2) è protected e internal: solo le classi derivate che si trovano anche nello stesso assembly. È il più ristretto, per una classe base i cui punti di estensione devono restare dentro la tua libreria.

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)
}

Valori predefiniti quando non scrivi nulla

Essere espliciti costa una parola e toglie un dubbio al prossimo lettore, per questo la maggior parte delle guide di stile chiede il modificatore anche quando coincide con quello predefinito.

Accesso a livello di accessor

Una proprietà o un indicizzatore può dare a uno dei suoi accessor un modificatore più ristretto di quello della proprietà stessa:

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
    }
}

Output:

report.pdf: 100%

Il modificatore dell'accessor deve essere più restrittivo di quello della proprietà, e solo uno dei due accessor può averne uno.

Accessibilità incoerente

Un membro pubblico non può esporre un tipo meno visibile di sé, perché i chiamanti riceverebbero qualcosa che non possono nominare:

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 stessa regola dà CS0051 per i tipi dei parametri e CS0053 per i tipi delle proprietà. Risolvi rendendo il tipo visibile quanto il membro, oppure il membro nascosto quanto il tipo.

Scegliere un modificatore

Parti dal modificatore più restrittivo che funziona e allargalo solo quando un chiamante ne ha bisogno. Rendere qualcosa più visibile in seguito è facile e non rompe mai nessuno; renderlo meno visibile rompe ogni chiamante che lo usava. In pratica: campi private, i membri che costituiscono lo scopo della classe public, le funzioni di supporto private e i tipi riservati alla libreria internal.