วิธีที่มีประสิทธิภาพมากที่สุดในการต่อสตริง?

วิธีที่มีประสิทธิภาพมากที่สุดในการเชื่อมสตริงคืออะไร

StringBuilder.Append()เป็นวิธีการที่ดีกว่าการใช้+ประกอบการ แต่ฉันได้พบว่าเมื่อมีการดำเนิน 1,000 concatenations หรือน้อยกว่าแม้จะมีประสิทธิภาพมากกว่าString.Join()StringBuilder

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

ปัญหาเดียวString.Joinคือคุณต้องเชื่อมสตริงด้วยตัวคั่นทั่วไป

แก้ไข:ตามที่@ryanversawชี้ให้เห็นคุณสามารถสร้างตัวคั่นstring.Emptyได้

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

Rico Mariani , ปรมาจารย์ด้าน. ประสิทธิภาพ NET, มีบทความเกี่ยวกับเรื่องนี้มาก มันไม่ง่ายอย่างที่ใคร ๆ ก็สงสัย คำแนะนำพื้นฐานคือ:

หากรูปแบบของคุณดูเหมือนว่า:

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

นั่นเป็นหนึ่งในความเชื่อมโยงกันและมันมีชีวิตชีวา แต่ StringBuilder อาจไม่ช่วยได้

หากรูปแบบของคุณดูเหมือนว่า:

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

จากนั้นคุณอาจต้องการ StringBuilder

บทความอื่นที่ให้การสนับสนุนการอ้างสิทธิ์นี้มาจาก Eric Lippert ซึ่งเขาอธิบายการปรับให้เหมาะสมที่ดำเนินการในการ+ต่อข้อมูลบรรทัดเดียวในรายละเอียด

การต่อสตริงมี 6 ชนิด:

1. การใช้+สัญลักษณ์เครื่องหมายบวก ( )
2. string.Concat()การใช้
3. string.Join()การใช้
4. string.Format()การใช้
5. string.Append()การใช้
6. StringBuilderการใช้

ในการทดสอบได้รับการพิสูจน์แล้วว่าstring.Concat()เป็นวิธีที่ดีที่สุดในการเข้าหาถ้าคำนั้นน้อยกว่า 1,000 (โดยประมาณ) และถ้าคำนั้นมีมากกว่า 1,000StringBuilderควรใช้

สำหรับข้อมูลเพิ่มเติมตรวจสอบเว็บไซต์นี้

string.Join () vs string.Concat ()

เมธอด string.Concat ที่นี่เทียบเท่ากับการเรียกเมธอด string.Join ด้วยตัวคั่นว่าง การต่อท้ายสตริงว่างเร็ว แต่การทำเช่นนั้นจะไม่เร็วกว่าดังนั้นเมธอดstring.Concatน่าจะดีกว่าที่นี่

จากChinh Do - StringBuilder ไม่ได้เร็วขึ้นเสมอ :

กฎของ Thumb

• เมื่อทำการต่อค่าสตริงแบบไดนามิกสามค่าหรือน้อยกว่าให้ใช้การต่อสตริงแบบดั้งเดิม

• เมื่อเชื่อมโยงมากกว่าสามStringBuilderค่าสตริงแบบไดนามิกการใช้งาน

• เมื่อสร้างสตริงขนาดใหญ่จากตัวอักษรสตริงหลายตัวให้ใช้@ตัวอักษรสตริงหรือตัวดำเนินการ inline +

ส่วนใหญ่ของเวลาStringBuilderเป็นทางออกที่ดีที่สุดของคุณ แต่มีกรณีตามที่ปรากฏในโพสต์ที่ว่าอย่างน้อยคุณควรคิดเกี่ยวกับแต่ละสถานการณ์

หากคุณกำลังทำงานอยู่ในวงStringBuilderอาจเป็นไปได้ มันช่วยให้คุณประหยัดค่าใช้จ่ายในการสร้างสตริงใหม่เป็นประจำ ในรหัสที่จะทำงานเพียงครั้งเดียว แต่String.Concatอาจเป็นเรื่องปกติ

อย่างไรก็ตามเปอร์โตริโก Mariani (.NET เพิ่มประสิทธิภาพกูรู) ที่สร้างขึ้นแบบทดสอบString.Formatซึ่งเขาระบุในตอนท้ายว่าในกรณีส่วนใหญ่ที่เขาแนะนำ

นี่เป็นวิธีที่เร็วที่สุดที่ฉันได้พัฒนามานานกว่าทศวรรษสำหรับแอป NLP ขนาดใหญ่ของฉัน ฉันมีรูปแบบIEnumerable<T>และประเภทอินพุตอื่น ๆ ที่มีและไม่มีตัวคั่นประเภทที่แตกต่างกัน ( Char, String) แต่ที่นี่ฉันแสดงกรณีง่าย ๆ ของการ เชื่อมสตริงทั้งหมดในอาร์เรย์เป็นสตริงเดียวโดยไม่มีตัวคั่น รุ่นล่าสุดที่นี่ได้รับการพัฒนาและทดสอบหน่วยบนC # 7และ. NET 4.74.7

มีสองปุ่มเพื่อประสิทธิภาพที่สูงขึ้น สิ่งแรกคือการคำนวณขนาดทั้งหมดที่ต้องการล่วงหน้า ขั้นตอนนี้ไม่สำคัญเมื่ออินพุตเป็นอาร์เรย์ดังที่แสดงไว้ที่นี่ สำหรับการจัดการIEnumerable<T>แทนมันคุ้มค่าก่อนที่จะรวบรวมสตริงลงในอาร์เรย์ชั่วคราวสำหรับการคำนวณทั้งหมด (ต้องใช้อาร์เรย์เพื่อหลีกเลี่ยงการโทรToString()มากกว่าหนึ่งครั้งต่อองค์ประกอบตั้งแต่ในทางเทคนิคให้ความเป็นไปได้ของผลข้างเคียงทำให้เปลี่ยนความหมายที่คาดไว้ ของการดำเนินการ 'เข้าร่วมสตริง')

ถัดไปที่ได้รับการจัดสรรขนาดรวมของสตริงสุดท้ายเพิ่มที่ใหญ่ที่สุดในประสิทธิภาพการทำงานจะได้รับจากการสร้างสตริงผลในสถานที่ การทำเช่นนี้ต้องใช้เทคนิค (อาจเป็นที่ถกเถียงกัน) เทคนิคในการระงับการเปลี่ยนแปลงไม่ได้ชั่วคราวของใหม่Stringซึ่งได้รับการจัดสรรครั้งแรกเต็มศูนย์ การโต้เถียงกันเช่นนี้อย่างไรก็ตาม ...

... ทราบว่านี่เป็นวิธีการแก้ปัญหาเป็นกลุ่มเรียงต่อกันเฉพาะในหน้านี้ซึ่งทั้งหลีกเลี่ยงรอบพิเศษของการจัดสรรและการคัดลอกโดยStringคอนสตรัค

รหัสสมบูรณ์:

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

ฉันควรพูดถึงว่ารหัสนี้มีการปรับเปลี่ยนเล็กน้อยจากสิ่งที่ฉันใช้ตัวเอง ในต้นฉบับฉันเรียกคำสั่งcpblk ILจากC #เพื่อทำการคัดลอกจริง เพื่อความง่ายและพกพาในรหัสที่นี่ฉันแทนที่ด้วย P / Invoke memcpyแทนตามที่คุณเห็น เพื่อประสิทธิภาพสูงสุดใน x64 ( แต่อาจไม่ใช่ x86 ) คุณอาจต้องการใช้วิธีcpblkแทน

จากบทความ MSDN นี้ :

มีค่าใช้จ่ายที่เกี่ยวข้องกับการสร้างวัตถุ StringBuilder ทั้งในเวลาและหน่วยความจำ ในเครื่องที่มีหน่วยความจำที่รวดเร็ว StringBuilder จะคุ้มค่าหากคุณกำลังดำเนินการห้าอย่าง ตามกฎของหัวแม่มือฉันจะพูดว่า 10 หรือมากกว่าการดำเนินงานสายเป็นเหตุผลสำหรับค่าใช้จ่ายในเครื่องใด ๆ แม้แต่ช้าลง

ดังนั้นถ้าคุณเชื่อถือ MSDN ให้ไปกับ StringBuilder ถ้าคุณต้องทำการดำเนินการสตริงมากกว่า 10 รายการ / การต่อข้อมูล - มิฉะนั้นสตริงแบบง่าย ๆ ที่เชื่อมต่อด้วย '+' นั้นใช้ได้

สิ่งสำคัญคือต้องชี้ให้เห็นว่าคุณควรใช้+โอเปอเรเตอร์ถ้าคุณต่อสตริงตัวอักษรเข้าด้วยกัน

เมื่อคุณต่อสตริงตัวอักษรหรือค่าคงที่สตริงเข้าด้วยกันโดยใช้ตัวดำเนินการ + คอมไพเลอร์จะสร้างสตริงเดียว ไม่มีการต่อข้อมูลรันไทม์เกิดขึ้น

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

การเพิ่มคำตอบอื่น ๆ โปรดทราบว่าStringBuilder สามารถบอกจำนวนเงินเริ่มต้นของหน่วยความจำที่จะจัดสรร

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

หากความจุเป็นศูนย์จะใช้ความจุเริ่มต้นเฉพาะการใช้งาน

ผนวกท้ายซ้ำกับ StringBuilder ที่ไม่ได้รับการจัดสรรล่วงหน้าอาจส่งผลให้เกิดการจัดสรรที่ไม่จำเป็นจำนวนมากเช่นเดียวกับการเชื่อมสตริงปกติซ้ำ ๆ

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

หากคุณไม่สามารถคาดเดาขนาดใด ๆ ได้คุณอาจกำลังเขียนฟังก์ชันยูทิลิตี้ซึ่งควรมีอาร์กิวเมนต์เป็นทางเลือกสำหรับการควบคุมการจัดสรรล่วงหน้า

การติดตามอาจเป็นอีกทางเลือกหนึ่งในการเชื่อมหลายสายเข้าด้วยกัน

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

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

การแก้ไขสตริง

มีประสิทธิภาพมากที่สุดคือการใช้ StringBuilder เช่น:

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

@ jonezy: String.Concat เป็นเรื่องปกติถ้าคุณมีสองสิ่งเล็ก ๆ น้อย ๆ แต่ถ้าคุณกำลังต่อข้อมูลเมกะไบต์โปรแกรมของคุณจะมีแนวโน้มว่าจะมีการเก็บข้อมูล

ลองโค้ด 2 ชิ้นนี้แล้วคุณจะพบทางออก

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

คุณจะพบว่ารหัสที่ 1 จะจบลงอย่างรวดเร็วและหน่วยความจำจะอยู่ในระดับที่ดี

รหัสที่สองอาจจะเป็นหน่วยความจำก็โอเค แต่มันจะใช้เวลานาน ... ดังนั้นหากคุณมีแอปพลิเคชั่นสำหรับผู้ใช้จำนวนมากและคุณต้องการความเร็วให้ใช้อันดับที่ 1 หากคุณมีแอพสำหรับผู้ใช้ระยะสั้นหนึ่งแอพคุณอาจใช้ทั้งสองอย่างหรืออย่างที่สองจะเป็น "ธรรมชาติ" มากกว่าสำหรับนักพัฒนา

ไชโย

สำหรับสองสายคุณไม่ต้องการใช้ StringBuilder มีขีด จำกัด ข้างต้นบางส่วนซึ่งค่าโสหุ้ย StringBuilder น้อยกว่าค่าใช้จ่ายในการจัดสรรหลายสาย

ดังนั้นสำหรับมากกว่าที่ 2-3 สตริงใช้รหัส DannySmurf ของ มิฉะนั้นเพียงใช้ตัวดำเนินการ +

System.String ไม่เปลี่ยนรูป เมื่อเราแก้ไขค่าของตัวแปรสตริงหน่วยความจำใหม่จะถูกจัดสรรเป็นค่าใหม่และการจัดสรรหน่วยความจำก่อนหน้า System.StringBuilder ถูกออกแบบมาให้มีแนวคิดของสตริงที่ไม่แน่นอนซึ่งสามารถดำเนินการได้หลากหลายโดยไม่ต้องจัดสรรตำแหน่งหน่วยความจำแยกต่างหากสำหรับสตริงที่แก้ไข

ทางออกอื่น:

ในลูปให้ใช้รายการแทนสตริง

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

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

มันเร็วมาก

มันขึ้นอยู่กับรูปแบบการใช้งานของคุณ เกณฑ์มาตรฐานโดยละเอียดระหว่าง stringJoin, string, Concat และ string สามารถพบได้ที่นี่: String.Format ไม่เหมาะสำหรับการบันทึกแบบเร่งรัด

(นี่เป็นคำตอบเดียวกับที่ฉันให้กับคำถามนี้ )

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