Модификаторы доступа в C#: public, private, protected и internal

Модификаторы доступа определяют, какой код может использовать тип или член. С их помощью класс отделяет часть, на которую опирается другой код (свою открытую поверхность), от части, которую он может свободно менять (своих внутренностей). В C# их шесть, плюс значения по умолчанию, которые вы получаете, если не пишете ни одного.

Шесть модификаторов

Сборка это один скомпилированный проект: создаваемый им .dll или .exe. «Та же сборка» означает «тот же проект», поэтому internal работает как «видно моему коду, скрыто от пользователей моей библиотеки».

private и public: инкапсуляция

private это значение по умолчанию для членов и правильный выбор для большинства полей. Класс открывает то, что нужно вызывающим, через методы и свойства public, а эти методы поддерживают согласованность данных объекта.

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

Вывод:

False
True
Priya: 180

Поскольку balance закрыто, изменить его можно только через Deposit и TryWithdraw, и оба соблюдают правила. Никакой другой код программы не сможет создать отрицательный баланс, как бы он ни был написан. Вот что даёт инкапсуляция: правила живут в одном месте.

private действует на уровне типа, а не объекта. Метод Account может читать other.balance у другого экземпляра Account, и именно так обычно пишут Equals и методы сравнения.

protected: видно производным классам

Член protected скрыт от внешнего мира, но доступен классам, которые наследуются от объявляющего класса.

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

Вывод:

Sam: 4000.00
Rita: 6400.00

Есть одно правило, которое удивляет. Внутри Manager можно использовать baseSalary у this или у другого Manager, но не у произвольного 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)
    }
}

Причина: other может оказаться Contractor, который тоже наследуется от Employee, а protected даёт доступ к вашей собственной ветви иерархии, а не к соседним.

Защищённое поле навсегда связывает с собой каждый производный класс. Многие кодовые базы предпочитают свойство или метод protected либо держат поля закрытыми и дают производным классам только то, что им нужно.

internal: видно внутри сборки

Члены и типы internal может использовать любой код того же проекта и никакой код снаружи. Библиотека использует это для вспомогательных функций, на которые опираются её открытые классы:

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

Типы верхнего уровня являются internal, если модификатор не указан. Поэтому класс в библиотеке классов, который вы забыли пометить public, «пропадает» в проекте, который на неё ссылается.

Проекты модульных тестов это отдельные сборки, поэтому код internal им тоже не виден. Стандартное решение это атрибут в библиотеке:

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

protected internal и private protected

Эти два модификатора объединяют предыдущие противоположными способами, и их названия легко перепутать:

• protected internal это protected или internal: любой код в той же сборке плюс производные классы в других сборках. Это более широкий вариант.
• private protected (C# 7.2) это protected и internal: только производные классы, которые к тому же находятся в той же сборке. Это более узкий вариант, для базового класса, точки расширения которого должны оставаться внутри вашей библиотеки.

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

Значения по умолчанию, когда ничего не написано

Явное указание стоит одного слова и снимает вопрос у следующего читателя, поэтому большинство руководств по стилю просят писать модификатор, даже когда он совпадает со значением по умолчанию.

Доступ на уровне методов доступа

Свойство или индексатор может дать одному из методов доступа более узкий модификатор, чем у самого свойства:

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

Вывод:

report.pdf: 100%

Модификатор метода доступа должен быть строже, чем у свойства, и иметь его может только один из двух методов доступа.

Несогласованная доступность

Открытый член не может предоставлять тип, который менее видим, чем он сам, потому что вызывающие получили бы то, что им не разрешено называть:

internal class Discount { }

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

То же правило даёт CS0051 для типов параметров и CS0053 для типов свойств. Исправьте, сделав тип таким же видимым, как член, или член таким же скрытым, как тип.

Выбор модификатора

Начинайте с самого строгого модификатора, который работает, и расширяйте его, только когда он нужен вызывающему. Сделать что-то видимее позже легко и никогда никому не вредит; сделать что-то менее видимым ломает каждого вызывающего, который это использовал. На практике: поля private, члены, составляющие назначение класса, public, вспомогательные функции private, а типы только для библиотеки internal.