StringBuilder ב-C#: Append, Insert, Replace ומתי להשתמש בו

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

StringBuilder, שנמצא ב-System.Text, הוא חוצץ שניתן לשינוי. Append כותבת לתוך מקום פנוי בסוף ומגדילה את החוצץ מדי פעם, ו-ToString() יוצרת מחרוזת אחת בסוף.

using System;
using System.Text;

class Program
{
    static void Main()
    {
        var sb = new StringBuilder();
        sb.Append("Order #");
        sb.Append(1042);                 // any type: calls ToString()
        sb.Append(", total ");
        sb.Append(59.97m);
        sb.AppendLine();                 // a newline
        sb.AppendLine("Status: shipped");
        sb.Append('*', 10);              // a char repeated

        string result = sb.ToString();
        Console.WriteLine(result);
        Console.WriteLine(sb.Length);
    }
}

פלט:

Order #1042, total 59.97
Status: shipped
**********
51

למה שרשור בתוך לולאה איטי

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

using System;
using System.Diagnostics;
using System.Text;

class Program
{
    static void Main()
    {
        const int n = 20_000;

        var watch = Stopwatch.StartNew();
        string s = "";
        for (int i = 0; i < n; i++)
        {
            s += "item" + i + ";";       // copies the whole string every time
        }
        watch.Stop();
        Console.WriteLine($"string +=     {watch.ElapsedMilliseconds} ms, length {s.Length}");

        watch.Restart();
        var sb = new StringBuilder();
        for (int i = 0; i < n; i++)
        {
            sb.Append("item").Append(i).Append(';');
        }
        string built = sb.ToString();
        watch.Stop();
        Console.WriteLine($"StringBuilder {watch.ElapsedMilliseconds} ms, length {built.Length}");
    }
}

פלט לדוגמה:

string +=     482 ms, length 188890
StringBuilder 1 ms, length 188890

עם 20,000 הוספות, גרסת ה-+= מעתיקה בסך הכול כמעט 2 מיליארד תווים. StringBuilder מעתיק כל תו בערך פעמיים, פעם כשהוא נוסף ופעם נוספת ב-ToString(), ולכן הוא נשאר סביב אלפית שנייה.

Append, AppendLine ו-AppendFormat

ל-Append יש העמסות לכל טיפוס מובנה, והיא מחזירה את אותו בונה, כך שאפשר לשרשר קריאות. AppendLine מוסיפה שורה חדשה אחרי הארגומנט שלה. AppendFormat מקבלת מחרוזת פורמט מורכבת כמו string.Format:

using System;
using System.Text;

class Program
{
    static void Main()
    {
        var items = new[] { "Espresso", "Croissant", "Orange juice" };
        var prices = new[] { 2.40m, 3.10m, 4.50m };

        var receipt = new StringBuilder();
        receipt.AppendLine("RECEIPT").AppendLine("-------");

        decimal total = 0;
        for (int i = 0; i < items.Length; i++)
        {
            receipt.AppendFormat("{0,-14}{1,6:F2}", items[i], prices[i]).AppendLine();
            total += prices[i];
        }
        receipt.Append($"{"TOTAL",-14}{total,6:F2}");

        Console.WriteLine(receipt);   // WriteLine calls ToString() for you
    }
}

פלט:

RECEIPT
-------
Espresso        2.40
Croissant       3.10
Orange juice    4.50
TOTAL          10.00

הוספה של מחרוזת אינטרפולציה (sb.Append($"...")) היא בסדר גמור וקריאה. ב-.NET 6 ומעלה הקומפיילר אפילו כותב את החלקים ישירות לתוך הבונה בלי ליצור את מחרוזת הביניים.

AppendLine משתמשת ב-Environment.NewLine: \n ב-Linux וב-macOS, \r\n ב-Windows. כשפורמט קובץ דורש סוף שורה מסוים, הוסיפו אותו בעצמכם.

Insert, Remove, Replace והאינדקסר

בניגוד למחרוזת, אפשר לערוך StringBuilder במקום:

using System;
using System.Text;

class Program
{
    static void Main()
    {
        var sb = new StringBuilder("Hello World");

        sb.Insert(5, ",");               // Hello, World
        Console.WriteLine(sb);

        sb.Replace("World", "Maya");     // replaces all occurrences
        Console.WriteLine(sb);

        sb.Remove(0, 7);                 // remove 7 chars at index 0
        Console.WriteLine(sb);

        sb[0] = 'm';                     // indexer is writable
        Console.WriteLine(sb);

        sb.Append("!!!");
        sb.Length -= 2;                  // shorten: drop the last 2 chars
        Console.WriteLine(sb);

        sb.Clear();
        Console.WriteLine($"[{sb}] length {sb.Length}");
    }
}

פלט:

Hello, World
Hello, Maya
Maya
maya
maya!
[] length 0

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

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

בעיית המפריד המיותר בסוף

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

using System;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main()
    {
        var tags = new List<string> { "csharp", "dotnet", "linq" };

        var sb = new StringBuilder();
        foreach (string tag in tags)
        {
            sb.Append(tag).Append(", ");
        }
        if (sb.Length > 0) sb.Length -= 2;   // drop the final ", "
        Console.WriteLine(sb);

        // Usually simpler: let Join place the separators
        Console.WriteLine(string.Join(", ", tags));
    }
}

פלט:

csharp, dotnet, linq
csharp, dotnet, linq

כשהפריטים כבר נמצאים באוסף, string.Join קצרה יותר ומהירה לפחות באותה מידה. שמרו את StringBuilder לטקסט שהצורה שלו תלויה בלוגיקה: קטעים מותנים, לולאות מקוננות, עיצוב מעורב.

קיבולת

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

using System;
using System.Text;

class Program
{
    static void Main()
    {
        var rows = 1000;
        var sb = new StringBuilder(rows * 12);   // about 12 chars per row
        Console.WriteLine(sb.Capacity);

        for (int i = 1; i <= rows; i++)
        {
            sb.Append("row ").Append(i.ToString("D4")).Append(";\n");
        }
        Console.WriteLine(sb.Length);
        Console.WriteLine(sb.Length <= sb.Capacity);
        Console.WriteLine(sb.MaxCapacity == int.MaxValue);
    }
}

פלט:

12000
10000
True
True

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

מתי לא להשתמש ב-StringBuilder

StringBuilder הוא לא תחליף מהיר יותר לכל +. הקומפיילר כבר הופך a + b + c + d בביטוי אחד לקריאה אחת ל-string.Concat, שמחשבת את האורך הסופי ומעתיקה כל חלק פעם אחת, אותה עבודה שבונה היה עושה עם יותר קוד. השתמשו במחרוזות רגילות כש:

• מספר החלקים קטן וקבוע: $"{first} {last} ({age})".
• החלקים נמצאים באוסף וצריכים מפריד: string.Join(", ", items).
• החלקים לא צריכים מפריד: string.Concat(parts).
• משרשרים כמה פעמים מחוץ לכל לולאה.

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

זרמים הם החלופה השנייה: כדי לייצר קובץ גדול, כתבו שורות ל-StreamWriter תוך כדי תנועה במקום לבנות את כל התוכן בזיכרון. ראו files.