引言

字符串拼接是編程中常見的操作，尤其在處理文本數(shù)據(jù)時更是如此。在 C# 中，字符串拼接有多種方式，每種方式都有其適用場景和性能特點。了解這些方式及其性能差異，可以幫助我們編寫更高效、更可讀的代碼。本文將詳細介紹 C# 中字符串拼接的 7 種常見方式，并通過性能對比分析它們的優(yōu)缺點。

字符串拼接的 7 種方式

1. 使用+ 或+= 運算符

這是最簡單直接的字符串拼接方式，適用于拼接少量字符串。在后臺，C# 編譯器會將使用+ 運算符的拼接轉換為String.Concat 方法的調(diào)用。

string result = "Hello" + ", " + "World" + "!";

優(yōu)點

• 代碼簡潔：對于少量字符串的拼接，代碼非常直觀和簡潔。

缺點

• 性能較差：當拼接大量字符串時，每次拼接都會創(chuàng)建一個新的字符串對象，因為字符串在 C# 中是不可變的。這會導致頻繁的內(nèi)存分配和回收，影響性能。

2. 使用StringBuilder 類

StringBuilder 是專為字符串拼接設計的類，它通過維護一個可變的字符數(shù)組來避免頻繁的內(nèi)存分配。

StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(", ");
sb.Append("World");
sb.Append("!");
string result = sb.ToString();

優(yōu)點

• 性能優(yōu)越：在拼接大量字符串時，性能顯著優(yōu)于使用+ 運算符。StringBuilder 可以在內(nèi)部動態(tài)調(diào)整字符數(shù)組的大小，減少內(nèi)存分配次數(shù)。
• 靈活性高：提供了多種方法來操作字符串，如Append、AppendLine、Insert、Remove 等。

缺點

• 代碼稍顯冗長：相比于使用+ 運算符，代碼量稍多，但對于大量拼接操作，這是值得的。

3. 使用String.Concat 方法

String.Concat 方法可以將多個字符串參數(shù)連接成一個字符串。它是+ 運算符拼接的底層實現(xiàn)。

string result = String.Concat("Hello", ", ", "World", "!");

優(yōu)點

• 代碼簡潔：與使用+ 運算符類似，代碼簡潔。
• 性能適中：在拼接少量字符串時，性能與+ 運算符相當。

缺點

• 性能限制：在拼接大量字符串時，性能不如StringBuilder。

4. 使用String.Join 方法

String.Join 方法可以將字符串數(shù)組或枚舉中的字符串元素連接成一個字符串，并在元素之間插入指定的分隔符。

string[] parts = { "Hello", "World", "!" };
string result = String.Join(", ", parts);

優(yōu)點

• 代碼可讀性好：當需要在字符串之間插入相同的分隔符時，代碼非常清晰。
• 性能適中：在拼接少量字符串時，性能與+ 運算符相當。

缺點

• 不適用于無分隔符拼接：如果不需要分隔符，使用String.Join 會稍顯繁瑣。

5. 使用字符串插值

字符串插值是 C# 6.0 引入的特性，它允許在字符串文字中直接插入表達式的值。

string name = "World";
string result = $"Hello, {name}!";

優(yōu)點

• 代碼可讀性極佳：可以寫出非常直觀和易讀的代碼，特別是在需要插入變量或表達式時。
• 編譯時檢查：插入的表達式在編譯時會進行類型檢查，減少了運行時錯誤。

缺點

• 性能適中：在拼接大量字符串時，性能不如StringBuilder，但通常足夠滿足日常需求。

6. 使用String.Format 方法

String.Format 方法可以根據(jù)指定的格式字符串和參數(shù)，生成一個格式化的字符串。

string name = "World";
string result = String.Format("Hello, {0}!", name);

優(yōu)點

• 強大的格式化能力：可以對插入的值進行復雜的格式化操作，適用于需要精確控制輸出格式的場景。
• 代碼可讀性好：格式化字符串清晰地展示了最終輸出的結構。

缺點

• 性能適中：與字符串插值類似，在拼接大量字符串時，性能不如StringBuilder。

7. 使用Concat 擴展方法

LINQ 提供了一個Concat 擴展方法，可以將兩個序列連接起來。雖然它主要用于序列操作，但也可以用于字符串拼接。

string result = "Hello".Concat(", ", "World", "!");

優(yōu)點

• 代碼簡潔：對于簡單的拼接操作，代碼非常簡潔。

缺點

• 性能較差：與使用+ 運算符類似，每次拼接都會創(chuàng)建新的字符串對象，性能較差。
• 可讀性差：對于不熟悉 LINQ 的開發(fā)者，代碼可讀性可能較差。

性能對比

為了對比這些字符串拼接方式的性能，我們可以編寫一個簡單的性能測試程序，分別使用這些方式拼接大量的字符串，并記錄執(zhí)行時間。以下是一個示例測試程序：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

class Program
{
    static void Main()
    {
        int iterations = 10000;
        string[] parts = new string[iterations];
        for (int i = 0; i < iterations; i++)
        {
            parts[i] = "Part" + i;
        }

        // 使用 + 運算符
        Stopwatch sw = Stopwatch.StartNew();
        string result = "";
        for (int i = 0; i < iterations; i++)
        {
            result += parts[i];
        }
        sw.Stop();
        Console.WriteLine($"Using +: {sw.ElapsedMilliseconds} ms");

        // 使用 StringBuilder
        sw = Stopwatch.StartNew();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < iterations; i++)
        {
            sb.Append(parts[i]);
        }
        result = sb.ToString();
        sw.Stop();
        Console.WriteLine($"Using StringBuilder: {sw.ElapsedMilliseconds} ms");

        // 使用 String.Concat
        sw = Stopwatch.StartNew();
        result = String.Concat(parts);
        sw.Stop();
        Console.WriteLine($"Using String.Concat: {sw.ElapsedMilliseconds} ms");

        // 使用 String.Join
        sw = Stopwatch.StartNew();
        result = String.Join("", parts);
        sw.Stop();
        Console.WriteLine($"Using String.Join: {sw.ElapsedMilliseconds} ms");

        // 使用字符串插值
        sw = Stopwatch.StartNew();
        result = "";
        for (int i = 0; i < iterations; i++)
        {
            result = $"{result}{parts[i]}";
        }
        sw.Stop();
        Console.WriteLine($"Using String Interpolation: {sw.ElapsedMilliseconds} ms");

        // 使用 String.Format
        sw = Stopwatch.StartNew();
        result = "";
        for (int i = 0; i < iterations; i++)
        {
            result = String.Format("{0}{1}", result, parts[i]);
        }
        sw.Stop();
        Console.WriteLine($"Using String.Format: {sw.ElapsedMilliseconds} ms");

        // 使用 Concat 擴展方法
        sw = Stopwatch.StartNew();
        result = parts.Aggregate((current, next) => current.Concat(next));
        sw.Stop();
        Console.WriteLine($"Using Concat Extension Method: {sw.ElapsedMilliseconds} ms");
    }
}

測試結果分析

從測試結果可以看出：

• StringBuilder 性能最佳：在拼接大量字符串時，執(zhí)行時間最短，性能顯著優(yōu)于其他方式。
• String.Join 性能較好：在拼接字符串數(shù)組或枚舉時，性能較好，且代碼可讀性高。
• + 運算符和Concat 擴展方法性能較差：執(zhí)行時間最長，不適用于拼接大量字符串。
• 字符串插值和String.Format 性能適中：在拼接少量字符串或需要格式化時，性能可以接受

閱讀原文：原文鏈接