คำถามติดแท็ก design

ฉันคิดว่าฉันจะออกแบบตัวอักษรที่ "สมบูรณ์แบบ" ได้อย่างไรถ้าฉันจะออกแบบภาษา สำหรับคุณที่ไม่ทราบว่าเป็นช่วงตัวอักษรในคำสั่งที่แสดงถึงช่วงของค่าเช่น 1-4 พวกมันถูกใช้บ่อยที่สุดใน for / foreach loops ดูเหมือนจะมีปัญหาสองข้อที่ควรคำนึงถึง การสนับสนุนสำหรับช่วงที่รวมและไม่เหมือนใครการตรึงบน +1 หรือ -1 ถึงจุดสิ้นสุดดูเหมือนว่าจะผิดพลาดและไม่มีข้อผิดพลาด สนับสนุนการก้าวดังนั้นคุณสามารถสร้างช่วงของเลขคู่หรือคี่ได้ ความสามารถในการอ่านควรชัดเจนว่าช่วงตัวอักษรหมายถึงอะไร ความไม่น่าสงสัยมันควรจะไร้เหตุผลอย่างสมบูรณ์แบบในสิ่งที่ช่วงตัวอักษรอธิบาย ค่าเริ่มต้นควรเป็นแบบรวมถึงแบบเอกสิทธิ์เนื่องจากเป็นสิ่งที่ใช้ในกรณีส่วนใหญ่สำหรับการวนซ้ำอาร์เรย์เป็นต้น อย่างไรก็ตามตัวอย่างหนึ่งของช่วงตัวอักษรที่ฉันได้เห็นคือ Ruby ซึ่งอยู่ในรูปแบบของ 1..3 สำหรับช่วงพิเศษ (ที่สิ้นสุด) และ 1 ... 3 สำหรับการรวม (บนสุด) คุณยังสามารถทำ 1..10.step (5) หลังจากพิจารณาอย่างถี่ถ้วนแล้วฉันพบบางสิ่งที่ฉันไม่ชอบเกี่ยวกับวิธีการนั้น (จากความรู้ที่ จำกัด เกี่ยวกับทับทิม) คุณสามารถอธิบายได้อย่างครอบคลุมและพิเศษเฉพาะตอนท้าย ในขณะที่อธิบายสถานการณ์ส่วนใหญ่ดูเหมือนจะไม่สอดคล้องกันเล็กน้อย แตกต่างกันเพียงเพิ่มเติม ดูเหมือนว่าเป็นสูตรสำหรับทำให้ยากที่จะดูว่าช่วงนั้นครอบคลุมหรือเป็นเอกสิทธิ์ ฉันไม่รู้เกี่ยวกับคุณ แต่จุดที่มักจะกลายเป็นสิ่งที่เบลอ :) การเพิ่มวิธีการเช่นสัญกรณ์สำหรับช่วงดูเหมือนจะผสมผสานความคิดของตัวอักษรเข้ากับชั้นเรียนซึ่งดูเหมือนว่าจะไม่สอดคล้องกันเล็กน้อย อย่างไรก็ตามหลังจากไตร่ตรองทางเลือกที่แตกต่างกัน ฉันมากับสิ่งนี้ [5..1] …

10 programming-languages  design 

พื้นหลังเล็กน้อยก่อน ฉันกำลังค้นหารหัสจากอายุ -> อัตรา มีวงเล็บอายุ 7 รายการดังนั้นตารางการค้นหาคือ 3 คอลัมน์ (จาก | ถึง | อัตรา) ด้วย 7 แถว ค่าไม่ค่อยมีการเปลี่ยนแปลง - เป็นอัตราที่มีการออกกฎหมาย (คอลัมน์แรกและคอลัมน์ที่สาม) ที่มีค่าคงเดิมเป็นเวลา 3 ปี ฉันคิดว่าวิธีที่ง่ายที่สุดในการจัดเก็บตารางนี้โดยไม่ต้องเข้ารหัสยากอยู่ในฐานข้อมูลในตารางการกำหนดค่าส่วนกลางเป็นค่าข้อความเดียวที่มี CSV (ดังนั้น "65,69,0.05,70,74,0.06" เป็นวิธีการที่ 65-69 และ 70-74 ชั้นจะถูกเก็บไว้) ค่อนข้างง่ายต่อการแยกวิเคราะห์แล้วใช้ จากนั้นฉันก็ตระหนักว่าการใช้สิ่งนี้ฉันจะต้องสร้างตารางใหม่พื้นที่เก็บข้อมูลเพื่อล้อมรอบการทดสอบเลเยอร์ข้อมูลสำหรับ repo การทดสอบหน่วยรอบ ๆ โค้ดที่ unflattens CSV ลงในตารางและทดสอบรอบ ๆ การค้นหา ประโยชน์เพียงอย่างเดียวของงานนี้ทั้งหมดคือการหลีกเลี่ยงการเข้ารหัสตารางการค้นหาอย่างหนัก เมื่อพูดคุยกับผู้ใช้ (ผู้ที่ใช้ตารางการค้นหาโดยตรง - โดยดูที่สำเนา) ความคิดเห็นนั้นค่อนข้างดีที่ …

10 design 

ก่อนอื่นฉันอ่านข้อความที่ตัดตอนมาของ Edsger W. Dijkstra ในปี 1974 "ในบทบาทของความคิดทางวิทยาศาสตร์": ให้ฉันพยายามอธิบายให้คุณฟังว่าอะไรคือรสนิยมของฉันสำหรับการคิดที่ชาญฉลาด มันคือว่าเราเต็มใจที่จะศึกษาในเชิงลึกในแง่มุมของเนื้อหาที่แยกออกมาเพื่อความมั่นคงของตัวเองตลอดเวลาที่รู้ว่าคนนั้นครอบครองตัวเองด้วยแง่มุมใดด้านหนึ่งเท่านั้น เรารู้ว่าโปรแกรมจะต้องถูกต้องและเราสามารถศึกษาได้จากมุมมองนั้นเท่านั้น เรารู้ด้วยว่ามันควรจะมีประสิทธิภาพและเราสามารถศึกษาประสิทธิภาพของมันในอีกวันหนึ่ง ในอีกอารมณ์หนึ่งเราอาจถามตัวเองว่าและถ้าเป็นเช่นนั้น: ทำไมโปรแกรมนี้จึงเป็นที่ต้องการ แต่ไม่มีสิ่งใดได้รับ - ในทางตรงกันข้าม! - โดยจัดการกับแง่มุมต่าง ๆ เหล่านี้พร้อมกัน บางครั้งฉันก็เรียกว่า "การแยกความกังวล" ซึ่งแม้ว่าจะเป็นไปไม่ได้อย่างสมบูรณ์ก็ตาม ยังเป็นเทคนิคเดียวที่มีอยู่สำหรับการจัดลำดับความคิดของคน ๆ หนึ่งที่ฉันรู้ นี่คือสิ่งที่ฉันหมายถึงโดย "การมุ่งความสนใจไปที่บางแง่มุม": มันไม่ได้หมายถึงการเพิกเฉยต่อแง่มุมอื่น ๆ มันแค่ทำความยุติธรรมกับข้อเท็จจริงที่ว่าจากมุมมองของแง่มุมนี้มุมมองอื่น ๆ นั้นไม่เกี่ยวข้อง มันเป็นหนึ่งในใจและหลายแทร็คพร้อมกัน ฉันเห็นการแยกข้อกังวลที่ทันสมัยพูดคุยเกี่ยวกับการทำให้โค้ดของคุณเป็นโมดูล อย่างไรก็ตามการอ่านคำพูดข้างต้นฉันเข้าใจว่านี่คือการมุ่งความคิดของคุณไปที่งานหนึ่งโดยเฉพาะในขณะที่ไม่ได้มุ่งเน้นด้านอื่น ๆ นี่ไม่ได้แปลว่าจำเป็นต้องแบ่งรหัสออกเป็นส่วนย่อย ๆ กล่าวคือมีโค้ดอยู่ข้างหน้าคุณว่าในไฟล์เดียวมีแนวคิดของมุมมองพื้นที่เก็บข้อมูลตัวควบคุมการจัดการเหตุการณ์โรงงาน ฯลฯ ทั้งหมดในไฟล์เดียว สำหรับตัวอย่างสั้น ๆ นี่คือโค้ดบางส่วนที่มีการเข้าถึงข้อมูลและมุมมอง (เอาต์พุต): $sql = "SELECT * …

9 design  source-code  separation-of-concerns  modularization  dijkstra 

ฉันใช้การถกเถียงระหว่างเพื่อนสองสามคนกับฉันพวกเขาชอบข้อยกเว้นทั่วไปเช่นClientErrorExceptionและServerErrorExceptionมีรายละเอียดเป็นฟิลด์ของข้อยกเว้นในขณะที่ฉันชอบทำสิ่งที่เฉพาะเจาะจงมากขึ้น ตัวอย่างเช่นฉันอาจมีข้อยกเว้นจำนวนหนึ่งเช่น: BadRequestException AuthenticationFailureException ProductNotFoundException แต่ละรายการเหล่านี้สร้างขึ้นตามรหัสข้อผิดพลาดที่ส่งคืนจาก API การติดตามข้อดีของข้อยกเว้นนี้ดูเหมือนว่าเป็นไปไม่ได้สำหรับ Java อย่างไรก็ตามความคิดเห็นของเพื่อนฉันไม่ใช่เรื่องแปลก มีวิธีที่ต้องการในแง่ของความสามารถในการอ่านโค้ดและการใช้งาน API หรือว่ามันเป็นเรื่องที่ชอบ?

9 java  design  exceptions 

ฉันเขียนโค้ดจำนวนมากที่เกี่ยวข้องกับสามขั้นตอนพื้นฐาน รับข้อมูลจากที่อื่น แปลงข้อมูลนั้น วางข้อมูลนั้นไว้ที่ใดที่หนึ่ง ปกติแล้วฉันจะใช้คลาสสามประเภท - โดยได้แรงบันดาลใจจากรูปแบบการออกแบบที่เกี่ยวข้อง โรงงาน - เพื่อสร้างวัตถุจากทรัพยากรบางอย่าง ผู้ไกล่เกลี่ย - เพื่อใช้โรงงานทำการเปลี่ยนแปลงจากนั้นใช้ผู้บังคับบัญชา ผู้บังคับบัญชา - เพื่อใส่ข้อมูลนั้นไปที่อื่น ชั้นเรียนของฉันมักจะมีขนาดค่อนข้างเล็กมักเป็นวิธีเดียว (สาธารณะ) เช่นรับข้อมูลแปลงข้อมูลทำงานทำงานบันทึกข้อมูล สิ่งนี้นำไปสู่การเพิ่มจำนวนชั้นเรียน แต่โดยทั่วไปก็ใช้งานได้ดี ที่ฉันต้องดิ้นรนคือเมื่อฉันมาทดสอบฉันลงเอยด้วยการทดสอบที่รัดกุม ตัวอย่างเช่น; โรงงาน - อ่านไฟล์จากดิสก์ Commander - เขียนไฟล์ลงดิสก์ ฉันไม่สามารถทำการทดสอบได้หากไม่มีอันอื่น ฉันสามารถเขียนรหัส 'ทดสอบ' เพิ่มเติมเพื่อทำดิสก์อ่าน / เขียนได้ แต่จากนั้นฉันก็ทำซ้ำตัวเอง เมื่อดูที่. Net คลาสFileจะใช้วิธีการที่แตกต่างกันโดยจะรวมความรับผิดชอบของโรงงานและผู้บังคับบัญชาเข้าด้วยกัน มันมีฟังก์ชั่นสำหรับการสร้างลบอยู่และอ่านทั้งหมดในที่เดียว ฉันควรมองหาที่จะทำตามตัวอย่างของ. Net และการรวมกันโดยเฉพาะอย่างยิ่งเมื่อจัดการกับทรัพยากรภายนอก - คลาสของฉันด้วยกันไหม? รหัสนั้นยังคงอยู่คู่กัน แต่มันมีความตั้งใจมากกว่า - มันเกิดขึ้นที่การใช้งานดั้งเดิมมากกว่าในการทดสอบ ปัญหาของฉันที่นี่ที่ฉันได้ใช้หลักการความรับผิดชอบเดียวค่อนข้าง …

9 design  clean-code  single-responsibility 

ฉันมีลำดับชั้นเรียนที่ฉันต้องการแยกอินเทอร์เฟซจากการใช้งาน โซลูชันของฉันคือการมีสองลำดับชั้น: ลำดับชั้นของการจัดการสำหรับอินเทอร์เฟซและลำดับชั้นของคลาสที่ไม่เป็นสาธารณะสำหรับการนำไปใช้ คลาสตัวจัดการพื้นฐานมีตัวชี้การใช้งานซึ่งคลาสตัวจัดการที่ได้รับมาส่งไปยังตัวชี้ของชนิดที่ได้รับ (ดูฟังก์ชันgetPimpl()) นี่คือภาพร่างของโซลูชันของฉันสำหรับคลาสพื้นฐานที่มีสองคลาสที่ได้รับ มีวิธีแก้ปัญหาที่ดีกว่านี้ไหม? ไฟล์ "Base.h": #include <memory> class Base { protected: class Impl; std::shared_ptr<Impl> pImpl; Base(Impl* pImpl) : pImpl{pImpl} {}; ... }; class Derived_1 final : public Base { protected: class Impl; inline Derived_1* getPimpl() const noexcept { return reinterpret_cast<Impl*>(pImpl.get()); } public: Derived_1(...); void func_1(...) const; …

9 design  c++  c++11 

ฉันกำลังสร้างส่วนติดต่อใน Java สำหรับตัวจัดการข้อผิดพลาดที่กำหนดเอง ต้องการส่งผ่านข้อผิดพลาดวัตถุข้อโต้แย้ง แต่ฉันต้องการมันเป็นลูกของExceptionชั้น จะใช้ชื่อคลาสที่กำหนดในอินเทอร์เฟซได้หรือไม่ มันจะทำให้อินเทอร์เฟซน้อยลงหรือไม่ขึ้นอยู่กับการใช้งานใด ๆ ฉันพยายามทำสิ่งนี้: public class CustomException { /* ... Implementation ... */ } public interface Interface { void onError(CustomException ex); }

9 java  design  object-oriented  interfaces 

ใน PPCG เรามักจะมีความท้าทายKing of the Hillซึ่งทำให้บ็อตโค้ดแตกต่างกัน เราไม่ต้องการ จำกัด การท้าทายเหล่านี้ในภาษาเดียวดังนั้นเราจึงทำการสื่อสารข้ามแพลตฟอร์มผ่าน I / O มาตรฐาน เป้าหมายของฉันคือการเขียนเฟรมเวิร์กที่ผู้เขียนท้าทายจะสามารถใช้ในการเขียนการท้าทายเหล่านี้ได้ง่ายขึ้น ฉันได้ทำตามข้อกำหนดต่อไปนี้แล้วฉันต้องการที่จะปฏิบัติตาม: ที่นักเขียนท้าทายคือสามารถที่จะทำให้ชั้นเรียนที่วิธีการเป็นตัวแทนของแต่ละการสื่อสารที่แตกต่างกัน ตัวอย่างเช่นในการท้าทายGood vs Evilของเราผู้เขียนจะสร้างPlayerคลาสที่มีabstract boolean vote(List<List<Boolean>> history)วิธีการ คอนโทรลเลอร์สามารถให้อินสแตนซ์ของคลาสด้านบนที่สื่อสารผ่าน I / O มาตรฐานเมื่อเรียกเมธอดที่กล่าวมาแล้ว ที่กล่าวว่าอินสแตนซ์ทั้งหมดของคลาสข้างต้นไม่จำเป็นต้องสื่อสารผ่าน I / O มาตรฐาน 3 ของบอตอาจเป็นบ็อต Java ดั้งเดิม (นั่นก็แค่แทนที่Playerคลาสที่อีก 2 อยู่ในภาษาอื่น) เมธอดจะไม่มีอาร์กิวเมนต์จำนวนเท่ากันเสมอ (และจะไม่มีค่าตอบแทน) ฉันต้องการนักเขียนที่ท้าทายต้องทำงานให้น้อยที่สุดเท่าที่จะทำได้เพื่อทำงานกับกรอบงานของฉัน ฉันไม่ได้ใช้การสะท้อนเพื่อแก้ไขปัญหาเหล่านี้ ฉันได้พิจารณาให้ผู้เขียนผู้ท้าทายทำสิ่งต่อไปนี้: class PlayerComm extends Player { private …

9 java  design  delegation 

มีบางส่วนของ codebase ของเราเขียนในรูปแบบต่อไปนี้: // IScheduledTask.cs public interface IScheduledTask { string TaskName { get; set; } int TaskPriority { get; set; } List<IScheduledTask> Subtasks { get; set; } // ... several more properties in this vein } // ScheduledTaskImpl.cs public class ScheduledTaskImpl : IScheduledTask { public string TaskName { get; set; …

9 design  object-oriented-design  interfaces  procedural 

จากการพัฒนาซอฟต์แวร์หลักการรูปแบบและการปฏิบัติ: Pearson New International Edition : บางครั้งวิธีที่เรียกใช้โดยกลุ่มลูกค้าที่แตกต่างกันจะทับซ้อนกัน หากการซ้อนทับมีขนาดเล็กดังนั้นอินเทอร์เฟซสำหรับกลุ่มควรจะแยกจากกัน ควรประกาศฟังก์ชันทั่วไปในอินเทอร์เฟซที่ทับซ้อนกันทั้งหมด คลาสเซิร์ฟเวอร์จะสืบทอดฟังก์ชันทั่วไปจากแต่ละอินเตอร์เฟสเหล่านั้น แต่จะใช้งานเพียงครั้งเดียว ลุงบ๊อบพูดถึงกรณีที่มีการเหลื่อมกันเล็กน้อย เราควรทำอย่างไรหากมีการทับซ้อนอย่างมีนัยสำคัญ บอกว่าเรามี Class UiInterface1; Class UiInterface2; Class UiInterface3; Class UiIterface : public UiInterface1, public UiInterface2, public UiInterface3{}; เราควรทำอย่างไรหากมีการทับซ้อนกันระหว่างUiInterface1และUiInterface2?

9 design  object-oriented  c++  interfaces  solid 

ดังนั้นใช่ไดอะแกรมอาจไม่เหมาะสมในบางครั้ง เมื่อใดที่ไม่เหมาะสม เมื่อคุณสร้างพวกเขาโดยไม่มีรหัสเพื่อตรวจสอบพวกเขาแล้วตั้งใจที่จะติดตามพวกเขา ไม่มีอะไรผิดปกติกับการวาดไดอะแกรมเพื่อสำรวจความคิด การพัฒนาซอฟต์แวร์แบบว่องไว: หลักการรูปแบบและการปฏิบัติ - Robert C. Martin สิ่งนี้หมายความว่าอย่างไร UML ไม่ได้ออกแบบมาเพื่อช่วยวางแผนวิธีจัดโครงสร้างโค้ดของคุณก่อน "ลงมือดำน้ำ" หรือไม่? อะไรคือจุดประสงค์ของการใช้มันถ้าคุณไม่ทำตามไดอะแกรมที่คุณคิดขึ้นมา บริบท: ในบทนี้ลุงบ็อบจัดทำแผนภาพ UML สำหรับผู้รักษาคะแนนของเกมโบว์ลิ่ง จากนั้นเขาก็ไปพัฒนาโปรแกรมในลักษณะทดสอบการขับเคลื่อนโดยไม่ปรึกษาแผนภาพ UML โปรแกรมที่ได้นั้นไม่มีอะไรเหมือนกับแผนภาพ UML และลุงบ๊อบก็มาถึงข้อสรุปที่กล่าวไว้ข้างต้น

9 design  object-oriented  tdd  uml 

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

9 design  design-patterns  architecture  object-oriented-design  design-principles 

สมมติว่าคุณมีโครงสร้างข้อมูลบางประเภทซึ่งยังคงอยู่ในฐานข้อมูลบางประเภท เพื่อความง่ายเราจะเรียกโครงสร้างข้อมูลPersonนี้ ขณะนี้คุณได้รับมอบหมายให้ออกแบบ CRUD API ซึ่งอนุญาตให้แอปพลิเคชันอื่นสร้างอ่านอัปเดตและลบPersons เพื่อความง่ายลองสมมติว่า API นี้เข้าถึงได้ผ่านบริการเว็บบางประเภท สำหรับชิ้นส่วน C, R และ D ของ CRUD การออกแบบนั้นง่าย ฉันจะใช้เครื่องหมายคล้ายฟังก์ชัน C # - การใช้งานอาจเป็น SOAP, REST / JSON หรืออย่างอื่น: class Person { string Name; DateTime? DateOfBirth; ... } Identifier CreatePerson(Person); Person GetPerson(Identifier); void DeletePerson(Identifier); แล้วการอัพเดตล่ะ? สิ่งที่ต้องทำตามธรรมชาติคือ void UpdatePerson(Identifier, Person); แต่วิธีการที่คุณจะต้องระบุให้ซึ่งด้านของPersonการอัปเดต? วิธีแก้ปัญหาที่ฉันสามารถทำได้: คุณสามารถกำหนดให้บุคคลที่สมบูรณ์ต้องผ่านเช่นลูกค้าจะทำสิ่งนี้เพื่ออัปเดตวันเกิด: …

9 design  api  web-services  api-design  crud 

ฉันกำลังเขียนแอปพลิเคชัน C ++ แอปพลิเคชันส่วนใหญ่อ่านและเขียนข้อมูลที่จำเป็นและนี่ก็ไม่มีข้อยกเว้น ฉันสร้างการออกแบบระดับสูงสำหรับตัวแบบข้อมูลและตรรกะการทำให้เป็นอนุกรม คำถามนี้ขอให้ตรวจสอบการออกแบบของฉันโดยคำนึงถึงเป้าหมายเฉพาะเหล่านี้: เพื่อให้มีวิธีที่ง่ายและยืดหยุ่นในการอ่านและเขียนข้อมูลในรูปแบบที่กำหนดเอง: raw binary, XML, JSON, และอื่น ๆ อัล รูปแบบของข้อมูลควรถูกแยกออกจากตัวข้อมูลเช่นเดียวกับรหัสที่ร้องขอการทำให้เป็นอนุกรม เพื่อให้แน่ใจว่าการทำให้เป็นอนุกรมนั้นไม่มีข้อผิดพลาดเท่าที่จะทำได้ I / O มีความเสี่ยงโดยเนื้อแท้ด้วยเหตุผลหลายประการ: การออกแบบของฉันแนะนำวิธีที่ล้มเหลวมากขึ้นหรือไม่? ถ้าเป็นเช่นนั้นฉันจะปรับการออกแบบใหม่เพื่อลดความเสี่ยงเหล่านั้นได้อย่างไร โครงการนี้ใช้ C ++ ไม่ว่าคุณจะรักหรือเกลียดมันเป็นภาษาที่มีวิธีการของตัวเองในการทำสิ่งต่าง ๆ และจุดมุ่งหมายของการออกแบบเพื่อให้ทำงานร่วมกับภาษาไม่ได้กับมัน สุดท้ายโครงการจะสร้างขึ้นบนwxWidgets ในขณะที่ฉันกำลังมองหาวิธีแก้ปัญหาที่เหมาะสมกับกรณีทั่วไปมากขึ้นการใช้งานเฉพาะนี้ควรใช้กับชุดเครื่องมือนั้น สิ่งที่ตามมาคือชุดคลาสที่ง่ายมากที่เขียนใน C ++ ที่แสดงการออกแบบ นี่ไม่ใช่คลาสจริงที่ฉันเขียนบางส่วนจนถึงตอนนี้รหัสนี้แสดงให้เห็นถึงการออกแบบที่ฉันใช้อยู่ ขั้นแรกให้บางตัวอย่าง DAO: #include <iostream> #include <map> #include <memory> #include <string> #include <vector> // One widget …

9 design  c++  c++11 

ฉันได้ยินมาว่าขอแนะนำให้ตรวจสอบข้อโต้แย้งของวิธีการสาธารณะ: หนึ่งควรตรวจสอบโมฆะถ้าเขาไม่คาดหวังโมฆะ? เมธอดควรตรวจสอบความถูกต้องของพารามิเตอร์หรือไม่ MSDN - CA1062: ตรวจสอบข้อโต้แย้งของวิธีสาธารณะ (ฉันมีพื้นหลัง. NET แต่คำถามไม่เฉพาะ C #) แรงจูงใจสามารถเข้าใจได้ หากโมดูลจะถูกใช้ในทางที่ผิดเราต้องการที่จะโยนข้อยกเว้นทันทีแทนที่จะเป็นพฤติกรรมที่คาดเดาไม่ได้ สิ่งที่รบกวนจิตใจฉันคือข้อโต้แย้งที่ผิดไม่ใช่ข้อผิดพลาดเดียวที่สามารถทำได้ในขณะที่ใช้โมดูล นี่คือสถานการณ์ข้อผิดพลาดบางประการที่เราจำเป็นต้องเพิ่มตรรกะการตรวจสอบหากเราทำตามคำแนะนำและไม่ต้องการการเพิ่มระดับข้อผิดพลาด: สายเรียกเข้า - อาร์กิวเมนต์ที่ไม่คาดคิด สายเรียกเข้า - โมดูลอยู่ในสถานะไม่ถูกต้อง โทรภายนอก - ส่งคืนผลลัพธ์ที่ไม่คาดคิด การโทรภายนอก - ผลข้างเคียงที่ไม่คาดคิด (การป้อนสองครั้งในโมดูลการโทร, การแยกสถานะการอ้างอิงอื่น ๆ ) ฉันได้ลองคำนึงถึงเงื่อนไขเหล่านี้และเขียนโมดูลง่าย ๆ ด้วยวิธีการหนึ่ง (ขออภัยไม่ใช่ -C # guys): public sealed class Room { private readonly IDoorFactory _doorFactory; private bool …

9 design  code-quality  coding-standards  exceptions  error-handling