Chuỗi trong C#: Length, so sánh, ký tự escape, chuỗi verbatim và nhiều dòng

Một string trong C# là một dãy ký tự UTF-16 (các giá trị char). Đây là kiểu tham chiếu, nhưng hoạt động giống một giá trị ở những điểm quan trọng: chuỗi là bất biến (immutable), và == so sánh nội dung văn bản chứ không so sánh danh tính đối tượng. string là từ khóa C# cho kiểu .NET System.String; hai cách viết dùng thay cho nhau được.

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

Đầu ra:

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

Chuỗi là bất biến

Không có phương thức nào thay đổi chuỗi tại chỗ. ToUpper, Replace, Trim và mọi phương thức khác đều trả về một chuỗi mới và giữ nguyên chuỗi gốc. Quên dùng giá trị trả về là một bug rất hay gặp với chuỗi:

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

Đầu ra:

[  maya  ]
[MAYA]
tea
tea and cake

Tính bất biến giúp chuỗi an toàn khi chia sẻ giữa các luồng và khi dùng làm khóa của dictionary. Cái giá phải trả là việc ghép chuỗi từng mảnh trong vòng lặp sẽ tạo ra một chuỗi mới ở mỗi bước; trường hợp đó hãy dùng StringBuilder.

Length và chỉ số

Length là một thuộc tính (không có dấu ngoặc). Indexer s[i] trả về char ở vị trí i, đếm từ 0, và chỉ đọc được:

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

Đầu ra:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 trở đi còn chấp nhận chỉ số tính từ cuối: code[^1] là ký tự cuối cùng, giống code[code.Length - 1]. Để lấy nhiều ký tự cùng lúc, xem substring.

Length đếm số đơn vị mã UTF-16, không phải số ký tự mà người đọc nhìn thấy. Phần lớn chữ cái trong phần lớn ngôn ngữ chiếm một đơn vị, nhưng emoji và một số hệ chữ hiếm dùng hai đơn vị (một cặp surrogate), nên "👍".Length bằng 2.

So sánh chuỗi

== và != so sánh từng ký tự, có phân biệt hoa thường. Với các trường hợp khác, hãy truyền một giá trị StringComparison cho biết cách so sánh:

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

Đầu ra:

False
False
True
True
apple first
True
False
False
True

Nên dùng phép so sánh nào:

• Ordinal so sánh mã số của các ký tự. Nhanh, dễ đoán và giống nhau trên mọi máy. Dùng cho định danh, tên tệp, khóa, giá trị giao thức và mọi thứ không hiển thị cho người dùng.
• OrdinalIgnoreCase giống như trên nhưng bỏ qua hoa thường. Đây là lựa chọn đúng cho các phép kiểm tra không phân biệt hoa thường như phần mở rộng tệp hay HTTP header.
• CurrentCulture (và CurrentCultureIgnoreCase) theo quy tắc ngôn ngữ của người dùng, nên sắp xếp từ ngữ như từ điển của ngôn ngữ đó. Dùng để sắp xếp danh sách hiển thị cho người dùng.
• InvariantCulture dùng quy tắc theo văn hóa nhưng không phụ thuộc vào cài đặt ngôn ngữ của người dùng. Nó vẫn phụ thuộc vào thư viện toàn cầu hóa: .NET hiện đại dùng ICU, .NET Framework dùng NLS của Windows, và hai thư viện này có thể sắp xếp một số chuỗi khác nhau.

string.Compare(a, b) và a.CompareTo(b) khi không có StringComparison sẽ dùng văn hóa hiện tại, khiến kết quả thay đổi giữa các máy. Tránh so sánh kiểu a.ToLower() == b.ToLower(): cách này cấp phát hai chuỗi mới và cho kết quả sai ở một số văn hóa (chữ i có chấm và không chấm trong tiếng Thổ Nhĩ Kỳ là ví dụ kinh điển).

Gọi a.Equals(b) khi a là null sẽ ném NullReferenceException, còn a == b và phương thức tĩnh string.Equals(a, b) xử lý null an toàn.

Ký tự escape

Bên trong một string literal thông thường, dấu gạch chéo ngược mở đầu một chuỗi escape (escape sequence):

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

Đầu ra:

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

Một chuỗi không nhận dạng được như "\d" là lỗi biên dịch (CS1009, unrecognized escape sequence), đây chính là điều xảy ra khi đường dẫn Windows hoặc biểu thức chính quy được viết bằng chuỗi thông thường.

Chuỗi verbatim và chuỗi nhiều dòng

Thêm tiền tố @ trước literal sẽ biến nó thành chuỗi verbatim: dấu gạch chéo ngược là ký tự bình thường, và chuỗi có thể trải trên nhiều dòng. Escape duy nhất còn lại là "", tạo ra một dấu nháy kép.

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

Đầu ra:

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

Một chuỗi verbatim nhiều dòng chứa mọi thứ nằm giữa hai dấu nháy, kể cả phần thụt lề của các dòng tiếp theo, vì vậy chúng thường được viết sát lề như ví dụ trên. Các dấu xuống dòng bên trong là dấu xuống dòng của tệp nguồn, nên một tệp lưu với kiểu xuống dòng của Windows sẽ cho ra \r\n.

C# 11 bổ sung raw string literal, giải quyết cả hai vấn đề. Chúng bắt đầu và kết thúc bằng ba dấu nháy kép trở lên, hoàn toàn không cần escape, và bỏ đi phần thụt lề bằng đúng mức thụt lề của dấu nháy đóng:

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

Nếu nội dung chứa """, hãy mở và đóng bằng bốn dấu nháy. Raw literal cũng kết hợp được với nội suy ($"""..."""); xem nội suy chuỗi.

Null, rỗng và khoảng trắng

Một biến chuỗi có thể là null (không có chuỗi nào), rỗng ("", độ dài 0), hoặc chỉ chứa khoảng trắng. Hai phương thức tĩnh kiểm tra những trường hợp này mà không có nguy cơ gặp NullReferenceException:

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 == "");
    }
}

Đầu ra:

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

Để kiểm tra dữ liệu người dùng nhập vào, string.IsNullOrWhiteSpace gần như luôn là lựa chọn bạn cần. string.Empty và "" là cùng một giá trị; viết cách nào là tùy phong cách.

Duyệt qua các ký tự

Chuỗi có thể duyệt (enumerable), nên foreach đi qua từng char. Kiểu char có các phương thức tĩnh để phân loại ký tự:

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

Đầu ra:

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

Nối chuỗi

+ nối chuỗi, và chấp nhận mọi kiểu ở phía bên kia (nó gọi ToString()). Khi kết hợp nhiều giá trị, nên dùng nội suy hoặc string.Join:

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"
    }
}

Đầu ra:

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

Hai dòng cuối cho thấy một cái bẫy về độ ưu tiên: + được tính từ trái sang phải, nên một khi vế trái là chuỗi, mọi dấu + tiếp theo đều là phép nối chuỗi. Hãy đặt phép tính số học trong dấu ngoặc khi nằm giữa một phép nối chuỗi.