Cách hiệu quả nhất để nối chuỗi?

Cách hiệu quả nhất để nối chuỗi?

Các StringBuilder.Append()phương pháp là tốt hơn nhiều so với sử dụng các +nhà điều hành. Nhưng tôi đã thấy rằng, khi thực hiện 1000 phép nối hoặc ít hơn, String.Join()thậm chí còn hiệu quả hơn StringBuilder.

StringBuilder sb = new StringBuilder();
sb.Append(someString);

Vấn đề duy nhất String.Joinlà bạn phải nối các chuỗi với một dấu phân cách chung.

Chỉnh sửa: như @ryanversaw đã chỉ ra, bạn có thể tạo dấu phân cách string.Empty.

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Rico Mariani , chuyên gia về hiệu suất .NET, đã có một bài viết về chính chủ đề này. Nó không đơn giản như người ta có thể nghi ngờ. Lời khuyên cơ bản là:

Nếu mô hình của bạn trông như:

x = f1(...) + f2(...) + f3(...) + f4(...)

đó là một concat và nó rất nhanh, StringBuilder có thể sẽ không giúp đỡ.

Nếu mô hình của bạn trông như:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

thì có lẽ bạn muốn StringBuilder.

Tuy nhiên, một bài viết khác để hỗ trợ cho tuyên bố này đến từ Eric Lippert, nơi ông mô tả các tối ưu hóa được thực hiện trên các đường +nối một cách chi tiết.

Có 6 loại nối chuỗi:

1. Sử dụng ký hiệu dấu cộng ( +).
2. Sử dụng string.Concat().
3. Sử dụng string.Join().
4. Sử dụng string.Format().
5. Sử dụng string.Append().
6. Sử dụng StringBuilder.

Trong một thí nghiệm, người ta đã chứng minh rằng đó string.Concat()là cách tốt nhất để tiếp cận nếu các từ nhỏ hơn 1000 (xấp xỉ) và nếu các từ nhiều hơn 1000 thì StringBuildernên sử dụng.

Để biết thêm thông tin, kiểm tra trang web này .

chuỗi.Join () so với chuỗi.Concat ()

Phương thức string.Concat ở đây tương đương với lời gọi phương thức string.Join với một dấu phân cách trống. Nối một chuỗi rỗng thì nhanh, nhưng không làm như vậy thậm chí còn nhanh hơn, vì vậy phương thức string.Concat sẽ tốt hơn ở đây.

Từ Chinh Do - StringBuilder không phải lúc nào cũng nhanh hơn :

Quy tắc của ngón tay cái

• Khi nối ba giá trị chuỗi động trở xuống, hãy sử dụng nối chuỗi truyền thống.

• Khi nối nhiều hơn ba giá trị chuỗi động, hãy sử dụng StringBuilder.

• Khi xây dựng một chuỗi lớn từ một số chuỗi ký tự, hãy sử dụng một trong hai @ chuỗi ký tự hoặc toán tử nội tuyến +.

Hầu hết thời gian StringBuilderlà đặt cược tốt nhất của bạn, nhưng có những trường hợp như thể hiện trong bài đăng đó mà ít nhất bạn nên nghĩ về từng tình huống.

Nếu bạn đang hoạt động trong một vòng lặp, StringBuildercó lẽ là cách để đi; nó giúp bạn tiết kiệm chi phí tạo chuỗi mới thường xuyên. Trong mã sẽ chỉ chạy một lần, tuy nhiên, String.Concatcó lẽ là tốt.

Tuy nhiên, Rico Mariani (chuyên gia tối ưu hóa .NET) đã tạo ra một bài kiểm tra mà cuối cùng ông tuyên bố rằng, trong hầu hết các trường hợp, ông khuyến nghị String.Format.

Đây là phương pháp nhanh nhất tôi đã phát triển trong một thập kỷ cho ứng dụng NLP quy mô lớn của mình. Tôi có các biến thể cho IEnumerable<T>và các loại đầu vào khác, có và không có các dấu phân tách của các loại khác nhau ( Char, String), nhưng ở đây tôi chỉ ra trường hợp đơn giản là nối tất cả các chuỗi trong một mảng thành một chuỗi, không có dấu phân cách. Phiên bản mới nhất ở đây được phát triển và thử nghiệm đơn vị trên C # 7 và .NET 4.7 .

Có hai chìa khóa để hiệu suất cao hơn; đầu tiên là tính toán trước tổng kích thước chính xác cần thiết. Bước này là tầm thường khi đầu vào là một mảng như được hiển thị ở đây. Để xử lý IEnumerable<T>thay vào đó, trước tiên, đáng để tập hợp các chuỗi thành một mảng tạm thời để tính tổng đó (Mảng được yêu cầu để tránh gọi ToString()nhiều hơn một lần cho mỗi phần tử vì về mặt kỹ thuật, do khả năng tác dụng phụ, làm như vậy có thể thay đổi ngữ nghĩa dự kiến của một hoạt động 'chuỗi tham gia').

Tiếp theo, với tổng kích thước phân bổ của chuỗi cuối cùng, hiệu suất tăng mạnh nhất đạt được bằng cách xây dựng chuỗi kết quả tại chỗ . Làm điều này đòi hỏi kỹ thuật (có lẽ gây tranh cãi) tạm thời đình chỉ tính bất biến của một cái mới Stringban đầu được phân bổ đầy đủ các số không. Bất kỳ tranh cãi như vậy sang một bên, tuy nhiên ...

... Lưu ý rằng đây là giải pháp ghép nối hàng loạt duy nhất trên trang này, điều này hoàn toàn tránh được một vòng phân bổ và sao chép bổ sung của nhà Stringxây dựng.

Mã hoàn chỉnh:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

Tôi nên đề cập rằng mã này có một sửa đổi nhỏ từ những gì tôi sử dụng bản thân mình. Trong bản gốc, tôi gọi hướng dẫn cpblk IL từ C # để thực hiện sao chép thực tế. Để đơn giản và tính di động trong mã ở đây, tôi đã thay thế bằng P / Gọi memcpythay thế, như bạn có thể thấy. Để có hiệu suất cao nhất trên x64 ( nhưng có thể không phải là x86 ), bạn có thể muốn sử dụng phương thức cpblk thay thế.

Từ bài viết MSDN này :

Có một số chi phí liên quan đến việc tạo một đối tượng StringBuilder, cả về thời gian và bộ nhớ. Trên một máy có bộ nhớ nhanh, StringBuilder trở nên đáng giá nếu bạn thực hiện khoảng năm thao tác. Theo nguyên tắc thông thường, tôi sẽ nói 10 thao tác chuỗi trở lên là sự biện minh cho chi phí hoạt động trên bất kỳ máy nào, thậm chí là chậm hơn.

Vì vậy, nếu bạn tin tưởng MSDN, hãy sử dụng StringBuilder nếu bạn phải thực hiện hơn 10 chuỗi thao tác / nối chuỗi - nếu không thì chuỗi chuỗi đơn giản với '+' là ổn.

Điều quan trọng nữa là chỉ ra rằng bạn nên sử dụng +toán tử nếu bạn đang nối chuỗi ký tự .

Khi bạn nối chuỗi ký tự chuỗi hoặc hằng chuỗi bằng cách sử dụng toán tử +, trình biên dịch sẽ tạo ra một chuỗi. Không có thời gian chạy nối xảy ra.

Cách: Nối nhiều chuỗi (Hướng dẫn lập trình C #)

Thêm vào các câu trả lời khác, xin lưu ý rằng StringBuilder có thể được cho biết một lượng bộ nhớ ban đầu để phân bổ .

Các khả năng tham số xác định số ký tự tối đa có thể được lưu trữ trong bộ nhớ được phân bổ bởi các trường hợp hiện nay. Giá trị của nó được gán cho thuộc tính Năng lực . Nếu số lượng ký tự được lưu trữ trong phiên bản hiện tại vượt quá giá trị dung lượng này , đối tượng StringBuilder sẽ cấp phát bộ nhớ bổ sung để lưu trữ chúng.

Nếu dung lượng bằng 0, dung lượng mặc định dành riêng cho triển khai được sử dụng.

Việc liên tục nối thêm vào StringBuilder chưa được phân bổ trước có thể dẫn đến rất nhiều phân bổ không cần thiết giống như liên tục nối các chuỗi thông thường.

Nếu bạn biết chuỗi cuối cùng sẽ kéo dài bao lâu, có thể tính toán nó một cách tầm thường hoặc có thể đưa ra phỏng đoán có giáo dục về trường hợp phổ biến (phân bổ quá nhiều không nhất thiết là điều xấu), bạn nên cung cấp thông tin này cho nhà xây dựng hoặc Năng lực tài sản. Đặc biệt là khi chạy các bài kiểm tra hiệu năng để so sánh StringBuilder với các phương thức khác như String.Concat, chúng thực hiện cùng một thứ trong nội bộ. Bất kỳ thử nghiệm nào bạn thấy trực tuyến không bao gồm phân bổ trước StringBuilder trong các so sánh của nó đều sai.

Nếu bạn không thể đưa ra bất kỳ loại dự đoán nào về kích thước, có lẽ bạn đang viết một hàm tiện ích sẽ có đối số tùy chọn riêng để kiểm soát phân bổ trước.

Sau đây có thể là một giải pháp thay thế khác để nối nhiều chuỗi.

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

nội suy chuỗi

Hiệu quả nhất là sử dụng StringBuilder, như vậy:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy: String.Concat vẫn ổn nếu bạn có một vài điều nhỏ nhặt. Nhưng nếu bạn đang kết hợp megabyte dữ liệu, chương trình của bạn có thể sẽ tăng.

Hãy thử 2 đoạn mã này và bạn sẽ tìm thấy giải pháp.

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

Vs

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

Bạn sẽ thấy rằng mã thứ 1 sẽ kết thúc thực sự nhanh chóng và bộ nhớ sẽ có số lượng tốt.

Mã thứ hai có thể bộ nhớ sẽ ổn, nhưng sẽ mất nhiều thời gian hơn ... lâu hơn nhiều. Vì vậy, nếu bạn có một ứng dụng cho nhiều người dùng và bạn cần tốc độ, hãy sử dụng ứng dụng thứ nhất. Nếu bạn có một ứng dụng cho một ứng dụng người dùng ngắn hạn, có thể bạn có thể sử dụng cả hai hoặc thứ 2 sẽ "tự nhiên" hơn cho các nhà phát triển.

Chúc mừng.

Đối với chỉ hai chuỗi, bạn chắc chắn không muốn sử dụng StringBuilder. Có một số ngưỡng trên đó chi phí hoạt động của StringBuilder thấp hơn chi phí phân bổ nhiều chuỗi.

Vì vậy, để có thêm 2-3 chuỗi, hãy sử dụng mã của DanielSmurf . Nếu không, chỉ cần sử dụng toán tử +.

System.String là bất biến. Khi chúng ta sửa đổi giá trị của biến chuỗi thì bộ nhớ mới được phân bổ cho giá trị mới và phân bổ bộ nhớ trước đó được giải phóng. System.StringBuilder được thiết kế để có khái niệm về một chuỗi có thể thay đổi trong đó nhiều hoạt động có thể được thực hiện mà không cần phân bổ vị trí bộ nhớ riêng cho chuỗi đã sửa đổi.

Giải pháp khác:

bên trong vòng lặp, sử dụng Danh sách thay vì chuỗi.

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

nó rất rất nhanh

Nó thực sự phụ thuộc vào mô hình sử dụng của bạn. Một điểm chuẩn chi tiết giữa chuỗi.Join, chuỗi, concat và chuỗi.Format có thể được tìm thấy ở đây: String.Format không phù hợp để ghi nhật ký chuyên sâu

(Đây thực sự là cùng một câu trả lời tôi đã đưa ra cho câu hỏi này )

Nó sẽ phụ thuộc vào mã. StringBuilder thường hiệu quả hơn, nhưng nếu bạn chỉ nối một vài chuỗi và thực hiện tất cả trong một dòng, tối ưu hóa mã có thể sẽ chăm sóc nó cho bạn. Điều quan trọng là phải suy nghĩ về cách mã trông như thế nào: đối với các tập lớn hơn StringBuilder sẽ giúp dễ đọc hơn, đối với các tập nhỏ, StringBuilder sẽ chỉ thêm lộn xộn không cần thiết.