StringBuilder di C#: Append, Insert, Replace dan Kapan Memakainya

String di C# bersifat immutable: s += "x" tidak memperpanjang s, tetapi membuat string baru yang berisi karakter lama plus karakter baru, dan string lama menjadi sampah. Jika hanya sekali, itu bukan masalah. Di perulangan yang berjalan ribuan kali, setiap iterasi menyalin semua yang sudah dibangun sejauh ini, sehingga total pekerjaannya tumbuh sebanding dengan kuadrat panjangnya.

StringBuilder, di System.Text, adalah buffer yang bisa diubah. Append menulis ke ruang kosong di ujungnya, sesekali memperbesar buffer, dan ToString() membuat satu string di akhir.

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);
    }
}

Output:

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

Kenapa penggabungan di dalam perulangan itu lambat

Berikut teks yang sama yang dibangun dengan kedua cara. Waktunya berbeda-beda di setiap komputer, jadi angka di bawah hanya contoh; yang penting adalah selisihnya, dan selisih itu makin lebar seiring perulangan makin panjang:

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}");
    }
}

Contoh output:

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

Dengan 20.000 kali append, versi += menyalin hampir 2 miliar karakter secara total. StringBuilder menyalin setiap karakter sekitar dua kali, sekali saat ditambahkan dan sekali lagi di ToString(), itulah sebabnya waktunya tetap sekitar satu milidetik.

Append, AppendLine, dan AppendFormat

Append punya overload untuk setiap tipe bawaan, dan mengembalikan builder yang sama, jadi pemanggilannya bisa dirangkai. AppendLine menambahkan baris baru setelah argumennya. AppendFormat menerima composite format string seperti 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
    }
}

Output:

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

Menambahkan interpolated string (sb.Append($"...")) tidak masalah dan enak dibaca. Di .NET 6 dan sesudahnya, compiler bahkan menulis potongan-potongannya langsung ke builder tanpa membuat string perantara.

AppendLine memakai Environment.NewLine: \n di Linux dan macOS, \r\n di Windows. Jika format file mewajibkan akhir baris tertentu, tambahkan sendiri.

Insert, Remove, Replace, dan indexer

Berbeda dengan string, StringBuilder bisa diedit langsung:

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}");
    }
}

Output:

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

Mengisi Length dengan nilai yang lebih kecil akan memotong isinya; ini cara termurah untuk membuang pemisah di akhir. Clear() mengatur panjangnya menjadi 0 dan mempertahankan buffer yang sudah dialokasikan, jadi satu builder bisa dipakai ulang di setiap iterasi perulangan luar.

Indexer cepat untuk bagian yang baru ditambahkan, tetapi bisa lambat untuk akses acak ke builder yang sangat besar, karena isinya disimpan dalam potongan-potongan yang saling terhubung. Jika kamu perlu membaca karakter, panggil ToString() sekali lalu akses string-nya lewat indeks.

Masalah pemisah di akhir

Pemakaian klasiknya adalah membangun daftar yang dipisahkan koma. Menambahkan pemisah setelah setiap item menyisakan satu pemisah berlebih di akhir:

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));
    }
}

Output:

csharp, dotnet, linq
csharp, dotnet, linq

Jika item-itemnya sudah ada di dalam collection, string.Join lebih singkat dan setidaknya sama cepatnya. Simpan StringBuilder untuk teks yang bentuknya bergantung pada logika: bagian kondisional, perulangan bersarang, format campuran.

Capacity

StringBuilder dimulai dengan ruang untuk 16 karakter. Saat ruangnya habis, ia menyambungkan blok penyimpanan baru sebesar semua isi yang sudah disimpannya, sampai 8.000 karakter per blok, jadi capacity-nya berlipat dua selama masih kecil, lalu bertambah dengan langkah 8.000 karakter. Pertumbuhan itu tidak pernah menyalin teks yang sudah tersimpan. Jika kamu kira-kira tahu panjang hasilnya, berikan capacity ke constructor, dan builder itu tidak perlu tumbuh sama sekali:

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);
    }
}

Output:

12000
10000
True
True

Menentukan ukuran di awal adalah optimasi, bukan keharusan. Pertumbuhan mengalokasikan blok baru tetapi tidak pernah memindahkan teks yang sudah ada, jadi nilai default sudah cukup, kecuali kamu membangun banyak string besar di bagian kode yang sering dijalankan.

Kapan tidak memakai StringBuilder

StringBuilder bukan pengganti yang lebih cepat untuk setiap +. Compiler sudah mengubah a + b + c + d dalam satu ekspresi menjadi satu pemanggilan string.Concat, yang menghitung panjang akhirnya dan menyalin setiap potongan sekali, pekerjaan yang sama dengan yang akan dilakukan builder, hanya dengan kode yang lebih banyak. Pakai string biasa jika:

• Jumlah potongannya sedikit dan tetap: $"{first} {last} ({age})".
• Potongannya ada di dalam collection dan butuh pemisah: string.Join(", ", items).
• Potongannya tidak butuh pemisah: string.Concat(parts).
• Kamu menggabungkan beberapa kali saja di luar perulangan.

Pakai StringBuilder saat kamu menambahkan teks di dalam perulangan, menambahkan teks dalam jumlah yang tidak kamu ketahui sebelumnya, atau mengedit teksnya (menyisipkan, mengganti, menghapus) sambil membangunnya. Bolak-balik mengonversi (sb.ToString() di dalam perulangan) membuang manfaatnya; panggil sekali saja di akhir.

Stream adalah alternatif lainnya: untuk menghasilkan file besar, tulis baris-barisnya ke StreamWriter sambil jalan alih-alih membangun seluruh isinya di memori. Lihat file.