Bagaimanakah string berfungsi dalam C#?

Question

Accepted Answer

Dalam C#, **`string`** ialah reference type tak boleh ubah (immutable) yang mewakili teks. String menyokong interpolasi, perpustakaan kaedah yang kaya, dan — yang pentingnya untuk prestasi — `StringBuilder` untuk pengubahsuaian berulang yang cekap.

## Interpolasi dan pembinaan string

```csharp
string name = "Ann";
int age = 30;

// string interpolation ($) — embed expressions directly
string msg = $"Hello {name}, you are {age} years old";
string formatted = $"Price: {price:C2}";    // {value:format} — C2 = currency, 2 decimals

// verbatim strings (@) — no escaping, multi-line
string path = @"C:\Users\Ann";               // backslashes literal, no \ needed
string multi = """
    Raw string literal
    preserves formatting (C# 11)
    """;
```

**Interpolasi string** (`$"..."`) ialah cara moden dan mudah dibaca untuk membina string dengan nilai terbenam dan penentu format. String verbatim (`@`) mematikan escaping (bagus untuk laluan/regex), dan literal string mentah (`"""`) mengendalikan teks berbilang baris.

## String adalah tak boleh ubah

```csharp
string s = "Hello";
s.ToUpper();        // returns a NEW string "HELLO"; s is unchanged
s = s + " World";    // creates a NEW string; the old "Hello" is discarded
```

Setiap operasi yang "mengubah suai" string sebenarnya mencipta string **baharu** (kebolehubahan). Ini selamat tetapi mempunyai kos prestasi untuk pengubahsuaian berulang.

## StringBuilder untuk pembinaan yang cekap

```csharp
// ❌ string concatenation in a loop — creates a new string each iteration (slow, O(n²))
string result = "";
for (int i = 0; i < 10000; i++) result += i;

// ✅ StringBuilder mutates a buffer — efficient (O(n))
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string final = sb.ToString();
```

Untuk membina string dalam gelung, **`StringBuilder`** mengelakkan penciptaan banyak string perantara — satu amalan prestasi yang penting.

## Kaedah string yang biasa

```csharp
s.Length; s.ToUpper(); s.Trim(); s.Substring(0, 5);
s.Contains("x"); s.IndexOf("x"); s.Replace("a", "b");
s.Split(','); string.Join(",", items);
string.IsNullOrEmpty(s); string.IsNullOrWhiteSpace(s);
```

## Mengapa ia penting

Manipulasi string berleluasa dalam pengaturcaraan (membina output, memproses input, memformat data), jadi memahami string C# adalah pengetahuan harian yang amat penting.

Ciri-ciri moden penting untuk produktiviti: **interpolasi string** (`$"..."`) ialah cara bersih dan mudah dibaca untuk membina string dengan nilai terbenam dan pemformatan, dan literal string verbatim/mentah mengendalikan laluan dan teks berbilang baris dengan elegan.

Yang pentingnya, memahami bahawa **string adalah tak boleh ubah** (setiap "pengubahsuaian" mencipta string baharu) menjelaskan satu pertimbangan prestasi utama: **penggabungan string dalam gelung** secara naif adalah membazir (O(n²), mencipta banyak string perantara), dan mengetahui untuk menggunakan **`StringBuilder`** untuk pengubahsuaian berulang (yang mengubah penimbal dalaman dengan cekap) ialah satu pengoptimuman praktikal penting yang datang terus daripada pemahaman tentang kebolehubahan.

Mengetahui perpustakaan kaedah string yang kaya (cari, ganti, split/join, pemformatan), sintaks interpolasi moden, dan amalan StringBuilder yang didorong oleh kebolehubahan ialah pengetahuan teras untuk kerja string berterusan yang melibatkan pengaturcaraan — kelancaran di sini, terutamanya kemudahan interpolasi dan pembetulan prestasi StringBuilder, adalah asas untuk menulis C# yang bersih dan cekap.