C# String: Uzunluk, Karşılaştırma, Kaçış Karakterleri, Verbatim ve Çok Satırlı String'ler

C#'ta bir string, UTF-16 karakterlerinden (char değerleri) oluşan bir dizidir. Bir referans tipidir, ama önemli açılardan bir değer gibi davranır: değiştirilemezdir ve == nesne kimliğini değil metni karşılaştırır. string, .NET tipi System.String için C# anahtar kelimesidir; ikisi birbirinin yerine kullanılabilir.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Çıktı:

Porto
5
0
*****
hi
Porto has 5 letters

String'ler değiştirilemez

Hiçbir metot bir string'i yerinde değiştirmez. ToUpper, Replace, Trim ve diğer tüm metotlar yeni bir string döndürür ve orijinaline dokunmaz. Dönüş değerini kullanmayı unutmak çok yaygın bir string hatasıdır:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Çıktı:

[  maya  ]
[MAYA]
tea
tea and cake

Değiştirilemezlik, string'lerin thread'ler arasında paylaşılmasını ve dictionary anahtarı olarak kullanılmasını güvenli kılar. Bedeli, bir döngüde bir string'i parça parça oluşturmanın her adımda yeni bir string yaratmasıdır; bunun için StringBuilder kullanın.

Uzunluk ve indeksleme

Length bir property'dir (parantez yok). s[i] indeksleyicisi, 0'dan saymaya başlayarak i konumundaki char'ı döndürür ve salt okunurdur:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Çıktı:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 ve sonrası sondan bir indeksi de kabul eder: code[^1] son karakterdir, code[code.Length - 1] ile aynıdır. Birkaç karakteri birden almak için substring sayfasına bakın.

Length bir okuyucunun karakter olarak gördüğünü değil, UTF-16 kod birimlerini sayar. Çoğu dildeki çoğu harf tek birimdir, ama emoji ve bazı nadir yazı sistemleri iki birim kullanır (bir surrogate çifti), bu yüzden "👍".Length 2'dir.

String'leri karşılaştırmak

== ve != karakterleri büyük/küçük harfe duyarlı olarak karşılaştırır. Diğer her şey için nasıl karşılaştırılacağını söyleyen bir StringComparison değeri verin:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Çıktı:

False
False
True
True
apple first
True
False
False
True

Hangi karşılaştırmayı kullanmalı:

• Ordinal sayısal karakter kodlarını karşılaştırır. Hızlıdır, öngörülebilirdir ve her makinede aynıdır. Tanımlayıcılar, dosya adları, anahtarlar, protokol değerleri ve bir insana gösterilmeyen her şey için kullanın.
• OrdinalIgnoreCase aynısıdır, harf büyüklüğünü yok sayar. Dosya uzantıları ya da HTTP başlıkları gibi harf duyarsız kontroller için doğru seçimdir.
• CurrentCulture (ve CurrentCultureIgnoreCase) kullanıcının dilinin kurallarını izler, böylece kelimeleri o dildeki bir sözlüğün sıralayacağı gibi sıralar. Kullanıcılara gösterilen listeleri sıralamak için kullanın.
• InvariantCulture kullanıcının dil ayarlarına bağlı olmayan kültüre duyarlı kurallar kullanır. Yine de globalleştirme kütüphanesine bağlıdır: modern .NET ICU kullanır, .NET Framework Windows'un NLS'ini kullanır ve ikisi bazı string'leri farklı sıralayabilir.

StringComparison olmadan string.Compare(a, b) ve a.CompareTo(b) geçerli kültürü kullanır; bu da sonuçlarının makineden makineye değişmesine yol açar. a.ToLower() == b.ToLower() ile karşılaştırmaktan kaçının: iki yeni string ayırır ve bazı kültürlerde yanlış cevaplar verir (Türkçedeki noktalı ve noktasız i klasik örnektir).

a null iken a.Equals(b) çağırmak bir NullReferenceException fırlatır; a == b ve statik string.Equals(a, b) ise null'ı güvenle ele alır.

Kaçış karakterleri

Normal bir string literal'inin içinde ters eğik çizgi bir kaçış dizisi başlatır:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Çıktı:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

"\d" gibi tanınmayan bir dizi derleme hatasıdır (CS1009, unrecognized escape sequence); bir Windows yolu ya da bir düzenli ifade normal string olarak yazıldığında olan budur.

Verbatim string'ler ve çok satırlı string'ler

Bir literal'in önüne @ koymak onu verbatim yapar: ters eğik çizgiler olduğu gibi karakterlerdir ve string birkaç satıra yayılabilir. Geriye kalan tek kaçış, tek bir çift tırnak üreten ""'dir.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Çıktı:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

Verbatim çok satırlı bir string, devam satırlarının girintisi dahil tırnaklar arasındaki her şeyi içerir; bu yüzden genellikle yukarıdaki gibi kenar boşluğuna yaslanarak yazılır. İçerdiği satır sonları kaynak dosyadakilerdir, yani Windows satır sonlarıyla kaydedilmiş bir dosya \r\n üretir.

C# 11, iki sorunu da çözen ham string literal'lerini ekledi. Üç ya da daha fazla çift tırnakla başlayıp biterler, hiç kaçış gerektirmezler ve kapanış tırnaklarının girintisi kadar girintiyi kaldırırlar:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

İçeriğin kendisi """ içeriyorsa bunun yerine dört tırnakla başlayıp bitirin. Ham literal'ler interpolation ile de birleşir ($"""..."""); bkz. string interpolation.

Null, boş ve boşluk

Bir string değişkeni null (hiç string yok), boş ("", uzunluk 0) olabilir ya da yalnızca boşluk karakterleri içerebilir. İki statik yardımcı bu durumları NullReferenceException riski olmadan kontrol eder:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Çıktı:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Kullanıcı girdisini doğrulamak için neredeyse her zaman istediğiniz string.IsNullOrWhiteSpace'tir. string.Empty ve "" aynı değerdir; hangisinin yazılacağı stil meselesidir.

Karakterler üzerinde döngü

Bir string numaralandırılabilirdir, bu yüzden foreach her char'ı ziyaret eder. char tipinin karakterleri sınıflandıran statik metotları vardır:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Çıktı:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

String'leri birleştirmek

+ birleştirir ve diğer tarafta her tiple çalışır (ToString() çağırır). Birçok değeri birleştirmek için interpolation ya da string.Join'i tercih edin:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Çıktı:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

Son iki satır bir öncelik tuzağını gösterir: + soldan sağa değerlendirilir, bu yüzden sol taraf bir string olduğu anda sonraki her + birleştirmedir. Birleştirme içindeki aritmetiği parantez içine alın.