Hur fungerar strängar i C#?

Question

Accepted Answer

I C# är **`string`** en oföränderlig referenstyp som representerar text. Strängar stöder interpolation, ett omfattande metodbibliotek, och – viktigt för prestanda – `StringBuilder` för effektiv upprepad ändring.

## Stränginterpolation och skapande

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

**Stränginterpolation** (`$"..."`) är det moderna, läsbara sättet att bygga strängar med inbäddade värden och formatspecificerare. Ordagrant (`@`) strängar inaktiverar escape-sekvenser (utmärkt för sökvägar/regex), och råsträngsliteraler (`"""`) hanterar flerradig text.

## Strängar är oföränderliga

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

Varje operation som "ändrar" en sträng skapar faktiskt en **ny** sträng (oföränderlighet). Det är säkert men har en prestandakostnad för upprepad ändring.

## StringBuilder för effektiv byggnation

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

När strängar byggs i loopar undviker **`StringBuilder`** att skapa många mellanliggande strängar – en viktig prestandapraxis.

## Vanliga strängmetoder

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

## Varför det är viktigt

Strängmanipulation är genomgripande inom programmering (byggnation av utdata, bearbetning av indata, formatering av data), så förståelse för C#-strängar är väsentlig daglig kunskap.

De moderna funktionerna är viktiga för produktivitet: **stränginterpolation** (`$"..."`) är det rena, läsbara sättet att bygga strängar med inbäddade värden och formatering, och ordagrant/råsträngsliteraler hanterar sökvägar och flerradig text elegant.

Kritiskt är det att förstå att **strängar är oföränderliga** (varje "ändring" skapar en ny sträng) förklarar en viktig prestandakonsideration: naiv **strängsammanfogning i loopar** är slösaktig (O(n²), skapar många mellanliggande strängar), och vetskap om att använda **`StringBuilder`** för upprepad ändring (som effektivt muterar en intern buffert) är en viktig praktisk optimering som kommer direkt från förståelse av oföränderlighet.

Kännedom om det omfattande strängmetodbiblioteket (sökning, ersättning, dela/sammanfoga, formatering), den moderna interpolationssyntaxen, och den oföränderlighet-driven StringBuilder-praxis är kärnkunskap för det konstanta strängarbete som programmering involverar – flytande här, särskilt interpolationens bekvämlighet och StringBuilder-prestandafix, är grundläggande för att skriva ren, effektiv C#.