Access Modifiers ב-C#: public, private, protected ו-internal

מגדירי גישה (access modifiers) קובעים איזה קוד רשאי להשתמש בטיפוס או באיבר. באמצעותם מחלקה מפרידה בין החלק שקוד אחר מסתמך עליו (הממשק הציבורי שלה) לבין החלק שהיא חופשייה לשנות (הפנימיות שלה). ב-C# יש שישה כאלה, ובנוסף ברירות המחדל שמקבלים כשלא כותבים אף אחד.

ששת המגדירים

assembly הוא פרויקט מקומפל אחד: קובץ ה-.dll או ה-.exe שהוא מייצר. "אותו assembly" פירושו "אותו פרויקט", ולכן internal מתפקד כ"גלוי לקוד שלי, מוסתר ממשתמשי הספרייה שלי".

private ו-public: כימוס (encapsulation)

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 הוא private, הדרכים היחידות לשנות אותו הן 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 קושר כל מחלקה יורשת לשדה הזה לתמיד. בהרבה בסיסי קוד מעדיפים מאפיין או מתודה protected, או משאירים שדות private ונותנים למחלקות היורשות רק את מה שהן צריכות.

internal: גלוי בתוך ה-assembly

איברים וטיפוסים 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 בספריית מחלקות "חסרה" בפרויקט שמפנה אליה.

פרויקטים של בדיקות יחידה הם assemblies נפרדים, ולכן גם הם לא רואים קוד internal. הפתרון המקובל הוא attribute בספרייה:

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

protected internal ו-private protected

שני אלה משלבים את המגדירים הקודמים, בדרכים הפוכות, וקל לבלבל בין השמות שלהם:

• protected internal הוא protected או internal: כל קוד באותו assembly, ובנוסף מחלקות יורשות ב-assemblies אחרים. זה הרחב מביניהם.
• private protected (C# 7.2) הוא protected וגם internal: רק מחלקות יורשות שנמצאות גם הן באותו assembly. זה הצר מביניהם, למחלקת בסיס שנקודות ההרחבה שלה צריכות להישאר בתוך הספרייה שלכם.

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

ברירות מחדל כשלא כותבים כלום

כתיבה מפורשת עולה מילה אחת וחוסכת שאלה מהקורא הבא, ולכן רוב מדריכי הסגנון דורשים את המגדיר גם כשהוא זהה לברירת המחדל.

גישה ברמת ה-accessor

מאפיין או אינדקסר יכולים לתת ל-accessor אחד מגדיר צר יותר מזה של המאפיין עצמו:

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%

המגדיר של ה-accessor חייב להיות מגביל יותר מזה של המאפיין, ורק לאחד משני ה-accessors מותר שיהיה מגדיר כזה.

נגישות לא עקבית

איבר public לא יכול לחשוף טיפוס שגלוי פחות ממנו, כי הקוד הקורא יקבל משהו שאסור לו אפילו לנקוב בשמו:

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.