Si funksionojnë stringjet në C#?

Question

Accepted Answer

Në C#, **`string`** është një tip referimi i pandryshueshëm që përfaqëson tekst. Stringjet mbështesin interpolim, një bibliotekë të pasur metodash, dhe — e rëndësishme për performancën — `StringBuilder` për modifikim efikas të përsëritur.

## Interpolimi i stringjeve dhe krijimi

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

**Interpolimi i stringjeve** (`$"..."`) është mënyra moderne dhe e legjitshme për të ndërtuar stringje me vlera të ngulitura dhe përcaktime formati. Stringjet verbatim (`@`) çaktivizojnë shpëtimin (shumë i mirë për rrugë/regex), dhe literalët e stringjeve të papërpunuara (`"""`) menaxhojnë tekstin shumëlinjësh.

## Stringjet janë të pandryshueshëm

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

Çdo operacion që "modifikon" një string në fakt krijon një string **të ri** (pandryshueshëmëri). Kjo është e sigurt por ka një kosto performancë për modifikim të përsëritur.

## StringBuilder për ndërtim efikas

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

Për të ndërtuar stringje në cikle, **`StringBuilder`** shmang krijimin e shumë stringjeve ndërmjetëse — një praktikë kyçe e performancës.

## Metodat e zakonshme të stringjeve

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

## Pse ka rëndësi

Manipulimi i stringjeve është i përhapur në programim (ndërtimi i rezultatit, përpunimi i hyrjes, formatimi i të dhënave), kështu që kuptimi i stringjeve në C# është njohuri thelbësore e përditshme.

Funsionet moderne kanë rëndësi për produktivitetin: **interpolimi i stringjeve** (`$"..."`) është mënyra e pastër dhe e legjitshme për të ndërtuar stringje me vlera të ngulitura dhe formatim, dhe stringjet verbatim/të papërpunuara menaxhojnë rrugë dhe tekst shumëlinjësh me elegancë.

Në mënyrë kritike, kuptimi i faktit që **stringjet janë të pandryshueshëm** (çdo "modifikim" krijon një string të ri) shpjegon një konsideratë kyçe të performancës: lidhja naive **e stringjeve në cikle** është shpërdoruese (O(n²), duke krijuar shumë stringje ndërmjetëse), dhe e dini të përdorni **`StringBuilder`** për modifikim të përsëritur (i cili ndryshon një tampon të brendshëm në mënyrë efikase) është një optimizim praktik i rëndësishëm që vjen drejtpërdrejt nga kuptimi i pandryshueshëmërisë.

Dija e bibliotekës së pasur të metodave të stringjeve (kërkimi, zëvendësimi, ndarje/bashkim, formatimi), sintaksa moderne e interpolimit, dhe praktika e ndërtuar në pandryshueshëmëri e StringBuilder është njohuri bërthamë për punën e vazhdueshme të stringjeve që përfshin programimi — rrjedhshmëria këtu, veçanërisht komoditetin e interpolimit dhe korrigjimin e performancës së StringBuilder, është themelore për të shkruar C# të pastër dhe efikas.