จะสร้างวัตถุ String จำนวนเท่าใดเมื่อใช้เครื่องหมายบวก

จะสร้างวัตถุสตริงจำนวนเท่าใดเมื่อใช้เครื่องหมายบวกในโค้ดด้านล่าง

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

ถ้าเป็นดังด้านล่างนี้ผมจะพูดว่า String object 3 ตัว: "1", "2", "12"

String result = "1" + "2";

ฉันรู้ด้วยว่าอ็อบเจ็กต์ String ถูกแคชไว้ใน String Intern Pool / Table เพื่อการปรับปรุงประสิทธิภาพ แต่นั่นไม่ใช่คำถาม

น่าแปลกที่มันขึ้นอยู่กับ

หากคุณทำสิ่งนี้ด้วยวิธีการ:

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ไม่ปรากฏใน IL ที่เป็นผลลัพธ์

โปรดทราบว่าอาจมีการเพิ่มประสิทธิภาพเพิ่มเติมในขณะรันไทม์ ฉันแค่ไปตามสิ่งที่ IL ผลิตขึ้น

สุดท้ายเกี่ยวกับภายในค่าคงที่และตัวอักษรจะอยู่ภายใน แต่ค่าที่อยู่ภายในคือค่าคงที่ที่เป็นผลลัพธ์ใน IL ไม่ใช่ค่าตัวอักษร ซึ่งหมายความว่าคุณอาจได้รับวัตถุสตริงน้อยกว่าที่คุณคาดหวังเนื่องจากค่าคงที่หรือตัวอักษรที่กำหนดเหมือนกันหลายตัวจะเป็นวัตถุเดียวกัน! นี่คือภาพประกอบดังต่อไปนี้:

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 ครั้งซึ่งแต่ละครั้งจะทำให้เกิดอินสแตนซ์สตริงใหม่:

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

คำตอบของ Chris Shain นั้นดีมาก ในฐานะคนที่เขียนเครื่องมือเพิ่มประสิทธิภาพการต่อสายอักขระฉันจะเพิ่มประเด็นที่น่าสนใจอีกสองประเด็น

ประการแรกคือเครื่องมือเพิ่มประสิทธิภาพการเชื่อมต่อโดยหลักแล้วจะละเว้นทั้งวงเล็บและการเชื่อมโยงด้านซ้ายเมื่อทำได้อย่างปลอดภัย สมมติว่าคุณมีเมธอด M () ที่ส่งคืนสตริง ถ้าคุณพูด:

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

จากนั้นคอมไพเลอร์ให้เหตุผลว่าตัวดำเนินการเพิ่มเติมถูกปล่อยให้เชื่อมโยงดังนั้นนี่จึงเหมือนกับ:

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

แต่นี่:

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

เหมือนกับ

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

เพื่อให้เป็น concatenation ของสตริงอย่างต่อเนื่อง กับ"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()อาจส่งคืนค่าว่าง แต่String.Concat(M(), null)จะส่งคืนสตริงว่างหากM()ส่งคืนค่าว่าง ดังนั้นสิ่งที่เราทำคือแทนที่จะลด

string s = M() + null;

ถึง

string s = M() ?? "";

ดังนั้นจึงแสดงให้เห็นว่าการต่อสายอักขระไม่จำเป็นต้องเรียกString.Concatเลย

สำหรับการอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้โปรดดู

เหตุใด String.Concat จึงไม่ได้รับการปรับให้เหมาะกับ StringBuilder.Append

ฉันพบคำตอบที่ MSDN หนึ่ง.

วิธีการ: เชื่อมต่อหลายสตริง (คู่มือการเขียนโปรแกรม C #)

การเชื่อมต่อเป็นกระบวนการต่อท้ายสตริงหนึ่งไปยังส่วนท้ายของสตริงอื่น เมื่อคุณเชื่อมต่อตัวอักษรสตริงหรือค่าคงที่ของสตริงโดยใช้ตัวดำเนินการ + คอมไพเลอร์จะสร้างสตริงเดียว ไม่มีการเชื่อมต่อเวลาทำงาน อย่างไรก็ตามตัวแปรสตริงสามารถเชื่อมต่อกันได้ในขณะรันไทม์เท่านั้น ในกรณีนี้คุณควรเข้าใจผลกระทบด้านประสิทธิภาพของแนวทางต่างๆ

แค่หนึ่ง. คอมไพเลอร์ C # จะพับค่าคงที่ของสตริงและด้วยเหตุนี้คอมไพเลอร์จึงรวบรวมลงไปที่

String result = "1234";

ฉันสงสัยว่านี่เป็นข้อบังคับมาตรฐานหรือข้อกำหนดใด ๆ เวอร์ชันหนึ่งอาจทำสิ่งที่แตกต่างจากเวอร์ชันอื่นได้

หนึ่งเนื่องจากเป็นแบบคงที่คอมไพลเลอร์จะสามารถเพิ่มประสิทธิภาพให้เป็นสตริงเดียวได้ในเวลาคอมไพล์

หากพวกเขาได้รับแบบไดนามิกที่พวกเขาต้องการได้รับการปรับปรุงให้สายเดียวที่จะString.Concat (สตริงสตริงสตริงสตริง)