Kaip veikia eilutės C#?

Question

Accepted Answer

C# sistemoje **`string`** yra nekintamas nuorodinis tipas, reprezentuojantis tekstą. Eilutės palaiko interpoliaciją, turtingą metodų biblioteką ir — svarbu našumui — `StringBuilder` efektyviam pakartotiniam modifikavimui.

## Eilučių interpoliacija ir kūrimas

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

**Eilučių interpoliacija** (`$"..."`) yra šiuolaikiška, aiški eilučių su įterptomis reikšmėmis ir formato specifikatoriais kūrimo priemonė. Žodinės (`@`) eilutės išjungia išėjimo ženklus (puikiai tinka kelią ir regex), o neapdoroti eilučių literalai (`"""`) tvarko daugiažines eilutes.

## Eilutės yra nekintamos

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

Kiekviena operacija, kuri "modifikuoja" eilutę, iš tikrųjų sukuria **naują** eilutę (nekintamumas). Tai saugu, bet turi našumo kainą pakartotiniam modifikavimui.

## StringBuilder efektyviam kūrimui

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

Būvant eilučių kūrimo ciklams, **`StringBuilder`** išvengia daug tarpinių eilučių kūrimo — tai ypatinga našumo praktika.

## Dažni eilučių metodai

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

## Kodėl tai svarbu

Eilučių manipuliacija yra plaši programavime (išvesties kūrimas, įvesties apdorojimas, duomenų formatavimas), todėl supratimas apie C# eilutes yra esminės kasdienės žinios.

Šiuolaikinės savybės svarbu produktyvumui: **eilučių interpoliacija** (`$"..."`) yra švara, aiški eilučių kūrimo su įterptomis reikšmėmis ir formatavimu priemonė, ir žodiniai/neapdoroti eilučių literalai elegantiškai tvarko kelius ir daugiažines eilutes.

Kritiškai, supratimas, kad **eilutės yra nekintamos** (kiekvienas "modifikavimas" sukuria naują eilutę), paaiškina svarbų našumo svarbą: naivioji **eilučių jungimas cikluose** yra švaistymas (O(n²), sukuria daug tarpinių eilučių), ir žinojimas, kad reikia naudoti **`StringBuilder`** pakartotiniam modifikavimui (kuris efektyviai mutavina vidinį buferį) yra svarbi praktinė optimizacija, kylanti tiesiogiai iš nekintamumo supratimo.

Žinojimas apie turtingą eilučių metodų biblioteką (paieška, pakeitimas, skaidymas/jungimas, formatavimas), šiuolaikinę interpoliacijos sintaksę ir nekintamumą varomą StringBuilder praktiką yra pagrindinės žinios nuolatiniam eilučių darbui, kurį apima programavimas — sklandumas čia, ypač interpoliacijos patogumą ir StringBuilder našumo pataisą, yra pagrindinis žinių šaltinis skaitiems, efektyviam C# rašymui.