Miten merkkijonot (strings) toimivat C#:ssa?

Question

Accepted Answer

C#:ssa **`string`** on muuttumaton viitosityyppi, joka edustaa tekstiä. Merkkijonot tukevat interpolaatiota, laajaa metodikirjastoa ja – tärkeää suorituskyvyn kannalta – `StringBuilder`-luokkaa tehokkaalle toistuvalle muokkaukselle.

## Merkkijonon interpolaatio ja luominen

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

**Merkkijonon interpolaatio** (`$"..."`) on moderni, luettava tapa rakentaa merkkijonoja upotettujen arvojen ja muotomääritysten kanssa. Verbatim-merkkijonot (`@`) poistavat escapoinnin käytöstä (hyvä polkuille/regex-lausekkeille), ja raw string literaalit (`"""`) käsittelevät moniriviset tekstit.

## Merkkijonot ovat muuttumattomia

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

Jokainen operaatio, joka "muokkaa" merkkijonoa, luo itse asiassa **uuden** merkkijonon (muuttumattomuus). Tämä on turvallista, mutta toistuvalla muokkauksella on suorituskykykustannus.

## StringBuilder tehokkaalle rakentamiselle

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

Merkkijonojen rakentamiselle silmukoissa **`StringBuilder`** välttää useiden välimerkkijonojen luomisen – tämä on keskeinen suorituskykykäytäntö.

## Yleiset merkkijonon metodit

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

## Miksi se on tärkeää

Merkkijonojen käsittely on ohjelmoinnissa kaikkialla (tuotoksen rakentaminen, tulon käsittely, tietojen muotoilu), joten C#-merkkijonojen ymmärtäminen on välttämätöntä jokapäiväistä tietoa.

Modernit ominaisuudet ovat tärkeitä tuottavuuden kannalta: **merkkijonon interpolaatio** (`$"..."`) on siisti, luettava tapa rakentaa merkkijonoja upotettujen arvojen ja muotoilun kanssa, ja verbatim/raw string literaalit käsittelevät polut ja moniriviset tekstit tyylikkäästi.

Ratkaisevasti, ymmärretään, että **merkkijonot ovat muuttumattomia** (jokainen "muokkaus" luo uuden merkkijonon), selitetään keskeinen suorituskykyharkinta: naiivi **merkkijonojen ketjuttaminen silmukoissa** on tuhlaajaista (O(n²), luodaan monia välimerkkijonoja), ja tietämys käyttää **`StringBuilder`**ia toistuvalle muokkaukselle (joka muuttaa sisäistä puskuria tehokkaasti) on tärkeä käytännöllinen optimointi, joka johtuu suoraan muuttumattomuuden ymmärtämisestä.

Rikkaan merkkijonon metodikirjaston tunteminen (haku, korvaus, split/join, muotoilu), moderni interpolaatiosyntaksi ja muuttumattomuuden ajama StringBuilder-käytäntö ovat perustietoa jatkuvasta merkkijonotyöstä, jota ohjelmointi sisältää – sujuvuus tässä, erityisesti interpolaation mukavuus ja StringBuilder-suorituskykykiinnitys, on perustava C#-osaaminen.