C# Nullable: int?, האופרטור ??, ?. ובדיקות null

null פירושו "אין ערך". טיפוסי הפניה (מחלקות, מחרוזות, מערכים) תמיד יכלו להחזיק אותו. טיפוסי ערך (int, decimal, bool, DateTime, structs) לא יכולים, אלא אם הופכים אותם ל-nullable עם ?. C# נותנת לכם אז קבוצה קטנה של אופרטורים לעבודה עם ערכים שעשויים לחסור: ??, ??= ו-?..

טיפוסי ערך nullable: int?

הוסיפו ? לטיפוס ערך כדי לאפשר null. int? הוא קיצור של ה-struct Nullable<int>, שמחזיק ערך יחד עם דגל שאומר אם הערך קיים:

using System;

class Program
{
    static void Main()
    {
        int? rating = null;          // e.g. a review with no star rating
        decimal? discount = 5.50m;

        Console.WriteLine(rating.HasValue);
        Console.WriteLine(rating == null);
        Console.WriteLine(discount.HasValue);
        Console.WriteLine(discount.Value);

        Console.WriteLine(rating.GetValueOrDefault());      // 0 when null
        Console.WriteLine(rating.GetValueOrDefault(3));     // your own fallback

        rating = 4;
        if (rating.HasValue)
            Console.WriteLine($"Rated {rating.Value} stars");

        int plain = rating ?? 0;     // back to a non-nullable int
        Console.WriteLine(plain);
    }
}

פלט:

False
True
True
5.50
0
3
Rated 4 stars
4

מקורות נפוצים לטיפוסי ערך nullable הם שדות טופס אופציונליים, פרמטרים של שאילתה ועמודות NULL במסד נתונים: Order עם DateTime? ShippedAt עוד לא נשלח כל עוד הערך הוא null. החלופה, ערך קסם כמו -1 או DateTime.MinValue, נראית כמו נתון אמיתי, ובמוקדם או במאוחר מישהו משתמש בה ככזה.

int? מומר ל-int רק במפורש, כי ההמרה עלולה להיכשל. זה מביא אותנו לחריגה היחידה שטיפוסי ערך nullable זורקים.

"Nullable object must have a value"

קריאה של .Value כשאין ערך, או המרה של int? שהוא null ל-int, זורקת InvalidOperationException:

using System;

class Program
{
    static int? FindStock(string sku) => sku == "MUG-01" ? 12 : (int?)null;

    static void Main()
    {
        int? stock = FindStock("LAMP-9");

        try
        {
            int n = stock.Value;          // same result with (int)stock
            Console.WriteLine(n);
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine($"{e.GetType().Name}: {e.Message}");
        }

        // Safe alternatives:
        Console.WriteLine(stock ?? 0);
        Console.WriteLine(stock.GetValueOrDefault());
        if (stock is int count) Console.WriteLine(count);
        else Console.WriteLine("not stocked");
    }
}

פלט:

InvalidOperationException: Nullable object must have a value.
0
0
not stocked

stock is int count היא תבנית: היא בודקת אם יש ערך ומחלצת אותו ל-count בצעד אחד, וזה קריא יותר מ-HasValue ועוד Value. בדף על pattern matching יש צורות נוספות.

חשבון והשוואות עם null

אופרטורים על טיפוסי ערך nullable הם מורמים (lifted): אם אחד האופרנדים הוא null, התוצאה היא null. השוואות סדר (<, >, <=, >=) הן היוצא מן הכלל: הן מחזירות false ולא null. (היוצא מן הכלל השני הוא bool? עם & ו-|, שבו null & false הוא false.) לדוגמה:

using System;

class Program
{
    static void Main()
    {
        int? a = null;
        int? b = 10;

        int? sum = a + b;
        Console.WriteLine(sum == null);
        Console.WriteLine($"[{sum}]");       // null formats as an empty string

        Console.WriteLine(a > 5);
        Console.WriteLine(a <= 5);           // also false: null is not ordered
        Console.WriteLine(a == null);
        Console.WriteLine(b == 10);
    }
}

פלט:

True
[]
False
False
True
True

גם a > 5 וגם a <= 5 הם false, ולכן !(a > 5) אינו זהה ל-a <= 5 כש-a הוא null. קוד כמו if (!(age >= 18)) Deny(); מתייחס לגיל חסר כאל גיל מתחת ל-18, וזה אולי מה שהתכוונתם ואולי לא. החליטו קודם מה null אמור לייצג, בדרך כלל עם ??, ורק אז השוו.

אופרטור ה-null-coalescing ??

a ?? b מחזיר את a כש-a אינו null, ואחרת את b. הוא עובד על טיפוסי ערך nullable ועל טיפוסי הפניה, ואפשר לשרשר אותו משמאל לימין:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var settings = new Dictionary<string, string> { ["theme"] = "dark" };

        string userTheme = null;
        string siteTheme;
        settings.TryGetValue("theme", out siteTheme);
        string fontSize;
        settings.TryGetValue("font-size", out fontSize);

        Console.WriteLine(userTheme ?? siteTheme ?? "light");
        Console.WriteLine(fontSize ?? "16px");

        int? pageSize = null;
        int size = pageSize ?? 20;
        Console.WriteLine(size);

        string nickname = null;
        string display = nickname ?? "Anonymous";
        Console.WriteLine(display.ToUpper());
    }
}

פלט:

dark
16px
20
ANONYMOUS

הצד הימני מחושב רק כשצריך, כך ש-cache ?? LoadFromDatabase() לא פונה למסד הנתונים כשיש ערך במטמון. ?? מקבל גם ביטוי throw, וזה יוצר שומר קומפקטי (ראו throw):

this.repository = repository ?? throw new ArgumentNullException(nameof(repository));

??= (C# 8)

x ??= y מציב את y ב-x רק אם x הוא null. זה הביטוי המקובל לאתחול עצל (lazy):

private List<string> tags;

public void AddTag(string tag)
{
    tags ??= new List<string>();   // C# 8 and later
    tags.Add(tag);
}

לפני C# 8, כתבו tags = tags ?? new List<string>(); או if (tags == null) tags = new List<string>();.

אופרטור ה-null-conditional ?.

a?.Member מחשב את Member רק אם a אינו null; אחרת כל הביטוי הוא null. הוא הופך שרשרת של בדיקות null לביטוי אחד:

using System;
using System.Collections.Generic;

class Address { public string City; }
class Customer { public string Name; public Address Address; public List<string> Orders; }

class Program
{
    static void Main()
    {
        var withAddress = new Customer { Name = "Ines", Address = new Address { City = "Braga" } };
        var noAddress = new Customer { Name = "Omar" };
        Customer nobody = null;

        Console.WriteLine(withAddress.Address?.City);
        Console.WriteLine(noAddress.Address?.City ?? "(no city)");
        Console.WriteLine(nobody?.Address?.City ?? "(no customer)");

        int? orderCount = noAddress.Orders?.Count;       // int becomes int?
        Console.WriteLine(orderCount ?? 0);

        string firstOrder = noAddress.Orders?[0];         // null-conditional indexer
        Console.WriteLine(firstOrder == null);

        Action<string> onSaved = null;
        onSaved?.Invoke("saved");                          // nothing happens, no exception
        onSaved += msg => Console.WriteLine($"handler: {msg}");
        onSaved?.Invoke("saved");
    }
}

פלט:

Braga
(no city)
(no customer)
0
True
handler: saved

פרטים שכדאי להכיר:

• האופרטור מקצר את שאר השרשרת: ב-nobody?.Address?.City, ברגע ש-nobody הוא null שום דבר מימינו לא רץ.
• כשהאיבר מחזיר טיפוס ערך, התוצאה הופכת ל-nullable: Orders?.Count הוא int?, ולכן הוא צריך ?? 0 כדי לחזור להיות int.
• לפני C# 14, ?. לא יכול להיות יעד של השמה: customer?.Name = "x" לא מתקמפל בגרסאות קודמות.
• handler?.Invoke(...) היא הדרך המקובלת להפעיל event או לקרוא ל-callback אופציונלי.

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

בדיקת null

if (customer == null) { ... }             // classic
if (customer is null) { ... }             // C# 7 constant pattern
if (customer != null) { ... }
if (customer is not null) { ... }         // C# 9
if (customer is { } c) { ... }            // C# 8 property pattern: not null, and named

is null תמיד מבצע בדיקת null אמיתית, ואילו == קורא להעמסת האופרטור של הטיפוס אם יש כזו, כך שהעמסה כתובה גרוע יכולה לגרום ל-x == null לשקר. לארגומנטים שאסור שיהיו null, היכשלו מוקדם:

public void Ship(Order order)
{
    ArgumentNullException.ThrowIfNull(order);   // .NET 6+
    // ...
}

טיפוסי הפניה nullable (C# 8)

הוספת ? לטיפוס ערך משנה את הטיפוס. הוספת ? לטיפוס הפניה, מאז C# 8, משנה רק את מה שהקומפיילר בודק. כשהתכונה מופעלת (<Nullable>enable</Nullable> בקובץ הפרויקט, ברירת המחדל בפרויקטים חדשים מאז .NET 6), string אומר "אף פעם לא אמור להיות null" ו-string? אומר "יכול להיות null", והקומפיילר מזהיר כשהקוד לא תואם:

#nullable enable

public class User
{
    public string Email { get; set; }      // warning CS8618: Non-nullable property 'Email'
                                           // must contain a non-null value when exiting constructor.
    public string? Nickname { get; set; }  // allowed to be null

    public int NicknameLength() => Nickname.Length;
    // warning CS8602: Dereference of a possibly null reference.

    public int SafeLength() => Nickname?.Length ?? 0;   // no warning
}

string? input = Console.ReadLine();
string name = input;                       // warning CS8600: Converting null literal or possible
                                           // null value to non-nullable type.
string checkedName = input ?? "guest";     // no warning
int len = input!.Length;                   // ! tells the compiler "trust me": no warning

הקומפיילר עוקב אחרי הבדיקות שלכם לאורך המתודה: אחרי if (input != null), input נחשב כלא-null. האופרטור ! (null-forgiving) משתיק אזהרה כשאתם יודעים יותר טוב מהניתוח; כל שימוש בו הוא טענה שהקומפיילר לא יכול לאמת, אז השתמשו בו לעיתים רחוקות.

שתי עובדות מבהירות את רוב הבלבול. ראשית, מדובר רק באזהרות: התוכנית רצה אותו דבר, ו-string עדיין יכול להחזיק null בזמן ריצה אם הוא הגיע מקוד בלי הערות nullable. שנית, string? אינו Nullable<string>; אין לו HasValue.

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

• .Value בלי בדיקה. זורק InvalidOperationException כשהערך null. השתמשו ב-??, ב-GetValueOrDefault() או ב-is int n.
• הנחה ש-!(x > 5) אומר x <= 5. לא כש-x הוא null: כל השוואת סדר עם null היא false.
• כיסוי של כל null עם ?.. זה משתיק את הסימפטום ומרחיק את הכישלון מהסיבה.
• התייחסות לאזהרות nullable כאל רעש. כל אחת מסמנת שורה שיכולה לזרוק NullReferenceException. תקנו את הזרימה או הצהירו על הכוונה עם ?.
• ערכי קסם במקום null. -1, 0 ו-DateTime.MinValue בתור "לא ידוע" נראים כמו נתונים אמיתיים. השתמשו ב-int? וב-DateTime?.