Berapa banyak objek String yang akan dibuat saat menggunakan tanda plus?

Berapa banyak objek String yang akan dibuat saat menggunakan tanda plus pada kode di bawah ini?

String result = "1" + "2" + "3" + "4";

Jika seperti di bawah ini, saya akan mengatakan tiga objek String: "1", "2", "12".

String result = "1" + "2";

Saya juga tahu bahwa objek String di-cache di String Intern Pool / Table untuk peningkatan kinerja, tapi bukan itu pertanyaannya.

Anehnya, itu tergantung.

Jika Anda melakukan ini dengan metode:

void Foo() {
    String one = "1";
    String two = "2";
    String result = one + two + "34";
    Console.Out.WriteLine(result);
}

kemudian compiler tampaknya memancarkan kode menggunakan String.Concat@Joachim menjawab (+1 padanya btw).

Jika Anda mendefinisikannya sebagai konstanta , misalnya:

const String one = "1";
const String two = "2";
const String result = one + two + "34";

atau sebagai literal , seperti pada pertanyaan awal:

String result = "1" + "2" + "3" + "4";

maka kompilator akan mengoptimalkan +tanda - tanda tersebut. Ini setara dengan:

const String result = "1234";

Selanjutnya, kompilator akan menghapus ekspresi konstanta asing, dan hanya memancarkannya jika digunakan atau diekspos. Misalnya, program ini:

const String one = "1";
const String two = "1";
const String result = one + two + "34";

public static void main(string[] args) {
    Console.Out.WriteLine(result);
}

Hanya menghasilkan satu string- konstanta result(sama dengan "1234"). onedan twotidak muncul di IL yang dihasilkan.

Perlu diingat bahwa mungkin ada pengoptimalan lebih lanjut pada waktu proses. Saya hanya mengikuti apa yang IL diproduksi.

Akhirnya, dalam hal interning, konstanta dan literal diinternir, tetapi nilai yang diinternir adalah nilai konstanta yang dihasilkan di IL, bukan literal. Ini berarti bahwa Anda mungkin mendapatkan lebih sedikit objek string dari yang Anda harapkan, karena beberapa konstanta atau literal yang didefinisikan secara identik sebenarnya akan menjadi objek yang sama! Ini diilustrasikan sebagai berikut:

public class Program
{
    private const String one = "1";
    private const String two = "2";
    private const String RESULT = one + two + "34";

    static String MakeIt()
    {
        return "1" + "2" + "3" + "4";
    }   

    static void Main(string[] args)
    {
        string result = "1" + "2" + "34";

        // Prints "True"
        Console.Out.WriteLine(Object.ReferenceEquals(result, MakeIt()));

        // Prints "True" also
        Console.Out.WriteLine(Object.ReferenceEquals(result, RESULT));
        Console.ReadKey();
    }
}

Dalam kasus di mana String digabungkan dalam satu lingkaran (atau sebaliknya secara dinamis), Anda berakhir dengan satu string tambahan per penggabungan. Misalnya, berikut ini membuat 12 instance string: 2 konstanta + 10 iterasi, masing-masing menghasilkan instance String baru:

public class Program
{
    static void Main(string[] args)
    {
        string result = "";
        for (int i = 0; i < 10; i++)
            result += "a";
        Console.ReadKey();
    }
}

Tetapi (juga secara mengejutkan), beberapa penggabungan yang berurutan digabungkan oleh kompilator menjadi satu penggabungan multi-string. Misalnya, program ini juga hanya menghasilkan 12 instance string! Ini karena " Meskipun Anda menggunakan beberapa + operator dalam satu pernyataan, konten string hanya akan disalin sekali. "

public class Program
{
    static void Main(string[] args)
    {
        string result = "";
        for (int i = 0; i < 10; i++)
            result += "a" + result;
        Console.ReadKey();
    }
}

Jawaban Chris Shain sangat bagus. Sebagai orang yang menulis pengoptimal rangkaian string, saya hanya akan menambahkan dua poin menarik tambahan.

Yang pertama adalah bahwa pengoptimal penggabungan pada dasarnya mengabaikan tanda kurung dan asosiasi kiri jika dapat melakukannya dengan aman. Misalkan Anda memiliki metode M () yang mengembalikan string. Jika Anda mengatakan:

string s = M() + "A" + "B";

maka kompilator beralasan bahwa operator penjumlahan dibiarkan asosiatif, dan oleh karena itu ini sama dengan:

string s = ((M() + "A") + "B");

Tapi ini:

string s = "C" + "D" + M();

sama dengan

string s = (("C" + "D") + M());

jadi itu adalah penggabungan string konstan "CD" dengan M().

Faktanya, pengoptimal penggabungan menyadari bahwa penggabungan string adalah asosiatif , dan menghasilkan String.Concat(M(), "AB")untuk contoh pertama, meskipun itu melanggar asosiasi kiri.

Anda bahkan dapat melakukan ini:

string s = (M() + "E") + ("F" + M()));

dan kami masih akan menghasilkan String.Concat(M(), "EF", M()).

Hal menarik kedua adalah bahwa string kosong dan kosong dioptimalkan. Jadi jika Anda melakukan ini:

string s = (M() + "") + (null + M());

Anda akan mendapatkan String.Concat(M(), M())

Sebuah pertanyaan menarik kemudian muncul: bagaimana dengan ini?

string s = M() + null;

Kami tidak bisa mengoptimalkannya hingga

string s = M();

karena M()mungkin mengembalikan null, tetapi String.Concat(M(), null)akan mengembalikan string kosong jika M()mengembalikan null. Jadi yang kita lakukan justru mengurangi

string s = M() + null;

untuk

string s = M() ?? "";

Dengan demikian menunjukkan bahwa penggabungan string sebenarnya tidak perlu dipanggil String.Concatsama sekali.

Untuk bacaan lebih lanjut tentang subjek ini, lihat

Mengapa String.Concat tidak dioptimalkan untuk StringBuilder.Append?

Saya menemukan jawabannya di MSDN. Satu.

Cara: Menggabungkan Beberapa String (Panduan Pemrograman C #)

Penggabungan adalah proses menambahkan satu string ke ujung string lain. Saat Anda menggabungkan literal string atau konstanta string dengan menggunakan operator +, kompilator membuat satu string. Tidak ada penggabungan waktu proses yang terjadi. Namun, variabel string hanya dapat digabungkan pada waktu proses. Dalam kasus ini, Anda harus memahami implikasi kinerja dari berbagai pendekatan.

Hanya satu. Kompiler C # akan melipat konstanta string dan karenanya pada dasarnya dikompilasi menjadi

String result = "1234";

Saya ragu ini diamanatkan oleh standar atau spesifikasi apa pun. Satu versi kemungkinan dapat melakukan sesuatu yang berbeda dari yang lain.

Pertama, karena bersifat statis, kompilator akan dapat mengoptimalkannya ke satu string pada waktu kompilasi.

Jika mereka dinamis, mereka akan dioptimalkan untuk satu panggilan ke String.Concat (string, string, string, string) .