מאפיינים ב-C#: get, set, מאפיינים אוטומטיים, init ו-required

מאפיין (property) נראה כמו שדה לקוד שמשתמש בו (order.Total, order.Total = 5), אבל הוא למעשה זוג מתודות: מאחזר get שמחזיר ערך ומאחזר set שמקבל ערך. העקיפות הזו מאפשרת למחלקה לבדוק ערכים, לחשב אותם או לסרב לכתיבה, בלי לשנות את האופן שבו הקוראים משתמשים בה.

שדות מול מאפיינים

שדה ציבורי נותן גישה ישירה לאחסון של האובייקט. כל אחד יכול לשים בו כל דבר:

public class Account
{
    public decimal Balance;   // any code can write -500 here
}

מאפיין שם קוד בין הקורא לבין האחסון. הנה הצורה המלאה שנכתבת ביד: שדה גיבוי (backing field) פרטי ועוד מאפיין עם שני המאחזרים. בתוך set, מילת המפתח value היא הערך שמוצב.

using System;

class Account
{
    private decimal balance; // backing field

    public decimal Balance
    {
        get { return balance; }
        set
        {
            if (value < 0) throw new ArgumentException("Balance cannot be negative");
            balance = value;
        }
    }
}

class Program
{
    static void Main()
    {
        var acc = new Account();
        acc.Balance = 250m;          // calls set with value = 250
        Console.WriteLine(acc.Balance); // calls get

        try
        {
            acc.Balance = -500m;
        }
        catch (ArgumentException)
        {
            Console.WriteLine("Rejected a negative balance");
        }
        Console.WriteLine(acc.Balance);
    }
}

פלט:

250
Rejected a negative balance
250

מעבר לאימות, מאפיינים חשובים כי רוב האקוסיסטם של .NET עובד איתם ומתעלם משדות: ממשקים יכולים להצהיר על מאפיינים אבל לא על שדות מופע, data binding ב-WPF וב-MAUI נקשר למאפיינים, ו-System.Text.Json מבצע סריאליזציה של מאפיינים ציבוריים כברירת מחדל ומדלג על שדות.

מאפיינים אוטומטיים

כשהמאחזרים רק היו קוראים וכותבים את השדה, תנו לקומפיילר לכתוב אותם. { get; set; } הוא מאפיין אוטומטי (auto-implemented property): הקומפיילר יוצר בשבילכם את שדה הגיבוי הנסתר.

using System;

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; } = 9.99m; // initializer, C# 6
    public int Stock { get; set; }
}

class Program
{
    static void Main()
    {
        var p = new Product { Name = "Notebook", Stock = 12 };
        p.Stock -= 2;
        Console.WriteLine($"{p.Name}: {p.Price}, {p.Stock} left");
    }
}

פלט:

Notebook: 9.99, 10 left

זה נראה כמו שדה, אז למה לטרוח? כי הפיכה של שדה ציבורי למאפיין בהמשך היא שינוי שובר לקוד מקומפל שמשתמש בו (ולארגומנטים של ref ו-out), ואילו שינוי של מאפיין אוטומטי למאפיין מלא עם אימות שקוף לקוראים. התחלה עם { get; set; } שומרת את האפשרות הזו פתוחה בחינם.

private set ומאפייני קריאה בלבד

את רוב המצב כדאי שכולם יוכלו לקרוא ורק האובייקט עצמו יוכל לשנות. תנו ל-setter מגדיר גישה מצומצם יותר:

using System;
using System.Collections.Generic;

class Cart
{
    private readonly List<decimal> prices = new List<decimal>();

    public string Owner { get; }                 // get-only: set in the constructor, never again
    public int ItemCount { get; private set; }   // readable anywhere, written only in here
    public decimal Total => SumPrices();         // computed on every read

    public Cart(string owner) { Owner = owner; }

    public void Add(decimal price)
    {
        prices.Add(price);
        ItemCount++;
    }

    private decimal SumPrices()
    {
        decimal sum = 0;
        foreach (var p in prices) sum += p;
        return sum;
    }
}

class Program
{
    static void Main()
    {
        var cart = new Cart("Ines");
        cart.Add(12.50m);
        cart.Add(3.25m);
        Console.WriteLine($"{cart.Owner}: {cart.ItemCount} items, total {cart.Total}");
        // cart.ItemCount = 99; // error CS0272: the set accessor is inaccessible
        // cart.Owner = "Tom";  // error CS0200: property is read only
    }
}

פלט:

Ines: 2 items, total 15.75

יש כאן שלושה סוגים של קריאה בלבד:

• { get; private set; }: המחלקה יכולה לשנות אותו בכל זמן, קוד חיצוני לא.
• { get; } (מאפיין אוטומטי לקריאה בלבד, C# 6): אפשר להציב בו ערך רק בבנאי או באתחול. אחרי הבנייה אף אחד לא יכול לשנות אותו, אפילו לא המחלקה. כך יוצרים מאפיין בלתי ניתן לשינוי.
• => expression (מאפיין מחושב): אין אחסון בכלל. הביטוי רץ בכל קריאה, כך ש-Total תמיד מעודכן לפי הרשימה.

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

מאחזרים עם גוף ביטוי

מאפיינים מלאים עם מאחזרים של שורה אחת יכולים להשתמש ב-=> לכל מאחזר:

private string title;

public string Title
{
    get => title;
    set => title = value?.Trim() ?? "";
}

public decimal Total => SumPrices(); הוא קיצור למאפיין עם getter בלבד; get => ... הוא אותו רעיון בתוך מאפיין שיש לו גם setter.

לוגיקה ב-getter וב-setter: התראות וערכים עצלים

מכיוון שמאחזרים הם מתודות, הם יכולים לעשות יותר מאחסון ערך. שתי תבניות נפוצות: הפעלת התראת שינוי מה-setter, וחישוב ערך בקריאה הראשונה ושמירתו במטמון.

using System;

class Settings
{
    private string theme = "light";
    private string summary; // cached

    public event Action<string> Changed;

    public string Theme
    {
        get => theme;
        set
        {
            if (value == theme) return;  // no change, no event
            theme = value;
            summary = null;              // invalidate the cache
            Changed?.Invoke(nameof(Theme));
        }
    }

    public string Summary
    {
        get
        {
            if (summary == null)
            {
                Console.WriteLine("(building summary)");
                summary = $"Theme: {theme}";
            }
            return summary;
        }
    }
}

class Program
{
    static void Main()
    {
        var s = new Settings();
        s.Changed += name => Console.WriteLine($"{name} changed");

        Console.WriteLine(s.Summary);
        Console.WriteLine(s.Summary);
        s.Theme = "dark";
        s.Theme = "dark";
        Console.WriteLine(s.Summary);
    }
}

פלט:

(building summary)
Theme: light
Theme: light
Theme changed
(building summary)
Theme: dark

Changed הוא event, ותבנית ה-setter הזו היא בדיוק איך שנראים מימושים של INotifyPropertyChanged ב-WPF וב-MAUI. nameof(Theme) שומר על המחרוזת מסונכרנת אם שם המאפיין משתנה.

טעות הרקורסיה האינסופית

הבאג הנפוץ ביותר במאפיינים הוא setter שמציב ערך במאפיין במקום בשדה הגיבוי:

public string Name
{
    get { return Name; }        // calls get again, forever
    set { Name = value; }       // calls set again, forever
}

כל מאחזר קורא לעצמו, והתוכנית קורסת עם StackOverflowException, שאי אפשר לתפוס. התיקון הוא לקרוא ולכתוב שדה נפרד (name, באותיות קטנות), או להשתמש במאפיין אוטומטי. C# 14 מוסיפה את מילת המפתח field בדיוק למקרה הזה: בתוך מאחזר, field מתייחס לשדה הגיבוי שהקומפיילר יוצר, כך ש-set => field = value.Trim(); עובד בלי להצהיר על שדה.

מאחזרי init (C# 9)

מאפיין לקריאה בלבד מכריח אתכם להעביר כל ערך דרך בנאי. C# 9 הוסיפה את init, setter שמותר רק בזמן יצירת האובייקט: בבנאי או באתחול אובייקט.

public class Product
{
    public string Sku { get; init; }
    public decimal Price { get; init; }
}

var p = new Product { Sku = "MUG-01", Price = 8.50m };   // fine: during creation
p.Price = 4m;   // error CS8852: Init-only property or indexer 'Product.Price' can only be assigned
                // in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor

התוצאה היא אובייקט בלתי ניתן לשינוי עם תחביר של אתחול אובייקט, וזה בדיוק מה שמחלקות record משתמשות בו למאפייני המיקום שלהן. כדי "לשנות" אובייקט כזה, יוצרים אחד חדש; records הופכים את זה לשורה אחת עם with.

ב-C# 7, המקבילה הקרובה ביותר היא מאפיין לקריאה בלבד ועוד פרמטר בבנאי:

public class Product
{
    public string Sku { get; }
    public decimal Price { get; }
    public Product(string sku, decimal price) { Sku = sku; Price = price; }
}

איברי required (C# 11)

אתחול אובייקט לא יכול להכריח קוראים להציב שום ערך: new Product { } מתקמפל גם כש-Sku אסור שיהיה ריק לעולם. C# 11 הוסיפה את המגדיר required:

public class User
{
    public required string Email { get; init; }
    public string DisplayName { get; init; } = "";
}

var ok = new User { Email = "ana@example.com" };
var bad = new User { DisplayName = "Ana" };   // error CS9035: Required member 'User.Email'
                                              // must be set in the object initializer or attribute constructor.

required עובד עם set ועם init. בנאי שמציב בעצמו את האיברים הנדרשים יכול להצהיר על כך עם התכונה [SetsRequiredMembers], כך שקוראים שמשתמשים בבנאי הזה לא יתבקשו להציב אותם שוב.

טעויות נפוצות

• רקורסיה במאחזר. set { Name = value; } קורא לעצמו. השתמשו בשדה גיבוי או במאפיין אוטומטי.
• getters יקרים או עם תופעות לוואי. קוראים מצפים שקריאה של מאפיין תהיה מהירה ובטוחה לחזרה. לעבודה, השתמשו במתודה.
• שדות ציבוריים "בינתיים". המרה של שדה למאפיין בהמשך שוברת תאימות בינארית, וסריאלייזרים מתעלמים משדות כברירת מחדל. התחילו עם מאפיין אוטומטי.
• setters ציבוריים לכל דבר. { get; set; } על יתרה או על סטטוס מזמין מצבים לא תקינים. השתמשו ב-private set, ב-init או בקריאה בלבד, ושנו מצב דרך מתודות.
• החזרה של אוסף שניתן לשינוי ממאפיין לקריאה בלבד. public List<string> Tags { get; } מונע מקוראים להחליף את הרשימה, לא להוסיף לה. החזירו IReadOnlyList<string> כשהאוסף לא אמור להשתנות מבחוץ.