C# Erişim Belirleyiciler: public, private, protected ve internal

Erişim belirleyiciler bir tipi ya da üyeyi hangi kodun kullanabileceğine karar verir. Bir sınıfın, diğer kodun dayandığı kısmı (public yüzeyi) değiştirmekte serbest olduğu kısımdan (iç yapısı) ayırmasının yolu budur. C#'ta altı tane vardır, bir de hiçbirini yazmadığınızda aldığınız varsayılanlar.

Altı belirleyici

Bir assembly derlenmiş tek bir projedir: ürettiği .dll ya da .exe. "Aynı assembly" "aynı proje" demektir; internal'ın "benim koduma görünür, kütüphanemin kullanıcılarından gizli" olarak çalışmasının nedeni budur.

private ve public: kapsülleme

private üyeler için varsayılandır ve çoğu alan için doğru seçimdir. Sınıf, çağıranların ihtiyaç duyduğunu public metotlar ve property'ler aracılığıyla sunar ve bu metotlar nesnenin verisini tutarlı tutar.

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

Çıktı:

False
True
Priya: 180

balance private olduğu için onu değiştirmenin tek yolu Deposit ve TryWithdraw'dur ve ikisi de kuralları uygular. Programdaki başka hiçbir kod, nasıl yazılırsa yazılsın, negatif bir bakiye oluşturamaz. Kapsüllemenin kazandırdığı budur: kurallar tek bir yerde yaşar.

private nesne başına değil tip başınadır. Account'un bir metodu farklı bir Account örneğindeki other.balance'ı okuyabilir; Equals ve karşılaştırma metotları genellikle böyle yazılır.

protected: türetilmiş sınıflara görünür

protected bir üye dış dünyadan gizlidir ama bildiren sınıftan kalıtım alan sınıflar tarafından kullanılabilir.

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

Çıktı:

Sam: 4000.00
Rita: 6400.00

İnsanları şaşırtan bir kural vardır. Manager içinde baseSalary'yi this üzerinde ya da başka bir Manager üzerinde kullanabilirsiniz, ama rastgele bir Employee üzerinde kullanamazsınız:

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

Nedeni: other, Employee'den türeyen bir Contractor da olabilir ve protected size hiyerarşinin kardeşlerinizin dalına değil kendi dalınıza erişim verir.

Protected bir alan her türetilmiş sınıfı sonsuza kadar o alana bağlar. Birçok kod tabanı protected bir property ya da metodu tercih eder veya alanları private tutup türetilmiş sınıflara yalnızca ihtiyaç duyduklarını verir.

internal: assembly içinde görünür

internal üyeler ve tipler aynı projedeki her kod tarafından kullanılabilir, dışarıdaki hiçbir şey tarafından kullanılamaz. Bir kütüphane onu public sınıflarının dayandığı yardımcılar için kullanır:

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

Hiçbir belirleyici yazmadığınızda üst seviye tipler internal'dır. Bir sınıf kütüphanesinde public işaretlemeyi unuttuğunuz bir sınıfın ona referans veren projede "kayıp" olmasının nedeni budur.

Birim test projeleri ayrı assembly'lerdir, bu yüzden onlar da internal kodu göremez. Standart çözüm kütüphanedeki bir özniteliktir:

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

protected internal ve private protected

Bu ikisi önceki belirleyicileri zıt yollarla birleştirir ve adları kolayca karıştırılır:

• protected internal, protected ya da internal'dır: aynı assembly'deki her kod ve başka assembly'lerdeki türetilmiş sınıflar. Daha geniş olanıdır.
• private protected (C# 7.2), protected ve internal'dır: yalnızca aynı assembly'de de bulunan türetilmiş sınıflar. Daha dar olanıdır; genişletme noktaları kütüphanenizin içinde kalması gereken bir temel sınıf içindir.

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

Hiçbir şey yazmadığınızda varsayılanlar

Açık olmak tek bir kelimeye mal olur ve sonraki okuyucu için bir soruyu ortadan kaldırır; bu yüzden çoğu stil kılavuzu varsayılanla eşleşse bile belirleyiciyi yazmayı ister.

Erişimci seviyesinde erişim

Bir property ya da indeksleyici, erişimcilerinden birine property'nin kendisinden daha dar bir belirleyici verebilir:

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

Çıktı:

report.pdf: 100%

Erişimcinin belirleyicisi property'ninkinden daha kısıtlayıcı olmalıdır ve iki erişimciden yalnızca birinin belirleyicisi olabilir.

Tutarsız erişilebilirlik

Public bir üye kendisinden daha az görünür bir tipi dışa açamaz, çünkü çağıranlar adını anmalarına izin verilmeyen bir şey alırdı:

internal class Discount { }

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

Aynı kural parametre tipleri için CS0051, property tipleri için CS0053 verir. Tipi üye kadar görünür ya da üyeyi tip kadar gizli yaparak düzeltin.

Bir belirleyici seçmek

Çalışan en kısıtlayıcı belirleyiciyle başlayın ve onu yalnızca bir çağıran ihtiyaç duyduğunda genişletin. Bir şeyi sonradan daha görünür yapmak kolaydır ve kimseyi bozmaz; bir şeyi daha az görünür yapmak onu kullanan her çağıranı bozar. Uygulamada: alanlar private, sınıfın amacını oluşturan üyeler public, yardımcılar private ve yalnızca kütüphaneye ait tipler internal.