Debug.Assert vs Exception Throwing

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

เหตุใดฉันจึงควรใช้Debug.Assertแทนข้อยกเว้นธรรมดา การวางคำยืนยันในที่ที่ไม่ควรเป็นเพียงแค่อาจทำให้เกิด "พฤติกรรมที่ไม่ต้องการ" ได้ทุกรูปแบบดังนั้นในมุมมองของฉันฉันไม่ได้ประโยชน์อะไรเลยจากการใช้การยืนยันแทนที่จะโยนข้อยกเว้น คุณเห็นด้วยกับฉันหรือว่าฉันพลาดอะไรที่นี่?

หมายเหตุ:ฉันเข้าใจอย่างถ่องแท้ว่าความแตกต่างคือ "ในทางทฤษฎี" (Debug vs Release, รูปแบบการใช้งานและอื่น ๆ ) แต่อย่างที่ฉันเห็นฉันจะดีกว่าที่จะทิ้งข้อยกเว้นแทนการยืนยัน เนื่องจากหากพบข้อบกพร่องในรุ่นที่ใช้งานจริงฉันก็ยังคงต้องการให้ "การยืนยัน" ล้มเหลว (อย่างไรก็ตาม "ค่าใช้จ่าย" มีขนาดเล็กมาก) ดังนั้นฉันจะดีกว่าที่จะทิ้งข้อยกเว้นแทน

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

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

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

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

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

นั่นเป็นเหตุผลที่ฉันจะไม่แทนที่การยืนยันด้วยข้อยกเว้น หากยืนยันจะไม่ได้ยิงแล้วแทนที่มันด้วยวิธีการยกเว้นคุณจะมีเส้นทางรหัส untestable ในโปรแกรมของคุณ ฉันไม่ชอบเส้นทางรหัสที่ไม่สามารถทดสอบได้

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

ยืนยันการทดสอบสำหรับเงื่อนไขที่ "ไม่สามารถเกิดขึ้นได้" มีข้อยกเว้นสำหรับเงื่อนไขที่ "ไม่ควรเกิดขึ้น แต่ต้องทำ"

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

หากคุณใช้ข้อยกเว้นแทนการยืนยันคุณจะสูญเสียคุณค่าบางอย่าง:

1. รหัสมีรายละเอียดมากกว่าเนื่องจากการทดสอบและการโยนข้อยกเว้นอย่างน้อยสองบรรทัดในขณะที่การยืนยันมีเพียงบรรทัดเดียว

2. รหัสการทดสอบและการโยนของคุณจะทำงานตลอดเวลาในขณะที่สามารถรวบรวมข้อมูลยืนยันได้

3. คุณขาดการสื่อสารบางอย่างกับนักพัฒนาซอฟต์แวร์รายอื่นเนื่องจากการยืนยันมีความหมายที่แตกต่างจากรหัสผลิตภัณฑ์ที่ตรวจสอบและพ่น หากคุณกำลังทดสอบการยืนยันการเขียนโปรแกรมจริงๆให้ใช้ Assert

เพิ่มเติมที่นี่: http://nedbatchelder.com/text/assert.html

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

ฉันจะพิมพ์คำตอบด้วยคำพูดของฉันเอง แต่แนวคิดนี้ทำให้เกิดความยุติธรรมได้ดีกว่าที่ฉันจะมี:

C # Station: การยืนยัน

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

การยืนยันจะใช้เพื่อทดสอบเงื่อนไขได้ดีที่สุดก็ต่อเมื่อมีการระงับทั้งหมดต่อไปนี้:

* the condition should never be false if the code is correct,
* the condition is not so trivial so as to obviously be always true, and
* the condition is in some sense internal to a body of software.

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

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

ฉันคิดว่าตัวอย่างที่ใช้ได้จริง (ที่สร้างขึ้น) อาจช่วยให้ความแตกต่าง:

(ดัดแปลงมาจากส่วนขยาย Batch ของ MoreLinq )

// 'public facing' method
public int DoSomething(List<string> stuff, object doohickey, int limit) {

    // validate user input and report problems externally with exceptions

    if(stuff == null) throw new ArgumentNullException("stuff");
    if(doohickey == null) throw new ArgumentNullException("doohickey");
    if(limit <= 0) throw new ArgumentOutOfRangeException("limit", limit, "Should be > 0");

    return DoSomethingImpl(stuff, doohickey, limit);
}

// 'developer only' method
private static int DoSomethingImpl(List<string> stuff, object doohickey, int limit) {

    // validate input that should only come from other programming methods
    // which we have control over (e.g. we already validated user input in
    // the calling method above), so anything using this method shouldn't
    // need to report problems externally, and compilation mode can remove
    // this "unnecessary" check from production

    Debug.Assert(stuff != null);
    Debug.Assert(doohickey != null);
    Debug.Assert(limit > 0);

    /* now do the actual work... */
}

ดังที่Eric Lippert et al ได้กล่าวไว้คุณยืนยันเฉพาะสิ่งที่คุณคาดว่าจะถูกต้องเท่านั้นในกรณีที่คุณ (ผู้พัฒนา) ใช้ผิดที่อื่นโดยไม่ได้ตั้งใจดังนั้นคุณจึงสามารถแก้ไขรหัสของคุณได้ โดยทั่วไปคุณจะโยนข้อยกเว้นเมื่อคุณไม่สามารถควบคุมหรือไม่สามารถคาดการณ์สิ่งที่เข้ามาได้เช่นการป้อนข้อมูลของผู้ใช้เพื่อให้ข้อมูลที่ไม่ดีสามารถตอบสนองได้อย่างเหมาะสม (เช่นผู้ใช้)

นักเก็ตอื่นจากCode Complete :

"การยืนยันคือฟังก์ชันหรือมาโครที่บ่นเสียงดังหากสมมติฐานไม่เป็นจริงใช้การยืนยันเพื่อบันทึกข้อสันนิษฐานที่สร้างขึ้นในรหัสและเพื่อล้างเงื่อนไขที่ไม่คาดคิด ...

"ในระหว่างการพัฒนาการยืนยันจะล้างสมมติฐานที่ขัดแย้งกันเงื่อนไขที่ไม่คาดคิดค่าที่ไม่ดีที่ส่งผ่านไปยังกิจวัตรและอื่น ๆ "

เขายังคงเพิ่มแนวทางบางอย่างเกี่ยวกับสิ่งที่ควรและไม่ควรยืนยัน

ในทางกลับกันข้อยกเว้น:

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

หากคุณไม่มีหนังสือเล่มนี้ควรซื้อ

Debug.Assert โดยค่าเริ่มต้นจะใช้ได้เฉพาะในรุ่น debug เท่านั้นดังนั้นหากคุณต้องการตรวจจับพฤติกรรมที่ไม่คาดคิดที่ไม่ดีในรุ่นของคุณคุณจะต้องใช้ข้อยกเว้นหรือเปิดค่าคงที่ในการแก้ปัญหาในคุณสมบัติโครงการของคุณ (ซึ่งถือว่าอยู่ใน ทั่วไปไม่ควรเป็นความคิดที่ดี)

ใช้การยืนยันในสิ่งที่เป็นไปได้ แต่ไม่ควรเกิดขึ้น (ถ้าเป็นไปไม่ได้คุณจะยืนยันทำไม)

ฟังดูไม่เหมือนกรณีที่จะใช้Exception? ทำไมคุณถึงใช้การยืนยันแทนException?

เนื่องจากควรมีรหัสที่ถูกเรียกก่อนการยืนยันของคุณซึ่งจะหยุดพารามิเตอร์ของการยืนยันว่าเป็นเท็จ

โดยปกติแล้วจะไม่มีรหัสใด ๆ มาก่อนExceptionซึ่งรับประกันได้ว่าจะไม่ถูกโยนทิ้ง

ทำไมจึงDebug.Assert()รวบรวมไว้ในแยงได้ดี? ถ้าคุณอยากรู้เกี่ยวกับมันใน debug คุณจะไม่อยากรู้เกี่ยวกับมันใน prod หรือ?

คุณต้องการเฉพาะในระหว่างการพัฒนาเพราะเมื่อคุณพบDebug.Assert(false)สถานการณ์คุณจึงเขียนโค้ดเพื่อรับประกันว่าDebug.Assert(false)จะไม่เกิดขึ้นอีก เมื่อการพัฒนาเสร็จสิ้นโดยสมมติว่าคุณพบDebug.Assert(false)สถานการณ์และแก้ไขแล้วDebug.Assert()สามารถรวบรวมได้อย่างปลอดภัยเนื่องจากตอนนี้ซ้ำซ้อน

สมมติว่าคุณเป็นสมาชิกของทีมที่ค่อนข้างใหญ่และมีหลายคนที่ทำงานบนฐานรหัสทั่วไปเดียวกันรวมถึงการทับซ้อนกันในชั้นเรียน คุณอาจสร้างเมธอดที่เรียกโดยวิธีการอื่น ๆ และเพื่อหลีกเลี่ยงความขัดแย้งในการล็อกคุณไม่ได้เพิ่มการล็อกแยกต่างหาก แต่ "สมมติ" ก่อนหน้านี้ถูกล็อคโดยวิธีการโทรที่มีการล็อกเฉพาะ เช่น Debug.Assert (RepositoryLock.IsReadLockHeld || RepositoryLock.IsWriteLockHeld); นักพัฒนารายอื่นอาจมองข้ามความคิดเห็นที่ระบุว่าวิธีการโทรต้องใช้การล็อก แต่ไม่สามารถเพิกเฉยต่อสิ่งนี้ได้