Access Modifier C#: public, private, protected, dan internal

Access modifier menentukan kode mana yang boleh memakai sebuah tipe atau member. Dengan access modifier, sebuah class memisahkan bagian yang diandalkan kode lain (permukaan publiknya) dari bagian yang bebas diubahnya (bagian internalnya). C# punya enam access modifier, ditambah default yang kamu dapat saat tidak menulis apa pun.

Enam modifier

Assembly adalah satu project yang sudah di-compile: file .dll atau .exe yang dihasilkannya. "Assembly yang sama" berarti "project yang sama", itulah sebabnya internal berfungsi sebagai "terlihat oleh kodeku, tersembunyi dari pengguna library-ku".

private dan public: enkapsulasi

private adalah default untuk member dan pilihan yang tepat untuk sebagian besar field. Class menyediakan apa yang dibutuhkan pemanggil lewat method dan property public, dan method-method itu menjaga data object tetap konsisten.

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

Karena balance bersifat private, satu-satunya cara mengubahnya adalah lewat Deposit dan TryWithdraw, dan keduanya menerapkan aturannya. Tidak ada kode lain di program yang bisa membuat saldo negatif, bagaimanapun kode itu ditulis. Inilah manfaat enkapsulasi: aturannya ada di satu tempat.

private berlaku per tipe, bukan per object. Method milik Account boleh membaca other.balance pada instance Account yang lain, dan begitulah biasanya Equals dan method pembanding ditulis.

protected: terlihat oleh class turunan

Member protected tersembunyi dari dunia luar, tetapi tersedia untuk class yang mewarisi class yang mendeklarasikannya.

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

Ada satu aturan yang sering mengejutkan. Di dalam Manager, kamu boleh memakai baseSalary pada this atau pada Manager lain, tetapi tidak pada sembarang 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)
    }
}

Alasannya: other bisa saja sebuah Contractor yang juga diturunkan dari Employee, dan protected memberi akses ke cabang hierarkimu sendiri, bukan ke cabang saudaramu.

Field protected mengikat setiap class turunan ke field itu selamanya. Banyak codebase lebih memilih property atau method protected, atau tetap membuat field private dan hanya memberi class turunan apa yang dibutuhkannya.

internal: terlihat di dalam assembly

Member dan tipe internal bisa dipakai oleh kode apa pun di project yang sama dan tidak oleh apa pun di luarnya. Sebuah library memakainya untuk class pembantu yang diandalkan class public-nya:

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

Tipe tingkat atas bersifat internal saat kamu tidak menulis modifier. Itulah sebabnya class yang lupa kamu tandai public di sebuah class library "hilang" dari project yang mereferensikannya.

Project unit test adalah assembly terpisah, jadi project itu juga tidak bisa melihat kode internal. Solusi standarnya adalah sebuah attribute di library:

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

protected internal dan private protected

Dua modifier ini menggabungkan modifier sebelumnya dengan cara yang berlawanan, dan namanya mudah tertukar:

• protected internal adalah protected atau internal: kode apa pun di assembly yang sama, ditambah class turunan di assembly lain. Ini yang lebih luas.
• private protected (C# 7.2) adalah protected dan internal: hanya class turunan yang juga berada di assembly yang sama. Ini yang lebih sempit, untuk class dasar yang titik perluasannya harus tetap di dalam library-mu.

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

Default saat kamu tidak menulis apa pun

Menulis modifier secara eksplisit hanya butuh satu kata dan menghilangkan pertanyaan bagi pembaca berikutnya, jadi sebagian besar panduan gaya meminta modifier ditulis meskipun sama dengan default-nya.

Akses di tingkat accessor

Sebuah property atau indexer bisa memberi salah satu accessor-nya modifier yang lebih sempit daripada property itu sendiri:

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%

Modifier accessor harus lebih ketat daripada modifier property-nya, dan hanya salah satu dari dua accessor yang boleh punya modifier.

Aksesibilitas yang tidak konsisten

Member public tidak boleh mengekspos tipe yang visibilitasnya lebih sempit daripada member itu, karena pemanggil akan menerima sesuatu yang tidak boleh mereka sebut namanya:

internal class Discount { }

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

Aturan yang sama menghasilkan CS0051 untuk tipe parameter dan CS0053 untuk tipe property. Atasi dengan membuat tipenya seterlihat member-nya, atau membuat member-nya setersembunyi tipenya.

Memilih modifier

Mulailah dengan modifier paling ketat yang masih berfungsi, dan perluas hanya saat ada pemanggil yang membutuhkannya. Membuat sesuatu lebih terlihat belakangan itu mudah dan tidak pernah merusak siapa pun; membuat sesuatu kurang terlihat merusak setiap pemanggil yang memakainya. Dalam praktiknya: field private, member yang menjadi tujuan class public, method pembantu private, dan tipe khusus library internal.