Hogyan működnek a stringek a C#-ban?

Question

Accepted Answer

A C#-ban a **`string`** egy immutable (nem módosítható) referencia típus, amely szöveget reprezentál. A stringek támogatják az interpolációt, gazdag metódus könyvtárat, és – a teljesítmény szempontjából fontos – a `StringBuilder`-t az ismételt módosítások hatékony végrehajtásához.

## String interpoláció és létrehozás

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

A **string interpoláció** (`$"..."`​) a modern, olvasható módja a stringek összeállításának beágyazott értékekkel és formátum specifikációkkal. A verbatim (`@`) stringek kikapcsolják az escape-elést (kiváló az útvonalakhoz/regex-hez), a raw string literálok (`"""`) pedig a többsoros szöveget kezelik.

## A stringek nem módosíthatók

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

Minden olyan operáció, amely "módosít" egy stringet, valójában egy **új** stringet hoz létre (immutabilitás). Ez biztonságos, de költsége van az ismételt módosítás teljesítményében.

## StringBuilder a hatékony összeállításhoz

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

Stringek ciklusban történő összeállításakor a **`StringBuilder`** elkerüli sok közbenső string létrehozását – ez egy kulcsfontosságú teljesítmény gyakorlat.

## Gyakori string metódusok

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

## Miért fontos

A string manipuláció minden programozásban omniprezens (kimenet építése, bemenet feldolgozása, adatok formázása), ezért a C# stringek megértése lényeges napi ismerete.

A modern funkciók fontosak a produktivitás szempontjából: a **string interpoláció** (`$"..."`​) az egyértelmű, olvasható módja a stringek összeállításának beágyazott értékekkel és formázással, valamint a verbatim/raw string literálok elegánsan kezelik az útvonalakat és többsoros szöveget.

Szépen figyelembe véve, hogy a **stringek nem módosíthatók** (minden "módosítás" egy új stringet hoz létre), megmagyarázza a kulcsfontosságú teljesítménybeli szempont: az naív **string konkatenáció ciklusokban** pazarló (O(n²), sok közbenső stringet hoz létre), és tudni, hogy a **`StringBuilder`**-t kell használni az ismételt módosításhoz (amely hatékonyan mutálja a belső buffert) egy fontos praktikus optimalizáció, amely közvetlenül az immutabilitás megértéséből adódik.

A gazdag string metódus könyvtár (keresés, csere, split/join, formázás), a modern interpoláció szintaxis, valamint az immutabilitás-vezérelt StringBuilder gyakorlat ismerete az alapvető tudás a konstans string munkához, amely a programozást jelenti – a fluencia ebben, különösen az interpoláció kényelme és a StringBuilder teljesítmény javítása, alapvető a tiszta, hatékony C# írásához.