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

ฉันจะบอกได้อย่างไรว่าซอฟต์แวร์ของฉันมีสิ่งที่เป็นนามธรรมมากเกินไปและมีรูปแบบการออกแบบมากเกินไปหรือในทางกลับกันฉันจะรู้ได้อย่างไรว่าควรมีซอฟต์แวร์มากกว่านั้น นักพัฒนาที่ฉันทำงานด้วยกำลังเขียนโปรแกรมต่าง ๆ เกี่ยวกับประเด็นเหล่านี้ บางฟังก์ชั่นเป็นนามธรรมทุกฟังก์ชั่นเล็กน้อยใช้รูปแบบการออกแบบทุกที่ที่เป็นไปได้ คนอื่นรวมถึงฉันพยายามที่จะใช้ประโยชน์ได้มากขึ้นและเขียนโค้ดที่ไม่เหมาะกับทุกรูปแบบการออกแบบ แต่เป็นวิธีที่เข้าใจได้เร็วขึ้นเพราะใช้นามธรรมน้อยกว่า ฉันรู้ว่านี่เป็นการแลกเปลี่ยน ฉันจะบอกได้อย่างไรว่ามีสิ่งที่เป็นนามธรรมเพียงพอในโครงการและฉันจะรู้ได้อย่างไรว่ามันต้องการมาก ตัวอย่างเมื่อเลเยอร์แคชทั่วไปถูกเขียนโดยใช้ Memcache เราจำเป็นต้องจริงๆMemcache, MemcacheAdapter, MemcacheInterface, AbstractCache, CacheFactory, CacheConnector... หรือคือง่ายต่อการรักษาและยังคงรหัสที่ดีเมื่อใช้เพียงครึ่งหนึ่งของชั้นเรียนเหล่านั้นหรือไม่ พบสิ่งนี้ใน Twitter: ( https://twitter.com/rawkode/status/875318003306565633 )

29 design-patterns  architecture  clean-code  abstraction  architectural-patterns 

กฎหมายของ Demeterกล่าวต่อไปนี้: แต่ละหน่วยควรมีความรู้ที่ จำกัด เฉพาะเกี่ยวกับหน่วยอื่น ๆ : เฉพาะหน่วย "อย่างใกล้ชิด" ที่เกี่ยวข้องกับหน่วยปัจจุบัน แต่ละหน่วยควรคุยกับเพื่อนเท่านั้น อย่าคุยกับคนแปลกหน้า พูดคุยกับเพื่อนของคุณทันที C # 6.0 แนะนำผู้ประกอบการใหม่ที่เรียกว่าผู้ประกอบการ null เงื่อนไข IMHO ทำให้การเข้ารหัสง่ายขึ้นและปรับปรุงความสามารถในการอ่าน แต่มันยังทำให้ง่ายต่อการเขียนรหัสคู่มากขึ้นเนื่องจากง่ายต่อการเลื่อนดูฟิลด์คลาสและตรวจสอบค่าว่าง (เช่นvar x = A?.B?.C?.D?.E?.F?) ถูกต้องหรือไม่หากระบุว่าผู้ประกอบการรายใหม่นี้ขัดต่อกฎหมายของ Demeter

29 c#  design-patterns  object-oriented-design 

โปรดอ่านคำถามอย่างระมัดระวัง: จะถามว่าไม่ว่าทำไม ฉันเพิ่งเจอคำตอบนี้ซึ่งแนะนำให้ใช้ฐานข้อมูลเพื่อเก็บข้อมูลที่ไม่เปลี่ยนรูปแบบ: ดูเหมือนว่าตัวเลขเวทมนต์มากมายที่คุณอธิบายโดยเฉพาะอย่างยิ่งหากเป็นส่วนที่ขึ้นกับข้อมูลจริง ๆ ไม่ใช่รหัส [... ] มันอาจหมายถึงฐานข้อมูลประเภท SQL หรืออาจหมายถึงไฟล์ข้อความที่จัดรูปแบบ มันจะดูเหมือนกับผมว่าถ้าคุณมีข้อมูลที่เป็นส่วนหนึ่งของสิ่งที่โปรแกรมของคุณไม่แล้วสิ่งที่ต้องทำคือการใส่ไว้ในโปรแกรม ตัวอย่างเช่นหากฟังก์ชั่นโปรแกรมของคุณคือการนับเสียงสระมีอะไรผิดปกติvowels = "aeiou"หรือไม่ ท้ายที่สุดแล้วภาษาส่วนใหญ่มีโครงสร้างข้อมูลที่ออกแบบมาเพื่อการใช้งานนี้อย่างแม่นยำ เหตุใดคุณจึงต้องแยกข้อมูลโดยใส่ใน "ไฟล์ข้อความที่จัดรูปแบบ" ตามที่แนะนำข้างต้น ทำไมไม่เพียงทำให้ไฟล์ข้อความนั้นถูกจัดรูปแบบในภาษาการเขียนโปรแกรมที่คุณเลือก ตอนนี้มันเป็นฐานข้อมูลหรือไม่ หรือมันคือรหัส? ฉันแน่ใจว่าบางคนจะคิดว่านี่เป็นคำถามที่โง่ แต่ฉันถามมันอย่างจริงจัง ฉันรู้สึกว่า "การแยกรหัสและข้อมูล" กำลังเกิดขึ้นทางวัฒนธรรมเนื่องจากความจริงที่เห็นได้ชัดในตัวเองพร้อมกับสิ่งที่ชัดเจนอื่น ๆ เช่น "ไม่ให้ตัวแปรของคุณทำให้ชื่อที่ทำให้เข้าใจผิด" และ "อย่าหลีกเลี่ยงการใช้ช่องว่างเพราะภาษาของคุณพิจารณา มันไม่มีนัยสำคัญ " ใช้ตัวอย่างเช่นบทความนี้: ปัญหากับข้อมูลแยกจากรหัสหุ่นกระบอก ปัญหาเหรอ มีปัญหาอะไร? ถ้าPuppetเป็นภาษาสำหรับอธิบายโครงสร้างพื้นฐานของฉันทำไมมันถึงอธิบายไม่ได้ว่า nameserver คือ 8.8.8.8 สำหรับฉันแล้วดูเหมือนว่าปัญหาไม่ใช่รหัสและข้อมูลนั้นปะปนกันอยู่1แต่ Puppet ขาดโครงสร้างข้อมูลที่สมบูรณ์และวิธีการเชื่อมต่อกับสิ่งอื่น ๆ ฉันพบว่าการเปลี่ยนแปลงนี้รบกวน การเขียนโปรแกรมเชิงวัตถุกล่าวว่า "เราต้องการโครงสร้างข้อมูลที่หลากหลายตามอำเภอใจ" และมอบโครงสร้างข้อมูลด้วยพลังของรหัส …

29 design-patterns 

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

29 java  design-patterns 

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

29 design  design-patterns  architecture  domain-driven-design  entity-framework 

ฉันจะบันทึกส่วนของข้อมูลสตริงในฐานข้อมูล ฉันมีการกำหนดค่าระดับโลกสองแบบ: การเข้ารหัส การอัด สิ่งเหล่านี้สามารถเปิดใช้งานหรือปิดการใช้งานโดยใช้การกำหนดค่าในลักษณะที่เปิดใช้งานเพียงอย่างเดียวเท่านั้นทั้งสองถูกเปิดใช้งานหรือทั้งสองอย่างถูกปิดใช้งาน การใช้งานปัจจุบันของฉันคือ: if (encryptionEnable && !compressEnable) { encrypt(data); } else if (!encryptionEnable && compressEnable) { compress(data); } else if (encryptionEnable && compressEnable) { encrypt(compress(data)); } else { data; } ฉันกำลังคิดเกี่ยวกับลวดลายมัณฑนากร มันเป็นตัวเลือกที่ถูกต้องหรืออาจเป็นทางเลือกที่ดีกว่า

28 design  design-patterns  object-oriented-design  refactoring 

ข้อบกพร่องที่รู้จักกันดีของลำดับชั้นของคลาสดั้งเดิมคือมันไม่ดีเมื่อพูดถึงการสร้างแบบจำลองโลกแห่งความจริง ตัวอย่างเช่นพยายามเป็นตัวแทนสายพันธุ์สัตว์ด้วยชั้นเรียน จริงๆแล้วมีปัญหาหลายอย่างเมื่อทำเช่นนั้น แต่สิ่งหนึ่งที่ฉันไม่เคยเห็นวิธีแก้คือเมื่อ "พฤติกรรม" หรือคุณสมบัติย่อยที่สูญเสียไปซึ่งถูกกำหนดไว้ในระดับซุปเปอร์คลาสเหมือนเพนกวินที่ไม่สามารถบินได้ อาจเป็นตัวอย่างที่ดีกว่า แต่นั่นเป็นสิ่งแรกที่อยู่ในใจของฉัน) ในอีกด้านหนึ่งคุณไม่ต้องการกำหนดสำหรับทุกคุณสมบัติและพฤติกรรมบางธงที่ระบุว่าเป็นปัจจุบันและตรวจสอบทุกครั้งก่อนที่จะเข้าถึงพฤติกรรมหรือทรัพย์สินนั้น คุณแค่อยากจะบอกว่านกสามารถบินได้ง่ายและชัดเจนในชั้นเรียนนก แต่มันจะดีถ้าใครสามารถนิยาม "ข้อยกเว้น" หลังจากนั้นโดยไม่ต้องใช้แฮ็คที่น่ากลัวทุกที่ สิ่งนี้มักจะเกิดขึ้นเมื่อระบบมีประสิทธิผลในขณะที่ คุณจะพบข้อยกเว้น "" ที่ไม่พอดีกับการออกแบบดั้งเดิมเลยและคุณไม่ต้องการเปลี่ยนรหัสส่วนใหญ่เพื่อรองรับมัน ดังนั้นมีบางภาษาหรือรูปแบบการออกแบบที่สามารถจัดการปัญหานี้ได้อย่างหมดจดโดยไม่ต้องมีการเปลี่ยนแปลงที่สำคัญกับ "super-class" และรหัสทั้งหมดที่ใช้หรือไม่ แม้ว่าโซลูชันจะจัดการกับเคสเฉพาะเท่านั้นโซลูชันจำนวนมากอาจรวมกันเป็นกลยุทธ์ที่สมบูรณ์ หลังจากคิดเพิ่มขึ้นฉันรู้ว่าฉันลืมเกี่ยวกับหลักการทดแทน Liskov นั่นคือเหตุผลที่คุณไม่สามารถทำได้ สมมติว่าคุณกำหนด "คุณสมบัติ / อินเทอร์เฟซ" สำหรับ "กลุ่มคุณลักษณะ" หลักทั้งหมดคุณสามารถใช้คุณลักษณะในสาขาต่าง ๆ ของลำดับชั้นได้อย่างอิสระเช่นเดียวกับลักษณะการบินที่สามารถนำไปใช้กับนกและกระรอกและปลาชนิดพิเศษบางอย่าง ดังนั้นคำถามของฉันอาจมีค่าเป็น "ฉันจะยกเลิกการใช้คุณลักษณะได้อย่างไร" หากซุปเปอร์คลาสของคุณเป็น Java Serializable คุณก็ต้องเป็นหนึ่งด้วยแม้ว่าคุณจะไม่มีวิธีในการทำให้เป็นอันดับสถานะของคุณเช่นถ้าคุณมี "Socket" วิธีหนึ่งในการทำคือการกำหนดคุณสมบัติทั้งหมดของคุณเป็นคู่ตั้งแต่เริ่มต้น: การบินและการไม่พูดถึง (ซึ่งจะโยน UnsupportedOperationException หากไม่ได้ตรวจสอบกับ) ไม่ใช่คุณสมบัติจะไม่กำหนดอินเทอร์เฟซใหม่ใด ๆ และสามารถตรวจสอบได้ง่ายๆ ดูเหมือนโซลูชันที่ "ถูก" …

28 design-patterns  liskov-substitution 

สำหรับทุกโครงการการเขียนโปรแกรมผู้จัดการที่มีประสบการณ์การเขียนโปรแกรมที่ผ่านมาพยายามส่องแสงเมื่อพวกเขาแนะนำรูปแบบการออกแบบบางอย่างสำหรับโครงการของคุณ ฉันชอบรูปแบบการออกแบบเมื่อพวกเขาเข้าท่าหรือถ้าคุณต้องการโซลูชันที่ปรับขนาดได้ ฉันใช้พร็อกซีผู้สังเกตการณ์และรูปแบบคำสั่งในลักษณะที่เป็นบวกและทำทุกวัน แต่ฉันลังเลที่จะใช้พูดรูปแบบโรงงานหากมีวิธีเดียวเท่านั้นในการสร้างวัตถุเนื่องจากโรงงานอาจทำให้ทุกอย่างง่ายขึ้นในอนาคต แต่จะทำให้รหัสซับซ้อนและมีค่าใช้จ่ายที่ซับซ้อน ดังนั้นคำถามของฉันคือเกี่ยวกับอาชีพในอนาคตของฉันและคำตอบของฉันสำหรับผู้จัดการประเภทที่มีการสุ่มชื่อรูปแบบรอบ ๆ : คุณใช้รูปแบบการออกแบบแบบไหนที่ทำให้คุณกลับมาโดยรวม? รูปแบบการออกแบบใดที่เลวร้ายที่สุดรูปแบบที่คุณควรพิจารณายกเว้นในสถานการณ์เดียวที่มีเหตุผล (อ่าน: รูปแบบการออกแบบใดที่นิยามไว้แคบมาก) (มันเหมือนกับว่าฉันกำลังมองหารีวิวเชิงลบของผลิตภัณฑ์ที่ดีโดยรวมของ Amazon เพื่อดูว่าคนที่ถูกหลอกลวงมากที่สุดในการใช้รูปแบบการออกแบบ) และฉันไม่ได้พูดถึง Anti-Patterns ที่นี่ แต่เกี่ยวกับรูปแบบที่มักจะคิดว่าเป็น รูปแบบ "ดี" แก้ไข:ตามที่บางคนตอบปัญหาส่วนใหญ่มักจะมีรูปแบบที่ไม่ "ไม่ดี" แต่ "ใช้ผิด" หากคุณรู้จักรูปแบบที่มักใช้ในทางที่ผิดหรือยากต่อการใช้

28 bad-code  anti-patterns  patterns-and-practices  design-patterns 

เมื่อเร็ว ๆ นี้ฉันมาข้าม codebase หลามขนาดใหญ่ในระดับปานกลางมีจำนวนมากMyClassAbstractFactory, MyClassManager, MyClassProxy, MyClassAdapterเรียน ฯลฯ ในขณะที่ในมือข้างหนึ่งชื่อเหล่านั้นชี้ให้ฉันเพื่อการวิจัยและการเรียนรู้รูปแบบที่สอดคล้องกันที่พวกเขาไม่สามารถอธิบายในสิ่งที่ชั้นไม่ นอกจากนี้พวกเขาดูเหมือนจะตกอยู่ในรายชื่อต้องห้ามของคำในการเขียนโปรแกรม: variable, process_available_information, data, amount, compute: ชื่อกว้างเกินไปที่ไม่ได้บอกให้เราทราบอะไรเกี่ยวกับฟังก์ชั่นเมื่อใช้ด้วยตัวเอง ดังนั้นควรจะมีCommunicationManagerหรือมากกว่าPortListener? หรือบางทีฉันไม่เข้าใจปัญหาเลย ... ?

28 design-patterns  naming 

ฉันกำลังสร้าง REST API ซึ่งผู้ใช้หลายคนที่มีบทบาทที่แตกต่างกันจะสามารถเข้าถึงทรัพยากรที่มีอยู่ เพื่อให้ขอบเขตง่ายขึ้นขอโดเมน "นักเรียน / ครู / ชั้นเรียน": GET /students เป็นทรัพยากรที่จะเข้าถึง ผู้ใช้อาจมีบทบาทเช่นนักเรียนและ / หรืออาจารย์ นักเรียนจะสามารถเข้าถึงนักเรียนของชั้นเรียนของพวกเขาเท่านั้น ครูจะสามารถเข้าถึงนักเรียนของชั้นเรียนที่พวกเขาสอน การใช้งานบางอย่างอาจเป็นนักเรียนและสอนชั้นเรียนอื่น ๆ ด้วย พวกเขาจะต้องสามารถเข้าถึงนักเรียนของชั้นเรียนของพวกเขาและนักเรียนของชั้นเรียนที่พวกเขาสอน นึกคิดฉันต้องการที่จะใช้สิ่งนี้เป็นสองฟังก์ชั่น - หนึ่งต่อบทบาทและจากนั้น "สหภาพ" ถ้าผู้ใช้มีหลายบทบาท คำถามของฉันคือฉันควรใช้รูปแบบใดในการดำเนินการนี้ อย่างผิวเผิน ฉันควรแยก API ต่อบทบาทของฉันหรือไม่ GET /teacher/studentsและGET /student/studentsดูเหมือนจะไม่ถูกต้องสำหรับฉัน เก็บทุกอย่างฉันเป็นแหล่งข้อมูลเดียว (แนะนำ) ภายใน ควรนำไปใช้ภายในอย่างไร ทุกวิธีควรเริ่มต้นด้วยสวิตช์ขนาดใหญ่ / ต่อบทบาทหรือไม่ ฉันควรใช้ที่เก็บต่อบทบาทหรือไม่ มีรูปแบบการออกแบบที่จะช่วยฉันในการบรรลุเป้าหมายนี้หรือไม่? ตามความเห็นด้านข้าง: ฉันใช้ASP.NET Web APIและEntity Framework 6แต่จริงๆแล้วมันไม่สำคัญสำหรับการนำแนวคิดไปใช้

27 design-patterns  programming-practices  rest  web-api 

ใครสามารถให้คำตอบที่ยอมรับได้กับฉันเกี่ยวกับความแตกต่างระหว่างObservera Mediatorและ a และบทสรุปของเมื่อคุณควรใช้รูปแบบหนึ่งเหนืออีกรูปแบบหนึ่งได้หรือไม่ ฉันไม่แน่ใจว่าสถานการณ์แบบไหนที่จะต้องการObserverและสิ่งที่จะต้องมีMediator

27 design-patterns 

ฉันได้อ่านความคิดเห็นที่แตกต่างกันเกี่ยวกับรูปแบบซิงเกิล บางคนยืนยันว่าควรหลีกเลี่ยงค่าใช้จ่ายและอื่น ๆ ที่สามารถเป็นประโยชน์ในบางสถานการณ์ สถานการณ์หนึ่งที่ฉันใช้ singletons คือเมื่อฉันต้องการโรงงาน (สมมติว่าวัตถุประเภท f) เพื่อสร้างวัตถุของคลาส A แน่นอนโรงงานถูกสร้างขึ้นครั้งเดียวโดยใช้พารามิเตอร์การกำหนดค่าบางอย่างจากนั้นจะใช้แต่ละครั้งที่วัตถุของ พิมพ์ A ถูกสร้างขึ้น ดังนั้นทุกส่วนของรหัสที่ต้องการอินสแตนซ์ A ดึงค่าซิงเกิลตันและสร้างอินสแตนซ์ใหม่เช่น F& f = F::instance(); boost::shared_ptr<A> a = f.createA(); ดังนั้นสถานการณ์ทั่วไปของฉันก็คือ ฉันต้องการอินสแตนซ์เดียวของคลาสอย่างใดอย่างหนึ่งด้วยเหตุผลการปรับให้เหมาะสม (ฉันไม่ต้องการวัตถุหลายโรงงาน) หรือสำหรับการแบ่งปันสถานะทั่วไป (เช่นโรงงานทราบจำนวนอินสแตนซ์ของ A ที่ยังคงสามารถสร้างได้) ฉันต้องการวิธีการเข้าถึง f ของอินสแตนซ์นี้ในสถานที่ต่าง ๆ ของรหัส ฉันไม่สนใจในการอภิปรายว่ารูปแบบนี้ดีหรือไม่ดี แต่สมมติว่าฉันต้องการหลีกเลี่ยงการใช้ซิงเกิลตันฉันสามารถใช้รูปแบบอื่นแบบใดได้บ้าง แนวคิดที่ฉันมีคือ (1) นำวัตถุของโรงงานออกจากรีจิสตรีหรือ (2) เพื่อสร้างโรงงานในบางช่วงระหว่างการเริ่มต้นโปรแกรมแล้วส่งโรงงานเป็นพารามิเตอร์ ในโซลูชัน (1) ตัวรีจิสตรีนั้นเป็นซิงเกิลดังนั้นฉันเพิ่งเปลี่ยนปัญหาการไม่ใช้ซิงเกิลตันจากโรงงานไปยังรีจิสตรี ในกรณี (2) …

27 design-patterns  programming-practices  anti-patterns  singleton 

ฉันใช้วิธีที่คล้ายกับ DDD สำหรับโมดูลกรีนฟิลด์ของแอปพลิเคชันที่มีอยู่ ไม่ใช่ DDD 100% เนื่องจากสถาปัตยกรรม แต่ฉันพยายามใช้แนวคิด DDD บางอย่าง ฉันมีบริบท จำกัด (ผมคิดว่าเป็นระยะที่เหมาะสม - ฉันยังคงเรียนรู้เกี่ยวกับ DDD) ประกอบด้วยสองหน่วยงาน: และConversation Messageการสนทนาเป็นรากฐานเนื่องจากข้อความไม่มีอยู่โดยไม่มีการสนทนาและข้อความทั้งหมดในระบบเป็นส่วนหนึ่งของการสนทนา ฉันมีConversationRepositoryชั้นเรียน (แม้ว่าจะเป็นเหมือนเกตเวย์จริงๆแล้วฉันใช้คำว่า "พื้นที่เก็บข้อมูล") ซึ่งค้นหาบทสนทนาในฐานข้อมูล เมื่อพบการสนทนาและยังสร้าง (ผ่านทางโรงงาน) รายการข้อความสำหรับการสนทนานั้น (เปิดเผยเป็นคุณสมบัติ) นี่ดูเหมือนจะเป็นวิธีที่ถูกต้องในการจัดการสิ่งต่าง ๆ เนื่องจากไม่จำเป็นต้องมีMessageRepositoryคลาสที่เต็มไปด้วยลมหายใจเนื่องจากมีอยู่เฉพาะเมื่อมีการสนทนาเท่านั้น อย่างไรก็ตามเมื่อพูดถึงการบันทึกข้อความนี่เป็นความรับผิดชอบของ ConversationRepository เนื่องจากเป็นรากรวมของข้อความหรือไม่ สิ่งที่ฉันหมายถึงคือฉันควรมีวิธีการใน ConversationRepository เรียกว่าพูดAddMessageที่ใช้ข้อความเป็นพารามิเตอร์และบันทึกไว้ในฐานข้อมูลหรือไม่ หรือฉันควรจะมีที่เก็บแยกต่างหากสำหรับการค้นหา / บันทึกข้อความ? ดูเหมือนว่าเหตุผลจะเป็นหนึ่งที่เก็บต่อหน่วย แต่ฉันก็ได้ยิน "หนึ่งที่เก็บต่อบริบท"

27 design-patterns  architecture  domain-driven-design 

ฉันค่อนข้างสบายใจกับการฉีดแบบพึ่งพาโดยใช้ NInject ใน MVC3 ในขณะที่ทำงานในแอปพลิเคชัน MVC3 ฉันได้พัฒนา Factory Creation Factory แบบกำหนดเองโดยใช้ NInject ดังนั้นคอนโทรลเลอร์ใด ๆ ที่สร้างขึ้นจะมีการขึ้นต่อกันของมันผ่านทาง Factory Controller นี้ ตอนนี้ฉันเริ่มพัฒนาแอพพลิเคชัน windows ฉันต้องการใช้ Application Wide Dependency Injection เช่นวัตถุทุกชิ้นจะต้องสร้างผ่าน NInject เพื่อให้ง่ายต่อการทดสอบหน่วย โปรดแนะนำฉันเพื่อให้แน่ใจว่าวัตถุทุกชิ้นที่สร้างขึ้นต้องเป็นโรงงาน NInject เท่านั้น ตัวอย่างเช่นถ้าในหน้าต่างใด ๆ ในรูปแบบButton_Clickเหตุการณ์ฉันเขียน: TestClass testClass = new TestClass() และTestClassมีการพึ่งพาพูดพูดITestแล้วมันจะต้องได้รับการแก้ไขโดยอัตโนมัติ ฉันรู้ว่าฉันสามารถใช้: Ikernel kernel = new StandardKenel() //AddBinding() TestClass testClass = …

27 .net  design-patterns  unit-testing  dependency-injection 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันมี codebase ที่โปรแกรมเมอร์มักจะห่อสิ่งต่าง ๆ ในพื้นที่ที่ไม่สมเหตุสมผล ตัวอย่างเช่นให้บันทึกข้อผิดพลาดเรามีคุณสามารถเข้าสู่ระบบผ่าน ErrorLog.Log(ex, "friendly message"); เขาเพิ่มวิธีการอื่น ๆ อีกมากมายเพื่อให้งานเดียวกันนั้นสำเร็จ เช่น SomeClass.Log(ex, "friendly message"); ซึ่งจะหมุนไปรอบ ๆ และเรียกวิธีแรก สิ่งนี้จะเพิ่มระดับความซับซ้อนโดยไม่มีประโยชน์เพิ่มเติม มีรูปแบบการต่อต้านเพื่ออธิบายสิ่งนี้หรือไม่?

26 design-patterns  anti-patterns