Artı işareti kullanılırken kaç String nesnesi oluşturulacak?

Aşağıdaki kodda artı işareti kullanıldığında kaç String nesnesi oluşturulacak?

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

Aşağıdaki gibi olsaydı, üç String nesnesi söylerdim: "1", "2", "12".

String result = "1" + "2";

Performans iyileştirmesi için String nesnelerinin String Intern Pool / Table'da önbelleğe alındığını da biliyorum, ancak soru bu değil.

Şaşırtıcı bir şekilde duruma göre değişir.

Bunu bir yöntemle yaparsanız:

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

daha sonra derleyici kodu String.Concat@ Joachim yanıtını kullanarak (ona btw +1) gönderiyor gibi görünüyor .

Bunları sabitler olarak tanımlarsanız , örneğin:

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

veya orijinal soruda olduğu gibi değişmez değerler olarak:

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

daha sonra derleyici bu +işaretleri ortadan kaldıracaktır . Eşdeğeri:

const String result = "1234";

Ayrıca, derleyici yabancı sabit ifadeleri kaldıracak ve yalnızca kullanıldıklarında veya açığa çıktıklarında yayınlayacaktır. Örneğin, bu program:

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

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

Yalnızca bir dize üretir - sabit result("1234" e eşit). oneve twoortaya çıkan IL'de görünmez.

Çalışma zamanında daha fazla optimizasyon olabileceğini unutmayın. Ben sadece IL'nin ürettiği şeyle gidiyorum.

Son olarak, interning ile ilgili olarak, sabitler ve değişmezler dahil edilir, ancak dahili olan değer, IL'deki sonuçta elde edilen sabit değerdir, değişmez değer değil. Bu, beklediğinizden daha az dizi nesnesi elde edebileceğiniz anlamına gelir, çünkü birden fazla aynı tanımlı sabit veya değişmez değer aslında aynı nesne olacaktır! Bu, aşağıdaki şekilde gösterilmektedir:

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

Dizelerin bir döngüde (veya başka bir şekilde dinamik olarak) birleştirilmesi durumunda, bitiştirme başına fazladan bir dize elde edersiniz. Örneğin, aşağıdakiler 12 dize örneği oluşturur: 2 sabit + 10 yineleme, her biri yeni bir String örneğiyle sonuçlanır:

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

Ancak (şaşırtıcı bir şekilde), birden çok ardışık birleştirme, derleyici tarafından tek bir çok dizeli birleştirme halinde birleştirilir. Örneğin, bu program aynı zamanda yalnızca 12 dizgi örneği üretir! Bunun nedeni, " Bir ifadede birden fazla + operatörü kullansanız bile, dize içeriği yalnızca bir kez kopyalanır. "

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

Chris Shain'in cevabı çok güzel. Dize birleştirme iyileştiricisini yazan kişi olarak, sadece iki ilginç nokta daha ekledim.

Birincisi, birleştirme iyileştiricisinin, güvenli bir şekilde yapabildiğinde hem parantezleri hem de sol ilişkilendirilebilirliği esasen yok saymasıdır. Bir dize döndüren bir M () yönteminiz olduğunu varsayalım. Eğer öyle diyorsan:

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

daha sonra derleyici, toplama operatörünün ilişkisel bırakılmasına neden olur ve bu nedenle bu, şununla aynıdır:

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

Ama bu:

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

aynıdır

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

böylece birleşimidir sabit dize "CD" ile M().

Aslında, birleştirme iyileştiricisi, dize birleştirmenin ilişkisel olduğunu fark eder ve String.Concat(M(), "AB")sol ilişkilendirilebilirliği ihlal etse bile ilk örnek için üretir .

Bunu bile yapabilirsiniz:

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

ve yine de üreteceğiz String.Concat(M(), "EF", M()).

İkinci ilginç nokta, boş ve boş dizelerin optimize edilmesidir. Yani bunu yaparsanız:

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

alacaksınız String.Concat(M(), M())

Sonra ilginç bir soru ortaya çıkıyor: buna ne dersiniz?

string s = M() + null;

Bunu optimize edemeyiz

string s = M();

çünkü M()null döndürebilir, ancak null döndürürse String.Concat(M(), null)boş bir dize M()döndürür. Yani yaptığımız şey bunun yerine azaltmak

string s = M() + null;

için

string s = M() ?? "";

Böylece, dizi birleştirme işleminin aslında çağırılmasına gerek olmadığını gösterir String.Concat.

Bu konu hakkında daha fazla bilgi için bkz.

String.Concat neden StringBuilder.Append için optimize edilmedi?

Cevabı MSDN'de buldum. Bir.

Nasıl yapılır: Birden Çok Dizeyi Birleştirme (C # Programlama Kılavuzu)

Birleştirme, bir dizeyi başka bir dizenin sonuna ekleme işlemidir. + Operatörünü kullanarak dize değişmezlerini veya dize sabitlerini birleştirdiğinizde, derleyici tek bir dize oluşturur. Çalışma zamanı birleştirme oluşmaz. Bununla birlikte, dize değişkenleri yalnızca çalışma zamanında birleştirilebilir. Bu durumda, çeşitli yaklaşımların performans sonuçlarını anlamalısınız.

Sadece bir. C # derleyicisi dizge sabitlerini katlayacak ve bu nedenle esasen

String result = "1234";

Bunun herhangi bir standart veya spesifikasyon tarafından zorunlu kıldığından şüpheliyim. Bir sürüm muhtemelen diğerinden farklı bir şey yapabilir.

Birincisi, statik olduklarından, derleyici bunu derleme zamanında tek bir dizeye optimize edebilecektir.

Dinamik olsalardı, String.Concat'e (string, string, string, string) tek bir çağrı için optimize edilmiş olurlardı .