מה חדש בשפת C# 15?
בגרסה 15 של שפת #C נוספו כמה יכולות שכדאי להכיר. חלקן מקצרות קוד שכבר כתבנו בדרך אחרת, וחלקן נותנות לנו אפשרויות חדשות לייצג את המידע במערכת.
התוספות הבולטות הן Union Types והיררכיות ירושה סגורות. לצד אלה נוספו אפשרות להעביר פרמטרים בעת יצירת אוספים בתחביר המקוצר, אינדקסרים כהרחבה לטיפוסים קיימים, ושליטה מפורשת יותר בלולאות מקוננות. יש גם שינוי בתמיכה באיברים סטטיים של ממשקים בסביבות ריצה ישנות, והתחלה של שינוי בבטיחות הזיכרון, שעדיין נמצאת בשלב Preview.
כדי להשתמש בתכונות ששוחררו, אפשר ליצור פרויקט עם ה־SDK של .NET 11 שמכוון ל־net11.0. בפרויקט כזה גרסת השפה היא 15 כברירת מחדל. אין צורך להפעיל Preview בשביל הדוגמאות הרגילות במאמר.
נתחיל מהתוספת שמעלה לדעתי את השאלות התכנוניות המעניינות ביותר.
1. Union Types: מתודה אחת, כמה סוגי תוצאות
נניח שאנחנו כותבים מתודה שמחפשת לקוח לפי מזהה.
אם הלקוח נמצא, נרצה להחזיר את הפרטים שלו. אם לא, נרצה לציין שהוא לא נמצא. ואם המזהה שקיבלנו בכלל אינו תקין, נרצה להחזיר הסבר.
אפשר להחזיר null, אבל הוא לא מסביר מדוע לא קיבלנו לקוח. אפשר לזרוק חריגה, ואפשר ליצור מחלקת תוצאה עם כמה שדות:
public class CustomerResult
{
public Customer? Customer { get; init; }
public string? Error { get; init; }
public bool NotFound { get; init; }
}
זה יכול לעבוד, אבל המחלקה מאפשרת גם שילובים שלא התכוונו אליהם: לקוח ושגיאה יחד, או NotFound שמוגדר כ־true למרות שיש לקוח.
אפשר למנוע אותם באמצעות בנאים ומתודות יצירה. אבל מה שרצינו להגיד מלכתחילה פשוט יותר: התוצאה היא אחת מתוך כמה אפשרויות.
בשביל זה נוספו Union Types.
נגדיר את האפשרויות שלנו כטיפוסים נפרדים:
public sealed record CustomerFound(int Id, string Name);
public sealed record CustomerNotFound(int Id);
public sealed record InvalidCustomerId(string Reason);
ועכשיו את הטיפוס שמאגד אותן:
public union CustomerLookupResult(
CustomerFound,
CustomerNotFound,
InvalidCustomerId);
הטיפוס CustomerLookupResult יכול להכיל ערך מאחד הטיפוסים שציינו. הם אינם צריכים לרשת מאותה מחלקה או לממש ממשק משותף.
למשל:
static CustomerLookupResult FindCustomer(int id)
{
if (id <= 0)
return new InvalidCustomerId("Id must be positive.");
if (id == 42)
return new CustomerFound(42, "Dana");
return new CustomerNotFound(id);
}
החיפוש עצמו מדומה כדי להתרכז בתוצאה. שימו לב שאין צורך לעטוף כל החזרה ידנית ב־CustomerLookupResult. השפה מאפשרת המרה משתמעת מכל אחת מהאפשרויות שהגדרנו.
כדי להשתמש בתוצאה, נוכל לכתוב:
CustomerLookupResult result = FindCustomer(42);
string message = result switch
{
CustomerFound customer =>
$"Hello, {customer.Name}",
CustomerNotFound missing =>
$"Customer {missing.Id} was not found.",
InvalidCustomerId invalid =>
invalid.Reason,
null =>
"No result was initialized."
};
התאמת הטיפוסים ב־switch בודקת את הערך שנמצא בתוך ה־Union. ברגע שנכנסנו לענף של CustomerFound, יש לנו משתנה מטיפוס זה, עם המאפיינים שלו.
אם נוסיף לרשימת האפשרויות טיפוס נוסף, למשל CustomerAccessDenied, הקומפיילר יוכל להתריע על ביטויי switch שלא מטפלים בו.
אבל אם נכתוב ענף כללי עם _, הוא יתפוס גם אפשרויות שנוסיף בעתיד. במקרה כזה מבחינת הקומפיילר טיפלנו בהן, גם אם מבחינת הלוגיקה העסקית שכחנו שהן קיימות.
מאיפה הגיע ה־null הזה?
זו נקודה שכדאי להכיר כבר בהתחלה.
ההכרזה המקוצרת באמצעות union יוצרת מאחורי הקלעים struct, שבמימוש שנוצר מחזיק את התוכן באמצעות הפניה מסוג object?.
לכן גם זה אפשרי:
CustomerLookupResult result = default;
במצב הזה אין בפנים אף אחת משלוש התוצאות שיצרנו. התוכן הוא null.
לא בכל מצב כזה תתקבל אזהרה על ענף חסר. לכן בדוגמה הוספתי טיפול מפורש ב־null, בלי להוסיף ענף כללי שיסתיר אפשרויות חדשות.
לאחסון הזה יש משמעות נוספת: כאשר אחת האפשרויות היא Value Type, כמו int, המימוש שנוצר מבצע Boxing. כלומר, עצם השימוש ב־Union לא מבטיח היעדר הקצאות. קיימת גם אפשרות למימוש מותאם, אבל לסקירה ראשונה מספיק להבין שהתחביר הקצר מייצר מנגנון מסוים, עם התנהגות ומחיר משלו.
ומכאן מתחיל הדיון התכנוני
בדוגמת החיפוש היה נוח לתאר כמה תוצאות אפשריות בלי לבנות להן מחלקת בסיס משותפת.
אבל אפשר גם לייצג אובייקטים באמצעות ירושה, ולהגדיר בהם את ההתנהגות במקום לכתוב switch בקוד שמשתמש בהם. אז מתי נכון לבחור בכל דרך?
בחלק מהמקרים, Union ו־Pattern Matching יכולים לפשט מימושים שהיינו כותבים באמצעות תבניות כמו Visitor, ולעיתים גם State. במקרים אחרים אנחנו עלולים לפזר בדיקות טיפוסים ברחבי המערכת ולהקשות על ההרחבה הבאה.
זה כבר דיון על מבנה התוכנה, ולא רק על תחביר חדש. במאמר נפרד אעסוק בבחירה הזו, בתבניות שאפשר לפעמים להחליף, ובוויכוחים סביב השאלה אם Union מפשט את התכנון או רק מסתיר בעיה בתכנון הקיים.
בינתיים, גרסה 15 מוסיפה גם אפשרות קרובה, שנשארת בתוך עולם הירושה.
2. Closed Hierarchies: ירושה, אבל עם גבולות
מחלקת בסיס רגילה אינה אומרת לקומפיילר שהמחלקות שכבר יורשות ממנה הן כל האפשרויות. ייתכן שתתווסף מחלקה נוספת, אפילו בספרייה אחרת.
המילה החדשה closed מאפשרת להגביל את היורשים הישירים ל־Assembly שבו הוגדרה מחלקת הבסיס.
למשל, מצבים של משימת רקע:
public closed record class JobState;
public sealed record Queued : JobState;
public sealed record Running(int Percent) : JobState;
public sealed record Completed(string FileName) : JobState;
public sealed record Failed(string Reason) : JobState;
כעת אפשר לכתוב:
static string Describe(JobState state) => state switch
{
Queued => "Waiting",
Running running => $"{running.Percent}%",
Completed completed => completed.FileName,
Failed failed => failed.Reason,
null => "No state"
};
הקומפיילר מכיר את קבוצת היורשים הישירים ויכול לבדוק שכיסינו אותה. מחלקה שסומנה closed היא abstract באופן משתמע, ולכן אי אפשר ליצור ממנה מופע ישירות.
יש כאן הבדל מ־sealed: מחלקה עם closed מאפשרת ירושה בתוך הגבול שהוגדר. מחלקה עם sealed אינה מאפשרת ירושה כלל.
ההגבלה גם אינה עוברת אוטומטית לכל הדורות. אם אחת המחלקות היורשות אינה sealed או closed, עדיין ניתן לרשת ממנה מבחוץ. בדוגמה הגדרתי את מחלקות המצבים כ־sealed כדי למנוע זאת.
לעומת Union שמאגד טיפוסים, כאן כל המצבים באמת יורשים מ־JobState. זה מתאים כשיש משמעות למחלקת הבסיס המשותפת, ולא רק צורך לרכז כמה אפשרויות ברשימה.
3. התחביר המקוצר של אוספים מקבל פרמטרים
את התחביר הבא אנחנו כבר מכירים:
List<string> names = ["Dana", "Avi", "Noa"];
אבל לפעמים צריך לקבוע גם איך האוסף נבנה.
למשל, אני רוצה HashSet שלא יבדיל בין אותיות גדולות לקטנות. עד עכשיו יכולתי לכתוב:
HashSet<string> names =
new(StringComparer.OrdinalIgnoreCase)
{
"Dana",
"DANA",
"Avi"
};
בגרסה 15 אפשר להעביר את הפרמטר בתוך ביטוי האוסף:
HashSet<string> names =
[
with(StringComparer.OrdinalIgnoreCase),
"Dana",
"DANA",
"Avi"
];
Console.WriteLine(names.Count); // 2
החלק with(...) מופיע ראשון ומעביר פרמטרים לבנאי או למנגנון היצירה המתאים. הוא אינו איבר נוסף באוסף.
אפשר להשתמש בו גם לקביעת קיבולת:
List<int> numbers = [with(capacity: 100), 10, 20, 30];
ברשימה יש שלושה איברים. הקיבולת אינה מספר האיברים, אלא המקום שהרשימה מקצה עבורם לפני שתצטרך להגדיל את האחסון הפנימי.
זו תוספת קטנה, אבל היא מאפשרת להישאר בתחביר המקוצר גם כשהיצירה דורשת קצת יותר מרשימת ערכים.
4. Extension Indexers: אינדקסרים כהרחבה
במאמר על איך עובד LINQ בשפת #C הסברתי איך Extension Methods מאפשרות לקרוא למתודה כאילו היא חלק מטיפוס קיים, בלי לשנות את הטיפוס.
בגרסה 14 נוספו בלוקי extension. בגרסה 15 אפשר להגדיר בתוכם גם אינדקסרים, כלומר גישה באמצעות סוגריים מרובעים.
למשל, טיפוס שמייצג טווח מספרים:
public sealed record NumberRange(int Start, int Count);
נוסיף לו אינדקסר באמצעות הרחבה:
public static class NumberRangeExtensions
{
extension(NumberRange range)
{
public int this[int index]
{
get
{
if (index < 0 || index >= range.Count)
throw new ArgumentOutOfRangeException(
nameof(index));
return range.Start + index;
}
}
}
}
האובייקט הבא מייצג חמישה מספרים, החל מ־20:
var range = new NumberRange(20, 5);
כלומר, המספרים שהוא מייצג הם:
20, 21, 22, 23, 24
הם אינם נשמרים במערך. האובייקט שומר רק את המספר ההתחלתי ואת כמות המספרים, והאינדקסר מחשב את הערך המבוקש.
כמו במערך, האינדקס מתחיל ב־0:
Console.WriteLine(range[0]); // 20
Console.WriteLine(range[1]); // 21
Console.WriteLine(range[2]); // 22
כשכותבים range[2], מופעל ה־get של האינדקסר עם הערך 2 בפרמטר index. הוא מחזיר range.Start + index, כלומר 20 + 2.
המחלקה המקורית לא השתנתה. החידוש הוא שאפשר להגדיר את האינדקסר הזה בהרחבה, מחוץ למחלקה המקורית, ולהשתמש בו כאשר ההרחבה זמינה בהקשר של הקוד.
בדוגמה אנחנו שולטים במחלקה, ולכן אפשר היה להוסיף לה אינדקסר רגיל. הרחבה מועילה במיוחד כשהטיפוס מגיע מספרייה שאיננו רוצים או יכולים לשנות.
כדאי רק שהתחביר לא יטעה את מי שקורא. גישה בסוגריים מרובעים לא מבטיחה שהפעולה זולה. אם מימוש האינדקסר עובר על אוסף שלם כדי להגיע לאיבר המבוקש, התחביר הקצר לא משנה את העלות הזו.
5. פקודות break ו־continue עם תווית
כשיש שתי לולאות מקוננות, break יוצא מהלולאה הפנימית. אם מצאנו את מה שחיפשנו ורוצים לסיים גם את החיצונית, צריך דרך נוספת לעשות זאת.
בגרסה 15 אפשר לתת תווית ללולאה ולציין אותה בפקודת היציאה:
int[,] values =
{
{ 3, 8, 1 },
{ 6, 9, 4 }
};
int target = 9;
(int Row, int Column)? found = null;
search:
for (int row = 0; row < values.GetLength(0); row++)
{
for (int column = 0;
column < values.GetLength(1);
column++)
{
if (values[row, column] == target)
{
found = (row, column);
break search;
}
}
}
Console.WriteLine(found);
הפקודה break search מסיימת את הלולאה החיצונית המסומנת.
באופן דומה, continue search הייתה עוברת לאיטרציה הבאה של הלולאה החיצונית, ובדוגמה שלנו לשורה הבאה במערך. בלי תווית, ההתנהגות הישנה נשארת כפי שהייתה.
למי שעבד עם goto, התווית הזו בוודאי נראית מוכרת. אגב, goto קיימת גם בשפת #C.
ההבדל הוא שכאן היעד מוגבל למבנה שעוטף את הפקודה. break search יוצא מהלולאה שסימנו, ו־continue search עובר לאיטרציה הבאה שלה. אי אפשר להשתמש בהן כדי לקפוץ לתווית שרירותית במקום אחר במתודה.
זה נותן שם מפורש ללולאה שאנחנו רוצים לצאת ממנה, במקום להגדיר משתנה עזר ולבדוק אותו בכל רמה של הלולאות.
אם כל מטרת המתודה היא למצוא ערך ולהחזיר אותו, return עדיין יכול להיות הפתרון הפשוט ביותר. התוספת שימושית כשצריך להמשיך לעבוד באותה מתודה אחרי הלולאות.
6. איברים סטטיים בממשקים בסביבות ריצה ישנות
ממשקים יכולים להכיל איברים סטטיים עם מימוש. למשל:
public interface IFileSize
{
public static long KilobytesToBytes(long value)
=> checked(value * 1024);
}
הקריאה נעשית דרך הממשק:
long bytes = IFileSize.KilobytesToBytes(64);
החידוש כאן אינו עצם האפשרות לכתוב מתודה כזו. בגרסה 15 אפשר להשתמש באיברים סטטיים שאינם וירטואליים גם כאשר סביבת הריצה שאליה מכוונים אינה תומכת במימושי ברירת מחדל של ממשקים.
זו הקלה רלוונטית בעיקר לספריות שמכוונות לסביבות ותיקות. היא לא אומרת שכל יכולות הממשקים החדשות זמינות בכל Runtime: מימושי ברירת מחדל של איברי מופע, וכן static abstract ו־static virtual, עדיין דורשים תמיכה מתאימה.
7. בטיחות זיכרון: עדיין ב־Preview
ברוב הקוד שאנחנו כותבים בשפת #C, אנחנו לא עובדים ישירות עם כתובות בזיכרון. למשל, כשניגשים לאיבר במערך, סביבת הריצה בודקת שהאינדקס נמצא בגבולות המערך.
אבל יש גם אפשרות לעבוד עם מצביעים, בעיקר לצורך תקשורת עם קוד Native או עבודה ברמה נמוכה. מצביע מחזיק כתובת בזיכרון. באמצעותו אפשר לקרוא או לשנות את הערך שנמצא באותה כתובת.
למשל, בקוד הבא:
unsafe
{
int number = 10;
int* pointer = &number;
*pointer = 25;
Console.WriteLine(number); // 25
}
הסימן & מחזיר את הכתובת של number. המשתנה pointer שומר אותה. בשורה *pointer = 25 אנחנו כותבים את הערך 25 אל המקום שהמצביע מצביע עליו, ולכן גם ערכו של number משתנה.
הקוד הזה אפשרי גם לפני גרסה 15, כאשר הפרויקט מאפשר שימוש ב־unsafe. המילה unsafe לא אומרת שבהכרח יש כאן שגיאה. היא מסמנת שימוש בפעולות שהבטיחות שלהן דורשת אחריות נוספת מהמפתח.
אז מה משתנה?
המודל החדש, שעדיין נמצא ב־Preview, מפריד בין החזקת כתובת לבין גישה לזיכרון שנמצא בכתובת הזו. עצם ההכרזה על מצביע לא תחייב בהכרח הקשר unsafe, אבל קריאה וכתיבה דרכו עדיין יחייבו אותו.
יש גם אפשרות להגדיר הקשר כזה עבור ביטוי אחד באמצעות unsafe(expression), במקום בלוק שלם. זה שימושי למשל באתחול שדה, שבו אי אפשר להציב בלוק unsafe רגיל.
בכללים המעודכנים, סימון מתודה כ־unsafe מעביר אחריות גם לקורא שלה ומחייב קריאה מתוך הקשר unsafe. לעומת זאת, מתודה יכולה לעטוף פעולות כאלה בבלוק פנימי ולהציע לקורא פעולה בטוחה, אם היא לוקחת אחריות על הבדיקות הנדרשות.
למי שלא עובד עם מצביעים וקוד Native, אין כאן כרגע שינוי בעבודה היומיומית. זו הצצה לכיוון שאליו השפה מתקדמת, ולא יכולת שצריך להפעיל כדי להשתמש בשאר החידושים שבמאמר.
מה הייתי מנסה קודם
את השינויים באוספים ובלולאות אפשר לבחון במקומות קטנים בקוד הקיים. אם הם הופכים את הכוונה לברורה יותר, קל יחסית לאמץ אותם.
עם Union Types הייתי מתחיל מתוצאה של פעולה שיש לה כמה אפשרויות מוגדרות, כמו החיפוש שהצגנו. כותב את הטיפוסים, מטפל בהם, ואז מוסיף אפשרות נוספת ובודק אילו מקומות דורשים שינוי.
זה תרגיל קטן, אבל הוא מראה יותר מדוגמה שבה הכול כבר מוכן. אפשר לראות מה הקומפיילר מזהה, מה ענף כללי מסתיר, והאם המבנה החדש באמת מתאים לקוד שלנו.
ומשם כבר אפשר להגיע לשאלה הבאה: מתי נרצה לשמור את ההתנהגות בתוך האובייקטים, ומתי נעדיף לרכז אותה בפעולות שמטפלות בכמה סוגים? את ההשוואה הזו נעשה במאמר הבא, עם קוד שאפשר לשנות ולראות מה מרוויחים ומה משלמים בכל בחירה.