Cara paling efisien untuk menggabungkan string?

Apa cara paling efisien untuk menggabungkan string?

The StringBuilder.Append()Metode jauh lebih baik daripada menggunakan +operator. Tetapi saya telah menemukan bahwa, ketika menjalankan 1000 concatenations atau kurang, String.Join()bahkan lebih efisien daripada StringBuilder.

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

Satu-satunya masalah dengan String.Joinadalah Anda harus menyatukan senar dengan pembatas umum.

Sunting: seperti yang ditunjukkan @ryanversaw , Anda dapat membuat pembatas string.Empty.

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

Rico Mariani , guru .NET Performance, memiliki artikel tentang hal ini. Ini tidak sesederhana yang diduga. Saran dasar adalah ini:

Jika pola Anda terlihat seperti:

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

itu salah satu concat dan zippy, StringBuilder mungkin tidak akan membantu.

Jika pola Anda terlihat seperti:

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

maka Anda mungkin ingin StringBuilder.

Namun artikel lain untuk mendukung klaim ini berasal dari Eric Lippert di mana ia menggambarkan optimasi yang dilakukan pada satu baris +gabungan secara terperinci.

Ada 6 jenis rangkaian string:

1. Menggunakan plus (+ simbol ).
2. Menggunakan string.Concat().
3. Menggunakan string.Join().
4. Menggunakan string.Format().
5. Menggunakan string.Append().
6. Menggunakan StringBuilder.

Dalam percobaan, telah terbukti bahwa itu string.Concat()adalah cara terbaik untuk mendekati jika kata-katanya kurang dari 1000 (kurang-lebih) dan jika kata-kata lebih dari 1000 makaStringBuilder harus digunakan.

Untuk informasi lebih lanjut, periksa situs ini .

string.Join () vs string.Concat ()

Metode string.Compat di sini setara dengan doa metode string.Join dengan pemisah kosong. Menambahkan string kosong cepat, tetapi tidak melakukannya bahkan lebih cepat, jadi metode string.Compat akan lebih unggul di sini.

From Chinh Do - StringBuilder tidak selalu lebih cepat :

Aturan Jempol

• Saat menggabungkan tiga nilai string dinamis atau kurang, gunakan gabungan string tradisional.

• Saat menggabungkan lebih dari tiga nilai string dinamis, gunakan StringBuilder.

• Saat membuat string besar dari beberapa string literal, gunakan @string string literal atau inline +.

Sebagian besar waktu StringBuilderadalah taruhan terbaik Anda, tetapi ada kasus-kasus seperti yang ditunjukkan dalam posting bahwa Anda setidaknya harus memikirkan setiap situasi.

Jika Anda beroperasi dalam satu lingkaran, StringBuildermungkin ini cara yang harus dilakukan; ini menghemat biaya pembuatan string baru secara teratur. Dalam kode yang hanya akan berjalan sekali, String.Concatmungkin saja baik-baik saja.

Namun, Rico Mariani (.NET optimisasi guru) membuat kuis di mana ia menyatakan pada akhirnya bahwa, dalam banyak kasus, ia merekomendasikan String.Format.

Ini adalah metode tercepat yang telah saya kembangkan selama satu dekade untuk aplikasi NLP skala besar saya. Saya memiliki variasi untuk IEnumerable<T>dan tipe input lainnya, dengan dan tanpa pemisah dari tipe yang berbeda ( Char, String), tetapi di sini saya menunjukkan kasus sederhana menggabungkan semua string dalam array menjadi string tunggal, tanpa pemisah. Versi terbaru di sini dikembangkan dan diuji unit pada C # 7 dan .NET 4.7 .

Ada dua kunci untuk kinerja yang lebih tinggi; yang pertama adalah melakukan pra-perhitungan ukuran total persis yang dibutuhkan. Langkah ini sepele ketika input adalah array seperti yang ditunjukkan di sini. Untuk penanganan IEnumerable<T>sebagai gantinya, ada baiknya mengumpulkan string menjadi array sementara untuk menghitung total (Array diperlukan untuk menghindari memanggil ToString()lebih dari sekali per elemen karena secara teknis, mengingat kemungkinan efek samping, hal itu dapat mengubah semantik yang diharapkan. dari operasi 'string join').

Selanjutnya, mengingat ukuran alokasi total string akhir, dorongan terbesar dalam kinerja diperoleh dengan membangun string hasil di tempat . Melakukan hal ini memerlukan teknik (mungkin kontroversial) untuk sementara menangguhkan ketidakmampuan baru Stringyang awalnya dialokasikan penuh dengan nol. Terlepas dari kontroversi semacam itu, bagaimanapun ...

... perhatikan bahwa ini adalah satu-satunya solusi penggabungan massal pada halaman ini yang sepenuhnya menghindari putaran alokasi dan penyalinan tambahan oleh Stringkonstruktor.

Kode lengkap:

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

Saya harus menyebutkan bahwa kode ini memiliki sedikit modifikasi dari apa yang saya gunakan sendiri. Dalam dokumen asli, saya memanggil instruksi cpblk IL dari C # untuk melakukan penyalinan yang sebenarnya. Untuk kesederhanaan dan portabilitas dalam kode di sini, saya menggantinya dengan P / Invoke memcpy, seperti yang Anda lihat. Untuk kinerja tertinggi pada x64 ( tapi mungkin bukan x86 ), Anda mungkin ingin menggunakan metode cpblk .

Dari artikel MSDN ini :

Ada beberapa overhead yang terkait dengan membuat objek StringBuilder, baik dalam waktu maupun memori. Pada mesin dengan memori cepat, StringBuilder menjadi berguna jika Anda melakukan sekitar lima operasi. Sebagai aturan praktis, saya akan mengatakan 10 atau lebih operasi string adalah pembenaran untuk overhead pada mesin apa pun, bahkan yang lebih lambat.

Jadi, jika Anda mempercayai MSDN, gunakan StringBuilder jika Anda harus melakukan lebih dari 10 operasi string / gabungan - jika tidak, string string sederhana dengan '+' tidak masalah.

Penting juga untuk menunjukkan bahwa Anda harus menggunakan +operator jika Anda menggabungkan string string .

Ketika Anda menggabungkan string literal atau konstanta string dengan menggunakan operator +, kompiler membuat string tunggal. Tidak ada gabungan waktu proses.

How to: Concatenate Multiple Strings (Panduan Pemrograman C #)

Menambah jawaban lain, harap diingat bahwa StringBuilder dapat diberi tahu jumlah memori awal yang akan dialokasikan .

The kapasitas parameter mendefinisikan jumlah maksimum karakter yang dapat disimpan dalam memori yang dialokasikan oleh contoh saat. Nilainya ditugaskan ke properti Kapasitas . Jika jumlah karakter yang akan disimpan dalam instance saat ini melebihi nilai kapasitas ini , objek StringBuilder mengalokasikan memori tambahan untuk menyimpannya.

Jika kapasitas nol, kapasitas standar khusus implementasi digunakan.

Berulang kali menambahkan ke StringBuilder yang belum dialokasikan sebelumnya dapat menghasilkan banyak alokasi yang tidak perlu seperti berulang kali merangkai string biasa.

Jika Anda tahu berapa lama string terakhir akan, dapat menghitungnya secara sepele, atau dapat membuat tebakan yang berpendidikan tentang kasus umum (mengalokasikan terlalu banyak tidak selalu merupakan hal yang buruk), Anda harus memberikan informasi ini kepada konstruktor atau Properti kapasitas . Terutama ketika menjalankan tes kinerja untuk membandingkan StringBuilder dengan metode lain seperti String.Concat, yang melakukan hal yang sama secara internal. Setiap tes yang Anda lihat online yang tidak termasuk pra-alokasi StringBuilder dalam perbandingannya salah.

Jika Anda tidak dapat menebak apa pun tentang ukuran, Anda mungkin menulis fungsi utilitas yang seharusnya memiliki argumen opsional sendiri untuk mengendalikan pra-alokasi.

Mengikuti mungkin merupakan satu solusi alternatif untuk menggabungkan beberapa string.

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

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

interpolasi string

Yang paling efisien adalah menggunakan StringBuilder, seperti:

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

@jonezy: String.Compat baik-baik saja jika Anda memiliki beberapa hal kecil. Tetapi jika Anda menggabungkan megabita data, program Anda kemungkinan akan bertambah.

Coba 2 buah kode ini dan Anda akan menemukan solusinya.

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

Anda akan menemukan bahwa kode 1 akan berakhir sangat cepat dan memori akan dalam jumlah yang baik.

Kode kedua mungkin memori akan baik-baik saja, tetapi akan memakan waktu lebih lama ... lebih lama. Jadi jika Anda memiliki aplikasi untuk banyak pengguna dan Anda membutuhkan kecepatan, gunakan tanggal 1. Jika Anda memiliki aplikasi untuk aplikasi satu pengguna jangka pendek, mungkin Anda bisa menggunakan keduanya atau yang ke-2 akan lebih "alami" untuk pengembang.

Bersulang.

Untuk hanya dua string, Anda pasti tidak ingin menggunakan StringBuilder. Ada beberapa ambang di atas yang overhead StringBuilder kurang dari overhead mengalokasikan beberapa string.

Jadi, untuk lebih dari 2-3 string, gunakan kode DannySmurf . Jika tidak, cukup gunakan operator +.

System.String tidak dapat diubah. Ketika kita memodifikasi nilai variabel string maka memori baru dialokasikan ke nilai baru dan alokasi memori sebelumnya dirilis. System.StringBuilder dirancang untuk memiliki konsep string yang dapat berubah di mana berbagai operasi dapat dilakukan tanpa mengalokasikan lokasi memori yang terpisah untuk string yang dimodifikasi.

Solusi lain:

di dalam loop, gunakan List sebagai ganti string.

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

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

ini sangat sangat cepat.

Itu sangat tergantung pada pola penggunaan Anda. Patokan terperinci antara string.Gabung, string, Concat, dan string.Format dapat ditemukan di sini: String.Format Tidak Cocok untuk Pencatatan Intensif

(Ini sebenarnya jawaban yang sama yang saya berikan untuk pertanyaan ini )

Itu akan tergantung pada kode. StringBuilder umumnya lebih efisien, tetapi jika Anda hanya menggabungkan beberapa string dan melakukan semuanya dalam satu baris, optimasi kode kemungkinan akan mengaturnya untuk Anda. Sangat penting untuk memikirkan bagaimana kode terlihat juga: untuk set yang lebih besar, StringBuilder akan membuatnya lebih mudah dibaca, untuk yang kecil, StringBuilder hanya akan menambah kekacauan yang tidak perlu.