משתנים ב-C#: var, const, readonly, טווח ומתן שמות

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

using System;

class Program
{
    static void Main()
    {
        string customer = "Priya";   // declare and initialize
        int quantity;                // declare only
        quantity = 3;                // assign later
        decimal unitPrice = 4.25m;
        bool isMember = true;

        quantity = quantity + 2;     // reassign
        decimal total = quantity * unitPrice;
        if (isMember) total -= 1.00m;

        Console.WriteLine($"{customer} bought {quantity} items for {total:F2}");

        int apples = 4, pears = 6;   // several of the same type
        Console.WriteLine(apples + pears);
    }
}

פלט:

Priya bought 5 items for 20.25
10

השמה של ערך מהטיפוס הלא נכון היא שגיאת קומפילציה: quantity = "five"; נכשלת עם CS0029 (cannot implicitly convert type 'string' to 'int'). המרה בין טיפוסים היא מפורשת; ראו המרת טיפוסים.

var: לתת לקומפיילר להסיק את הטיפוס

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

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var name = "Oscar";          // string
        var age = 34;                // int
        var price = 19.99m;          // decimal
        var ratio = 0.75;            // double
        var tags = new List<string> { "new", "sale" };

        Console.WriteLine(name.GetType().Name);
        Console.WriteLine(age.GetType().Name);
        Console.WriteLine(price.GetType().Name);
        Console.WriteLine(ratio.GetType().Name);
        Console.WriteLine(tags.GetType().Name);

        // age = "old";  // error CS0029: age is an int, forever
    }
}

פלט:

String
Int32
Decimal
Double
List`1

ל-var יש שלושה כללים. הוא עובד רק עבור משתנים מקומיים (לא שדות ולא פרמטרים). המשתנה חייב להיות מאותחל בהצהרה: var x; היא שגיאה CS0818, "Implicitly-typed variables must be initialized". ולמאתחל חייב להיות טיפוס: var nothing = null; לא מתקמפל, כי ל-null לבדו אין טיפוס.

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

var orders = new List<Order>();         // obvious: var is fine
var reader = new StreamReader(path);    // obvious
decimal discount = CalculateDiscount(); // not obvious: name the type
int count = items.Count();              // makes the intent clear

מלכודת עדינה: var total = 0; הופך את total ל-int, כך שהוספת 2.5 אליו מאוחר יותר נכשלת, ו-var price = 10; הוא int, לא decimal. כשהטיפוס של הליטרל אינו הטיפוס שרוצים, כתבו את הטיפוס או הוסיפו סיומת (10m, 0.0).

טווח (scope)

משתנה מקומי קיים מההצהרה שלו ועד סוף הבלוק { } שבו הוצהר. משתנים שהוצהרו בכותרת של לולאה או בגוף של if לא נראים אחריהם.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 82, 91, 67 };
        int sum = 0;                         // visible in the whole of Main

        for (int i = 0; i < scores.Length; i++)   // i: only inside the loop
        {
            int doubled = scores[i] * 2;     // doubled: only inside the loop body
            sum += scores[i];
        }
        // Console.WriteLine(i);        // error CS0103: i does not exist here

        if (sum > 200)
        {
            string label = "high";
            Console.WriteLine(label);
        }
        Console.WriteLine(sum);
    }
}

פלט:

high
240

בניגוד ל-C ול-C++, C# לא מאפשרת לבלוק פנימי להצהיר על משתנה מקומי עם אותו שם כמו משתנה בבלוק עוטף (שגיאה CS0136): לשם חייבת להיות משמעות אחת לאורך כל המתודה. שני בלוקים אחים יכולים להשתמש שוב באותו שם, כמו שתי לולאות for נפרדות שכל אחת מצהירה על i.

השמה ודאית

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

int discount;
if (isMember)
{
    discount = 10;
}
Console.WriteLine(discount);
// error CS0165: Use of unassigned local variable 'discount'

תקנו את זה באתחול בהצהרה (int discount = 0;) או בהשמה בכל ענף (הוסיפו else). שדות ואיברי מערך שונים: הם מקבלים אוטומטית את ערך ברירת המחדל של הטיפוס שלהם (0, false, null).

const: קבועים של זמן קומפילציה

const הוא ערך שנקבע בזמן קומפילציה. חייבים לאתחל אותו בביטוי קבוע (ליטרל, const אחר, או חשבון עליהם), והוא יכול להיות רק מספר, char, bool, string, enum או null.

using System;

class Pricing
{
    public const decimal VatRate = 0.20m;
    public const int MaxItems = 50;
    public const string Currency = "EUR";
    public const string Label = "Price in " + Currency; // consts can combine
}

class Program
{
    static void Main()
    {
        const int Days = 7;          // local constants work too
        decimal net = 100m;

        Console.WriteLine(Pricing.Label);
        Console.WriteLine($"{net * (1 + Pricing.VatRate):F2} {Pricing.Currency}");
        Console.WriteLine(Pricing.MaxItems * Days);
        // Pricing.MaxItems = 60;   // error: cannot assign to a constant
    }
}

פלט:

Price in EUR
120.00 EUR
350

שדה const הוא static באופן מרומז, כך שניגשים אליו דרך שם הטיפוס (Pricing.VatRate), וכתיבה של static const היא שגיאה. הקומפיילר מעתיק את הערך לכל מקום שמשתמש בו, ולכן קבועים לא עולים כלום בזמן ריצה, ולכן גם const ציבורי בספרייה צריך להיות ערך שלעולם לא ישתנה (כמו מספר הימים בשבוע).

readonly ו-static readonly

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

using System;

class Account
{
    public readonly string Id;                    // set once per object
    public readonly DateTime OpenedOn;
    public static readonly DateTime Launch = new DateTime(2020, 1, 15);
    public static readonly string[] Plans = { "free", "pro" };

    public Account(string id, DateTime openedOn)
    {
        Id = id;                                  // allowed: in the constructor
        OpenedOn = openedOn;
    }

    public void Rename(string newId)
    {
        // Id = newId;  // error CS0191: readonly field outside the constructor
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("ACC-17", new DateTime(2024, 5, 2));
        Console.WriteLine($"{a.Id} opened {a.OpenedOn:yyyy-MM-dd}");
        Console.WriteLine($"Launch: {Account.Launch:yyyy-MM-dd}");

        Account.Plans[0] = "basic";   // allowed: the array itself is not readonly
        Console.WriteLine(string.Join(", ", Account.Plans));
    }
}

פלט:

ACC-17 opened 2024-05-02
Launch: 2020-01-15
basic, pro

השורות האחרונות מראות את אי-ההבנה הנפוצה: readonly מגן על השדה, לא על האובייקט שהוא מצביע עליו. Plans תמיד יפנה לאותו מערך, אבל האיברים של המערך עדיין יכולים להשתנות. לאוספים שבאמת בלתי ניתנים לשינוי השתמשו ב-ReadOnlyCollection<T> או ב-ImmutableArray<T>.

סיכום של שלושתם:

מוסכמות שמות

שמות ב-C# תלויים באותיות גדולות וקטנות (total ו-Total הם משתנים שונים) וחייבים להתחיל באות או בקו תחתון. המוסכמות של Microsoft, שכמעט כל קוד C# עוקב אחריהן:

• משתנים מקומיים ופרמטרים: camelCase (orderCount, unitPrice).
• קבועים, מאפיינים, מתודות, מחלקות ושדות ציבוריים: PascalCase (MaxItems, VatRate).
• שדות פרטיים: _camelCase עם קו תחתון בהתחלה (_balance), מוסכמה נפוצה בקוד .NET.
• משתנים בוליאניים נקראים כמו שאלות: isActive, hasDiscount, canRetry.
• הימנעו מקיצורים ומתחיליות הונגריות (strName, iCount).

מילת מפתח של C# לא יכולה לשמש כשם, אלא אם מוסיפים לפניה @: var @class = "5B"; חוקי, וזה שימושי לפעמים בקוד שנוצר אוטומטית או בשמות שדות של JSON.

החלפה והשמה מרובה

מאז C# 7, tuples מאפשרים להשים לכמה משתנים בפקודה אחת, וזה נותן החלפה בשורה אחת:

using System;

class Program
{
    static void Main()
    {
        int first = 10, second = 20;
        (first, second) = (second, first);
        Console.WriteLine($"{first} {second}");

        var (city, population) = ("Lisbon", 545000);
        Console.WriteLine($"{city}: {population:N0}");
    }
}

פלט:

20 10
Lisbon: 545,000

הצורה השנייה היא פירוק: היא מצהירה על city כ-string ועל population כ-int מתוך tuple. עוד ב-tuples.