String.Contains () เร็วกว่า String.IndexOf () หรือไม่

ฉันมีสตริงบัฟเฟอร์ประมาณ 2,000 อักขระและต้องการตรวจสอบบัฟเฟอร์ว่ามีสตริงเฉพาะหรือไม่
จะทำการตรวจสอบในเว็บแอป ASP.NET 2.0 สำหรับทุกการร้องขอ

มีใครรู้บ้างว่าเมธอด String.Containsทำงานได้ดีกว่าเมธอด String.IndexOfหรือไม่?

    // 2000 characters in s1, search token in s2
    string s1 = "Many characters. The quick brown fox jumps over the lazy dog"; 
    string s2 = "fox";
    bool b;
    b = s1.Contains(s2);
    int i;
    i = s1.IndexOf(s2);

สนุกจริงๆ

ContainsโทรIndexOf:

public bool Contains(string value)
{
    return (this.IndexOf(value, StringComparison.Ordinal) >= 0);
}

ซึ่งเรียกCompareInfo.IndexOfซึ่งในที่สุดก็ใช้การใช้งาน CLR

หากคุณต้องการดูการเปรียบเทียบสตริงใน CLR สิ่งนี้จะแสดงให้คุณเห็น (มองหาCaseInsensitiveCompHelper )

IndexOf(string)ไม่มีตัวเลือกและContains()ใช้การเปรียบเทียบแบบลำดับ (การเปรียบเทียบแบบไบต์ต่อไบต์แทนที่จะพยายามทำการเปรียบเทียบอย่างชาญฉลาดเช่น e กับé)

ดังนั้นIndexOfจะเร็วขึ้นเล็กน้อย (ในทางทฤษฎี) เมื่อIndexOfตรงไปที่การค้นหาสตริงโดยใช้ FindNLSString จาก kernel32.dll (พลังของตัวสะท้อน!)

อัปเดตสำหรับ. NET 4.0 - IndexOf ไม่ใช้ Ordinal Comparison อีกต่อไปดังนั้นการมีจึงเร็วขึ้น ดูความคิดเห็นด้านล่าง

อาจจะไม่สำคัญเลย อ่านโพสต์นี้เกี่ยวกับ Coding Horror;): http://www.codinghorror.com/blog/archives/001218.html

ประกอบด้วย (s2) หลายเท่า (ในคอมพิวเตอร์ของฉัน 10 เท่า) เร็วกว่า IndexOf (s2) เนื่องจากมีใช้ StringComparison.Ordinal ที่เร็วกว่าการค้นหาที่ไวต่อวัฒนธรรมที่ IndexOf ทำตามค่าเริ่มต้น (แต่อาจมีการเปลี่ยนแปลงใน. net 4.0 http: //davesbox.com/archive/2008/11/12/breaking-changes-to-the-string-class.aspx )

มีประสิทธิภาพเหมือนกับ IndexOf (s2, StringComparison.Ordinal)> = 0 ในการทดสอบของฉัน แต่สั้นกว่าและทำให้เจตนาของคุณชัดเจน

ฉันใช้งานเคสจริง (ตรงข้ามกับเกณฑ์มาตรฐานสังเคราะห์)

 if("=,<=,=>,<>,<,>,!=,==,".IndexOf(tmps)>=0) {

กับ

 if("=,<=,=>,<>,<,>,!=,==,".Contains(tmps)) {

เป็นส่วนสำคัญในระบบของฉันและมีการดำเนินการ 131,953 ครั้ง (ขอบคุณ DotTrace)

อย่างไรก็ตามความประหลาดใจที่น่าตกใจผลลัพธ์กลับตรงกันข้ามกับที่คาดไว้

• ดัชนี 533 มิลลิวินาที
• ประกอบด้วย 266ms

: - /

net framework 4.0 (อัปเดตเมื่อวันที่ 13-02-2555)

คุณจะเห็นได้ว่ามีการใช้งานตัวสะท้อนแสงโดยใช้ IndexOf นี่คือการใช้งาน

public bool Contains(string value)
{
   return (this.IndexOf(value, StringComparison.Ordinal) >= 0);
}

ดังนั้นจึงมีแนวโน้มที่จะช้ากว่าการเรียก IndexOf โดยตรงเล็กน้อย แต่ฉันสงสัยว่ามันจะมีความสำคัญต่อประสิทธิภาพที่แท้จริง

หากคุณต้องการเพิ่มประสิทธิภาพโค้ดของคุณอย่างแท้จริงแนวทางที่ดีที่สุดของคุณคือการเปรียบเทียบเสมอ

net framework มีการใช้งานนาฬิกาจับเวลาที่ยอดเยี่ยม - System.Diagnostics.Stopwatch

จากการอ่านเล็กน้อยดูเหมือนว่าภายใต้ฝากระโปรงวิธีการ String.Contains เพียงแค่เรียก String.IndexOf ความแตกต่างคือ String.Contains ส่งคืนบูลีนในขณะที่ String.IndexOf ส่งคืนจำนวนเต็มโดยมี (-1) แทนว่าไม่พบสตริงย่อย

ฉันขอแนะนำให้เขียนการทดสอบเล็กน้อยโดยมีการทำซ้ำประมาณ 100,000 ครั้งและดูด้วยตัวคุณเอง ถ้าจะให้เดาก็คงบอกว่า IndexOf อาจจะเร็วกว่าเล็กน้อย แต่ก็อย่างที่บอกว่าเป็นแค่การเดา

Jeff Atwood มีบทความที่ดีในสายที่บล็อกของเขา เป็นข้อมูลเพิ่มเติมเกี่ยวกับการเรียงต่อกัน แต่อาจเป็นประโยชน์

เช่นเดียวกับการอัปเดตสิ่งนี้ฉันได้ทำการทดสอบบางอย่างและให้สตริงอินพุตของคุณมีขนาดค่อนข้างใหญ่จากนั้น Regex แบบขนานเป็นวิธี C # ที่เร็วที่สุดที่ฉันพบ (หากคุณมีมากกว่าหนึ่งคอร์ที่ฉันคิด)

รับจำนวนการแข่งขันทั้งหมดเช่น -

needles.AsParallel ( ).Sum ( l => Regex.IsMatch ( haystack , Regex.Escape ( l ) ) ? 1 : 0 );

หวังว่านี่จะช่วยได้!

ใช้ไลบรารีมาตรฐานเช่นการโจมตีล่าสุดจาก Jon Skeetเพื่อวัดผล

Caveat Emptor

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

สำหรับคำถามเกี่ยวกับประสิทธิภาพ (micro-) ทั้งหมดขั้นตอนแรกต้องได้รับเวอร์ชันที่ใช้งานได้ซึ่งดูแลรักษาได้ง่าย จากนั้นการเปรียบเทียบการสร้างโปรไฟล์และการปรับแต่งสามารถนำไปใช้กับคอขวดที่วัดได้แทนการคาดเดา

สำหรับใครที่ยังอ่านสิ่งนี้อยู่ indexOf () น่าจะทำงานได้ดีกว่าในระบบขององค์กรส่วนใหญ่เนื่องจากมี () เข้ากับ IE ไม่ได้!