מחרוזות ב-C#: Length, השוואה, תווי בריחה, מחרוזות verbatim ומחרוזות מרובות שורות

string ב-C# הוא רצף של תווי UTF-16 (ערכי char). זה טיפוס הפניה, אבל הוא מתנהג כמו ערך בדרכים שחשובות: הוא בלתי ניתן לשינוי, ו-== משווה את הטקסט ולא את זהות האובייקט. string היא מילת המפתח של C# לטיפוס System.String של .NET; אפשר להחליף ביניהן בחופשיות.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

פלט:

Porto
5
0
*****
hi
Porto has 5 letters

מחרוזות הן בלתי ניתנות לשינוי

אף מתודה לא משנה מחרוזת במקום. ToUpper, Replace, Trim וכל מתודה אחרת מחזירות מחרוזת חדשה ולא נוגעות במקור. שכחה להשתמש בערך המוחזר היא באג מחרוזות נפוץ מאוד:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

פלט:

[  maya  ]
[MAYA]
tea
tea and cake

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

Length ואינדקסים

Length הוא מאפיין (בלי סוגריים). האינדקסר s[i] מחזיר את ה-char במיקום i, בספירה מ-0, והוא לקריאה בלבד:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

פלט:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 ומעלה מקבלות גם אינדקס מהסוף: code[^1] הוא התו האחרון, כמו code[code.Length - 1]. כדי לקחת כמה תווים בבת אחת, ראו substring.

Length סופר יחידות קוד של UTF-16, לא את מה שקורא רואה כתווים. רוב האותיות ברוב השפות הן יחידה אחת, אבל אמוג'י וכמה כתבים נדירים משתמשים בשתיים (זוג surrogate), ולכן "👍".Length הוא 2.

השוואת מחרוזות

== ו-!= משווים את התווים, בתלות באותיות גדולות וקטנות. לכל דבר אחר, העבירו ערך StringComparison שמגדיר איך להשוות:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

פלט:

False
False
True
True
apple first
True
False
False
True

באיזו השוואה להשתמש:

• Ordinal משווה את הקודים המספריים של התווים. היא מהירה, צפויה וזהה בכל מחשב. השתמשו בה למזהים, שמות קבצים, מפתחות, ערכי פרוטוקול וכל דבר שלא מוצג לאדם.
• OrdinalIgnoreCase זהה, אבל מתעלמת מאותיות גדולות וקטנות. הבחירה הנכונה לבדיקות בלי תלות באותיות גדולות וקטנות, כמו סיומות קבצים או כותרות HTTP.
• CurrentCulture (ו-CurrentCultureIgnoreCase) פועלת לפי הכללים של השפה של המשתמש, כך שהיא ממיינת מילים כמו שמילון בשפה הזו היה ממיין. השתמשו בה למיון רשימות שמוצגות למשתמשים.
• InvariantCulture משתמשת בכללים שתלויים בתרבות אבל לא בהגדרות השפה של המשתמש. היא עדיין תלויה בספריית הגלובליזציה: .NET מודרני משתמש ב-ICU, .NET Framework משתמש ב-NLS של Windows, והשתיים יכולות לסדר חלק מהמחרוזות בצורה שונה.

string.Compare(a, b) ו-a.CompareTo(b) בלי StringComparison משתמשות בתרבות הנוכחית, ולכן התוצאות שלהן משתנות בין מחשבים. הימנעו מהשוואה עם a.ToLower() == b.ToLower(): היא מקצה שתי מחרוזות חדשות, ונותנת תשובות שגויות בחלק מהתרבויות (ה-i עם הנקודה ובלי הנקודה בטורקית הוא המקרה הקלאסי).

קריאה ל-a.Equals(b) כש-a הוא null זורקת NullReferenceException, בעוד ש-a == b וה-string.Equals(a, b) הסטטית מטפלות ב-null בבטחה.

תווי בריחה

בתוך ליטרל מחרוזת רגיל, לוכסן הפוך מתחיל רצף בריחה:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

פלט:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

רצף לא מוכר כמו "\d" הוא שגיאת קומפילציה (CS1009, רצף בריחה לא מזוהה), וזה מה שקורה כשנתיב של Windows או ביטוי רגולרי נכתבים כמחרוזת רגילה.

מחרוזות verbatim ומחרוזות מרובות שורות

הוספת @ לפני ליטרל הופכת אותו ל-verbatim: לוכסנים הפוכים הם תווים רגילים, והמחרוזת יכולה להתפרס על כמה שורות. הבריחה היחידה שנשארת היא "", שמייצרת מירכאה כפולה אחת.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

פלט:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

מחרוזת verbatim מרובת שורות כוללת את כל מה שבין המירכאות, כולל ההזחה של שורות ההמשך, ולכן כותבים אותן בדרך כלל צמוד לשוליים כמו בדוגמה. מעברי השורה שהיא מכילה הם אלה שבקובץ המקור, כך שקובץ שנשמר עם סופי שורה של Windows מייצר \r\n.

C# 11 הוסיפה raw string literals, שפותרים את שתי הבעיות. הם מתחילים ומסתיימים בשלוש מירכאות כפולות או יותר, לא צריכים שום בריחה, ומסירים את ההזחה שבה מוזחות המירכאות הסוגרות:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

אם התוכן עצמו מכיל """, התחילו וסיימו עם ארבע מירכאות. ליטרלים גולמיים משתלבים גם עם אינטרפולציה ($"""..."""); ראו אינטרפולציית מחרוזות.

null, מחרוזת ריקה ורווח לבן

משתנה מחרוזת יכול להיות null (אין מחרוזת בכלל), ריק ("", אורך 0), או להכיל רק רווח לבן. שתי מתודות עזר סטטיות בודקות את המקרים האלה בלי סיכון ל-NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

פלט:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

לבדיקת קלט של משתמש, string.IsNullOrWhiteSpace היא כמעט תמיד מה שצריך. string.Empty ו-"" הם אותו ערך; מה לכתוב זה עניין של סגנון.

מעבר על תווים בלולאה

מחרוזת היא אוסף שאפשר לעבור עליו, כך ש-foreach מבקרת בכל char. לטיפוס char יש מתודות סטטיות לסיווג תווים:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

פלט:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

חיבור מחרוזות

+ משרשר, ועובד עם כל טיפוס בצד השני (הוא קורא ל-ToString()). לשילוב של הרבה ערכים, העדיפו אינטרפולציה או string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

פלט:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

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