C# Zugriffsmodifizierer: public, private, protected und internal

Zugriffsmodifizierer entscheiden, welcher Code einen Typ oder Member verwenden darf. Mit ihnen trennt eine Klasse den Teil, auf den anderer Code sich verlässt (ihre öffentliche Oberfläche), von dem Teil, den sie frei ändern darf (ihre Interna). C# hat sechs davon, plus die Standardwerte, die du bekommst, wenn du keinen angibst.

Die sechs Modifizierer

Eine Assembly ist ein kompiliertes Projekt: die .dll oder .exe, die es erzeugt. „Gleiche Assembly“ bedeutet „gleiches Projekt“, deshalb funktioniert internal als „für meinen Code sichtbar, vor den Nutzern meiner Bibliothek verborgen“.

private und public: Kapselung

private ist der Standard für Member und für die meisten Felder die richtige Wahl. Die Klasse stellt über public-Methoden und -Properties bereit, was Aufrufer brauchen, und diese Methoden halten die Daten des Objekts konsistent.

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

Ausgabe:

False
True
Priya: 180

Weil balance privat ist, lässt es sich nur über Deposit und TryWithdraw ändern, und beide setzen die Regeln durch. Kein anderer Code im Programm kann einen negativen Kontostand erzeugen, egal wie er geschrieben ist. Das bringt Kapselung: Die Regeln stehen an einer Stelle.

private gilt pro Typ, nicht pro Objekt. Eine Methode von Account darf other.balance einer anderen Account-Instanz lesen, so werden Equals und Vergleichsmethoden meist geschrieben.

protected: sichtbar für abgeleitete Klassen

Ein protected-Member ist vor der Außenwelt verborgen, aber für Klassen verfügbar, die von der deklarierenden Klasse erben.

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

Ausgabe:

Sam: 4000.00
Rita: 6400.00

Eine Regel überrascht Leute. Innerhalb von Manager darfst du baseSalary auf this oder einem anderen Manager verwenden, aber nicht auf einem beliebigen Employee:

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

Der Grund: other könnte ein Contractor sein, der ebenfalls von Employee abgeleitet ist, und protected gewährt Zugriff auf deinen eigenen Zweig der Hierarchie, nicht auf den deiner Geschwister.

Ein geschütztes Feld koppelt jede abgeleitete Klasse für immer an dieses Feld. Viele Codebasen bevorzugen eine protected-Property oder -Methode oder halten Felder privat und geben abgeleiteten Klassen nur, was sie brauchen.

internal: sichtbar innerhalb der Assembly

internal-Member und -Typen können von jedem Code im selben Projekt verwendet werden und von nichts außerhalb. Eine Bibliothek nutzt das für die Hilfsmethoden, auf die sich ihre öffentlichen Klassen stützen:

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

Typen auf oberster Ebene sind internal, wenn du keinen Modifizierer schreibst. Deshalb „fehlt“ eine Klasse, die du in einer Klassenbibliothek vergessen hast als public zu markieren, in dem Projekt, das sie referenziert.

Unit-Test-Projekte sind separate Assemblies und können internal-Code daher ebenfalls nicht sehen. Die übliche Lösung ist ein Attribut in der Bibliothek:

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

protected internal und private protected

Diese beiden kombinieren die vorherigen Modifizierer auf entgegengesetzte Weise, und ihre Namen sind leicht zu verwechseln:

• protected internal ist protected oder internal: jeder Code in derselben Assembly plus abgeleitete Klassen in anderen Assemblies. Es ist der weitere.
• private protected (C# 7.2) ist protected und internal: nur abgeleitete Klassen, die auch in derselben Assembly liegen. Es ist der engere, für eine Basisklasse, deren Erweiterungspunkte innerhalb deiner Bibliothek bleiben sollen.

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

Standardwerte, wenn du nichts schreibst

Explizit zu sein kostet ein Wort und erspart dem nächsten Leser eine Frage, deshalb verlangen die meisten Styleguides den Modifizierer auch dann, wenn er dem Standard entspricht.

Zugriff auf Ebene der Accessoren

Eine Property oder ein Indexer kann einem Accessor einen engeren Modifizierer geben als der Property selbst:

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

Ausgabe:

report.pdf: 100%

Der Modifizierer des Accessors muss restriktiver sein als der der Property, und nur einer der beiden Accessoren darf einen haben.

Inkonsistente Zugreifbarkeit

Ein öffentlicher Member kann keinen Typ offenlegen, der weniger sichtbar ist als er selbst, weil Aufrufer dann etwas bekämen, das sie nicht benennen dürfen:

internal class Discount { }

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

Dieselbe Regel ergibt CS0051 für Parametertypen und CS0053 für Property-Typen. Behebe das, indem du den Typ so sichtbar machst wie den Member oder den Member so verborgen wie den Typ.

Einen Modifizierer wählen

Beginne mit dem restriktivsten Modifizierer, der funktioniert, und erweitere ihn nur, wenn ein Aufrufer es braucht. Etwas später sichtbarer zu machen ist einfach und bricht nie jemanden; etwas weniger sichtbar zu machen bricht jeden Aufrufer, der es verwendet hat. In der Praxis: Felder private, die Member, die den Zweck der Klasse ausmachen, public, Hilfsmethoden private und Typen nur für die Bibliothek internal.