Скільки об'єктів String буде створено при використанні знака плюс?

Скільки об'єктів String буде створено при використанні знака плюс у наведеному нижче коді?

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

Якби це було нижче, я б сказав три об’єкти String: "1", "2", "12".

String result = "1" + "2";

Я також знаю, що об'єкти String є кешованими в басейні / таблиці String Intern для поліпшення продуктивності, але це не питання.

Дивно, але це залежить.

Якщо ви робите це методом:

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

тоді компілятор, здається String.Concat, видає код, використовуючи відповідь @Joachim (+1 до нього btw).

Якщо ви визначаєте їх як константи , наприклад:

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

або в прямому сенсі , як в оригінальному запитанні:

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

тоді компілятор оптимізує ці +знаки. Це еквівалентно:

const String result = "1234";

Крім того, компілятор видалить сторонні постійні вирази та випромінює їх лише в тому випадку, якщо вони використовуються або піддаються впливу. Наприклад, ця програма:

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

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

Генерує лише один рядок - константа result(дорівнює "1234"). oneі twoне відображаються в отриманому ІР.

Майте на увазі, що під час виконання можуть бути додаткові оптимізації. Я просто переходжу до того, що виробляється ІЛ.

Нарешті, що стосується інтернування, константи та буквали є інтернованими, але значення, яке інтерновано, є отриманим постійним значенням в ІЛ, а не буквальним. Це означає, що ви можете отримати ще менше рядкових об'єктів, ніж ви очікували, оскільки кілька однаково визначених констант або літералів будуть фактично одним і тим же об’єктом! Це пояснюється наступним:

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

У випадку, коли рядки об'єднані в цикл (або іншим чином динамічно), ви отримуєте один додатковий рядок за конкатенацію. Наприклад, наступне створює 12 рядкових екземплярів: 2 константи + 10 ітерацій, кожен з яких призводить до нового екземпляра String:

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

Але (що також дивно), кілька послідовних конкатенацій компілюється компілятором у єдине багаторядкове конкатенацію. Наприклад, ця програма також виробляє лише 12 рядкових екземплярів! Це тому, що " Навіть якщо ви використовуєте кілька операторів + в одному операторі, вміст рядка копіюється лише один раз ".

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

Відповідь Кріса Шейна дуже хороша. Як людина, яка написала оптимізатор конкатенації рядків, я просто додам два додаткових цікавих пункту.

Перший полягає в тому, що оптимізатор конкатенації по суті ігнорує і круглі дужки, і ліву асоціативність, коли це може зробити це безпечно. Припустимо, у вас є метод M (), який повертає рядок. Якщо ви говорите:

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

тоді компілятор міркує, що оператор додавання залишається асоціативним, і тому це те саме, що:

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

Але це:

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

те саме, що

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

так що це конкатенація постійної рядка "CD" з M().

Фактично, оптимізатор конкатенації розуміє, що конкатенація рядків є асоціативним і генерує String.Concat(M(), "AB")для першого прикладу, навіть якщо це порушує ліву асоціативність.

Ви навіть можете це зробити:

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

і ми все ще будемо генерувати String.Concat(M(), "EF", M()).

Другий цікавий момент - оптимізовані нульові та порожні рядки. Тож якщо ви це зробите:

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

ти отримаєш String.Concat(M(), M())

Тоді виникає цікаве запитання: що з цим?

string s = M() + null;

Ми не можемо оптимізувати це до

string s = M();

тому що M()може повернути null, але String.Concat(M(), null)поверне порожню рядок, якщо return M()null. Тож те, що ми робимо, це замість зменшення

string s = M() + null;

до

string s = M() ?? "";

Тим самим демонструючи, що з'єднання рядків не потрібно насправді викликати String.Concatвзагалі.

Для подальшого читання з цього приводу див

Чому String.Concat не оптимізовано до StringBuilder.Append?

Я знайшов відповідь у MSDN. Один.

Як: об'єднати кілька рядків (Посібник з програмування C #)

Конкатенація - це процес додавання одного рядка до кінця іншого рядка. Коли ви об'єднуєте рядкові літерали або рядкові константи за допомогою оператора +, компілятор створює одну рядок. Зв'язок часу виконання не відбувається. Однак струнні змінні можна об'єднати лише під час виконання. У цьому випадку слід розуміти наслідки різних підходів для продуктивності.

Тільки один. Компілятор C # складе рядкові константи і, отже, по суті компілює

String result = "1234";

Я сумніваюся, що це вимагає будь-який стандарт або специфікація. Одна версія, ймовірно, може зробити щось інше від іншої.

По-перше, оскільки вони статичні, компілятор зможе оптимізувати його до однієї рядка під час компіляції.

Якби вони були динамічними, вони були б оптимізовані під один виклик String.Concat (string, string, string, string) .