Hvordan fungerer strenger i C#?

Question

Accepted Answer

I C# er **`string`** en immutable referansetype som representerer tekst. Strenger støtter interpolasjon, et rikt metodebibiotek, og — viktig for ytelse — `StringBuilder` for effektiv gjentatt modifikasjon.

## String-interpolasjon og opprettelse

```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-interpolasjon** (`$"..."`) er den moderne, lesbare måten å bygge strenger med innebygde verdier og formatspesifikasjoner. Verbatim (`@`) strenger deaktiverer escaping (flott for stier/regex), og raw string literals (`"""`) håndterer flerlinjet tekst.

## Strenger er immutable

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

Enhver operasjon som "endrer" en streng, lager faktisk en **ny** streng (immutabilitet). Dette er trygt men har en ytelseskostnad for gjentatt modifikasjon.

## StringBuilder for effektiv bygging

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

For å bygge strenger i løkker unngår **`StringBuilder`** å lage mange mellomliggende strenger — en nøkkel ytelsespraksis.

## Vanlige string-metoder

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

## Hvorfor det er viktig

String-manipulasjon er utbredt i programmering (bygge utdata, behandle indata, formatere data), så å forstå C# strenger er essensielt hverdagskunnskaper.

Moderne funksjoner er viktige for produktivitet: **string-interpolasjon** (`$"..."`) er den rene, lesbare måten å bygge strenger med innebygde verdier og formatering, og verbatim/raw string literals håndterer stier og flerlinjet tekst elegant.

Kritisk er det å forstå at **strenger er immutable** (hver "endring" lager en ny streng) som forklarer en nøkkel ytelsesvurdering: naiv **string-konkatenasjon i løkker** er sløsing (O(n²), oppretter mange mellomliggende strenger), og å vite å bruke **`StringBuilder`** for gjentatt modifikasjon (som effektivt muterer en intern buffer) er en viktig praktisk optimalisering som kommer direkte fra å forstå immutabilitet.

Å kjenne det rike string-metodebiblioteket (søk, erstatning, deling/sammenslåing, formatering), den moderne interpolasjonssyntaksen, og immutabilitet-drevet StringBuilder-praksis er kjernekunnskap for det konstante strengarbeidet som programmering involverer — flytende her, spesielt interpolasjonsbehageliget og StringBuilder-ytelsesfestingen, er grunnleggende for å skrive ren, effektiv C#.