Strings yadda suke aiki a C#?

Question

Accepted Answer

A C#, **`string`** shine nau'in maƙalli da ba zai iya canzawa ba wanda ke wakiltar rubutu. Strings suna goyan bayan interpolation, kirjin hanyoyin da yawa, da — muhimmi ne ga aiki — `StringBuilder` don gyarawa mabur da kyau.

## String interpolation da creation

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

**String interpolation** (`$"..."`) shine wannan zamani, hanyar da aka iya karanta ta gina strings tare da ƙimar da aka sira da format specifiers. Verbatim (`@`) strings suna dakatar da scaping (kyau ne don hanyoyi/regex), da raw string literals (`"""`) suna shawo kan rubutun multi-line.

## Strings ba zai iya canzawa ba

```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
```

Kowane aiki da yake "canza" string a zahiri yana haifar da **sabon** string (immutability). Wannan yana da amni amma akwai kudi na aiki don canzawa da sama-sama.

## StringBuilder don gina mabur

```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();
```

Don gina strings a cikin loops, **`StringBuilder`** yana guje wa sarrafa hanyoyi da yawa tsakanin strings — wannan shine muhimmin aiki na aiki.

## Common string methods

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

## Me ya sa haka mai muhimmi

String manipulation yana faruwa a saboda (gina output, aiki input, format data), saboda haka fahimtar C# strings ita ce ilmin aiki na yau da kullun.

Wannan zamani features suna da mahimmanci don aiki: **string interpolation** (`$"..."`) shine tsarki mai kyau, hanyar da aka iya karanta ta gina strings tare da ƙimar da aka sira da formatting, da verbatim/raw string literals suna shawo kan hanyoyi da rubutun multi-line da kyau.

Tsakanin gida, fahimtar cewa **strings ba zai iya canzawa ba** (kowane "canza" yana haifar da sabon string) yana bayyana mahimmancin fa'ida: naïve **string concatenation a cikin loops** ba shi da ƙarfi (O(n²), sarrafa hanyoyi da yawa tsakanin), da sanin amfani da **`StringBuilder`** don canzawa da sama-sama (wanda yake canja buff da jiya na jiya mabur) shine muhimman aiki na karneya da yake fitowa kai tsaye daga fahimtar immutability.

Sanin library mai yawa string (bincike, sauya, split/join, formatting), syntax interpolation na zamani, da aiki na immutability-driven StringBuilder shine ilmin gida don aiki na kudi da programming ya shiga cikin -- fluency a nan, musamman interpolation jari da StringBuilder aiki na gyarawa, shine tushe na rubuting C# mai tsarki da aiki.