როგორ მუშაობს strings C#-ში?

Question

Accepted Answer

C#-ში **`string`** არის immutable reference type, რომელიც წარმოადგენს ტექსტს. Strings მხარს უჭერს interpolation-ს,풍부한მეთოდების ბიბლიოთეკას და — სამუშაოს შესრულების თვალსაზრისით მნიშვნელოვანია — `StringBuilder` ეფექტური განმეორებითი მოდიფიკაციისთვის.

## String interpolation და შექმნა

```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 interpolation** (`$"..."`) არის თანამედროვე, წაკითხვადი გზა strings-ის აგებისთვის ჩაჯდომილი მნიშვნელობებით და format specifiers-ით. Verbatim (`@`) strings აცილებს escaping-ს (შესანიშნავია paths/regex-ისთვის), და raw string literals (`"""`) ამუშავებს მრავალხაზიან ტექსტს.

## Strings არის 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
```

ყველა ოპერაცია, რომელიც "მოდიფიცირებს" string-ს, ფაქტობრივად ქმნის **ახალ** string-ს (immutability). ეს უსაფრთხოა, მაგრამ აქვს შესრულების ღირებულება განმეორებითი მოდიფიკაციის დროს.

## StringBuilder ეფექტური აგებისთვის

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

Strings-ის აგებისთვის loops-ში, **`StringBuilder`** თავიდან აიცილებს მრავალი შუალედური string-ის შექმნას — ეს არის მნიშვნელოვანი შესრულების პრაქტიკა.

## საერთო string methods-ები

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

## რატომ არის ეს მნიშვნელოვანი

String manipulation პროგრამირებში ყველგან გვხვდება (output აგება, input დამუშავება, data ფორმატირება), ამიტომ C# strings-ის გაგება აუცილებელი ყოველდღიური ცოდნაა.

თანამედროვე features მნიშვნელოვანია პროდუქტიულობისთვის: **string interpolation** (`$"..."`) არის სუფთა, წაკითხვადი გზა strings-ის აგებისთვის ჩაჯდომილი მნიშვნელობებით და ფორმატირებით, ხოლო verbatim/raw string literals ელეგანტურად აკმაყოფილებენ paths-ს და მრავალხაზიან ტექსტს.

კრიტიკულად, გაგება იმ რომ **strings არის immutable** (ყველა "მოდიფიკაცია" ქმნის ახალ string-ს) ხსნის მნიშვნელოვან შესრულების განხილვას: ნაივი **string concatenation loops-ში** არის ფიქალი (O(n²), ბევრი შუალედური string-ის შექმნა), და იმის ცოდნა რომ გამოვიყენოთ **`StringBuilder`** განმეორებითი მოდიფიკაციისთვის (რომელიც ეფექტურად მუტირებს შიდა buffer-ს) არის მნიშვნელოვანი პრაქტიკული ოპტიმიზაცია, რომელიც პირდაპირ მოდის immutability-ს გაგებიდან.

महत्वपूर्ण string method library-ის (search, replace, split/join, formatting), თანამედროვე interpolation syntax-ის, და immutability-driven StringBuilder practice-ის ცოდნა არის ბირთვული ცოდნა strings-ის მუდმივი სამუშაოსთვის — აქაურობა აქ, განსაკუთრებით interpolation სიმბოლურობა და StringBuilder შესრულების გამოჩენა, არის ფუნდამენტური სუფთა, ეფექტური C# წერისთვის.