C# static: מחלקות, מתודות, שדות ובנאים סטטיים

static מסמן איבר ששייך לטיפוס, לא לאובייקט. שדה מופע קיים פעם אחת לכל אובייקט; שדה סטטי קיים פעם אחת, וזהו. מתודת מופע רצה על אובייקט (order.Ship()); מתודה סטטית רצה על הטיפוס (Math.Round(x)) ולא צריכה אובייקט בכלל.

שדות סטטיים: עותק אחד, משותף

הדרך הברורה ביותר לראות את ההבדל היא מונה. לכל Order יש Id משלו, אבל ספירת ההזמנות שנוצרו עד עכשיו חייבת לשבת במקום משותף.

using System;

class Order
{
    private static int created;   // one copy for the whole program
    public int Id { get; }        // one copy per order
    public string Customer { get; }

    public Order(string customer)
    {
        created++;
        Id = created;
        Customer = customer;
    }

    public static int Created => created;
}

class Program
{
    static void Main()
    {
        var a = new Order("Ana");
        var b = new Order("Ben");
        var c = new Order("Chen");

        Console.WriteLine($"{a.Customer} #{a.Id}, {b.Customer} #{b.Id}, {c.Customer} #{c.Id}");
        Console.WriteLine($"Orders created: {Order.Created}");
    }
}

פלט:

Ana #1, Ben #2, Chen #3
Orders created: 3

ניגשים לאיברים סטטיים דרך שם הטיפוס: Order.Created, לא a.Created. C# לא מאפשרת להגיע לאיבר סטטי דרך מופע (שגיאה CS0176), וכך ברור במקום הקריאה שהערך משותף.

מתודות סטטיות

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

using System;

class Pricing
{
    public static decimal WithVat(decimal net, decimal rate) => Math.Round(net * (1 + rate), 2);

    public static string Format(decimal amount) => amount.ToString("0.00") + " EUR";
}

class Program
{
    static void Main()
    {
        decimal gross = Pricing.WithVat(49.90m, 0.23m);
        Console.WriteLine(Pricing.Format(gross));
        Console.WriteLine(Math.Max(3, 7)); // Math is full of static methods
    }
}

פלט:

61.38 EUR
7

גם Main עצמה סטטית: סביבת הריצה קוראת לה לפני שקיים אובייקט כלשהו.

השגיאה CS0120: קוד סטטי שמשתמש באיברי מופע

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

class Program
{
    int visits;
    void Greet() { Console.WriteLine("Hello"); }

    static void Main()
    {
        Greet();    // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
        visits++;   // error CS0120: An object reference is required for the non-static field, method, or property 'Program.visits'
    }
}

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

• האיבר באמת הוא נתון של אובייקט: צרו אובייקט והשתמשו בו. var app = new Program(); app.Greet();
• האיבר לא צריך מצב של אובייקט: סמנו אותו static. static void Greet() { ... }

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

הכיוון ההפוך תמיד מותר: מתודות מופע יכולות לקרוא לאיברים סטטיים בחופשיות.

מחלקות סטטיות

מחלקה שמוצהרת static יכולה להכיל רק איברים סטטיים, ואי אפשר ליצור ממנה מופע אף פעם. היא קבוצה של פונקציות וקבועים עם שם.

using System;

static class Temperature
{
    public const decimal FreezingC = 0m;

    public static decimal ToFahrenheit(decimal c) => c * 9 / 5 + 32;
    public static decimal ToCelsius(decimal f) => (f - 32) * 5 / 9;
    public static bool IsFreezing(decimal c) => c <= FreezingC;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(25m));
        Console.WriteLine(Temperature.ToCelsius(212m));
        Console.WriteLine(Temperature.IsFreezing(-3m));
        // var t = new Temperature(); // error CS0712: Cannot create an instance of the static class 'Temperature'
    }
}

פלט:

77
100
True

הקומפיילר אוכף את החוזה: איבר מופע בתוך מחלקה סטטית הוא שגיאה CS0708, ו-new עליה הוא שגיאה CS0712. Math, Console, File, Path ו-Enumerable הן כולן מחלקות סטטיות. גם מתודות הרחבה חייבות לשבת במחלקה סטטית.

בנאים סטטיים ו-static readonly

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

using System;
using System.Collections.Generic;

class ShippingRates
{
    public static readonly IReadOnlyDictionary<string, decimal> ByCountry;
    public static readonly DateTime LoadedOn = new DateTime(2026, 1, 1);

    static ShippingRates()
    {
        Console.WriteLine("ShippingRates initialized");
        ByCountry = new Dictionary<string, decimal> { ["PT"] = 4.90m, ["ES"] = 5.50m, ["FR"] = 6.20m };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before first use");
        Console.WriteLine(ShippingRates.ByCountry["ES"]);
        Console.WriteLine(ShippingRates.ByCountry.Count);
        Console.WriteLine(ShippingRates.LoadedOn.ToString("yyyy-MM-dd"));
    }
}

פלט:

Before first use
ShippingRates initialized
5.50
3
2026-01-01

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

const מול static readonly

שניהם נותנים ערך עם שם שמשותף לכל התוכנית, והם נבדלים ברגע שבו הערך נקבע:

שורת ההעתקה חשובה בספריות: אם assembly A מצהיר על public const int MaxItems = 50; ו-assembly B משתמש בו, B מכיל את הליטרל 50. שינוי של A ל-100 לא עושה כלום ל-B עד ש-B מקומפל מחדש. לערכים שעשויים להשתנות בין גרסאות, העדיפו static readonly.

using static

הנחיית using static (C# 6) מייבאת את האיברים הסטטיים של טיפוס, כך שאפשר לקרוא להם בלי שם הטיפוס:

using System;
using static System.Math;
using static System.Console;

class Program
{
    static void Main()
    {
        double radius = 3;
        double area = PI * Pow(radius, 2);
        WriteLine($"Area: {area:F2}");
        WriteLine(Max(12, 40));
    }
}

פלט:

Area: 28.27
40

זה נקרא טוב בקוד עתיר חישובים מתמטיים. במקומות אחרים השתמשו בזה במשורה: WriteLine או Parse חשופים מסתירים מאיזה טיפוס המתודה מגיעה.

מצב סטטי ותהליכונים

שדה סטטי משותף לכל התהליכונים בתהליך. הגדלה שלו מכמה תהליכונים בבת אחת מאבדת עדכונים, כי created++ הוא קריאה, חיבור וכתיבה, ושני תהליכונים יכולים לשזור אותם זה בזה. השתמשו ב-Interlocked.Increment(ref created) למונים, או ב-lock לכל דבר גדול יותר. אפליקציות web הן המקום הרגיל שבו זה נושך: כל בקשה רצה על תהליכון כלשהו, כך ששדה סטטי שמחזיק את "המשתמש הנוכחי" משותף לכל המשתמשים.

עוד דקות אחת: במחלקה גנרית, כל טיפוס שנבנה מקבל שדות סטטיים משלו. Cache<int>.Count ו-Cache<string>.Count הם שני שדות שונים.

מתי להשתמש ב-static

שימושים טובים:

• פונקציות עזר טהורות שמחשבות תוצאה מהארגומנטים שלהן: עיצוב, המרות, אימות.
• קבועים ונתוני חיפוש לקריאה בלבד שמשותפים לתוכנית.
• מתודות factory, כמו TimeSpan.FromMinutes(5) או Temperature.FromCelsius(21) משלכם.
• מתודות הרחבה.

שימושים גרועים:

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