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

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

21 design-patterns 

ฉันไม่ได้ใช้รูปแบบการออกแบบบ่อยครั้งนอกเหนือจากโรงงานเป็นครั้งคราวและ MVC และฉันต้องการเริ่มใช้พวกเขามากขึ้น ฉันมีกรณีที่เป็นรูปธรรมที่ฉันต้องการความเห็นของคุณเกี่ยวกับการใช้รูปแบบการออกแบบในกรณีนี้ ในแอปพลิเคชันของฉันฉันต้องแปลงวัตถุบ่อยครั้งในสถานการณ์ที่แตกต่างกัน ฉันอาจต้องแปลง PONO ของ Hibernate เป็น DTO เนื่องจากฉันใช้ GWT และ Hibernate POJO นั้นไม่สามารถต่อเนื่องได้และไม่สามารถส่งข้ามสายได้ ในสถานการณ์อื่นฉันอาจต้องแปลงวัตถุ Java เป็น SolrInputDocument เพื่อสร้างดัชนีโดย Solr ฉันต้องการทราบว่าฉันควรใช้รูปแบบการออกแบบสำหรับสิ่งนี้หรือไม่ ดูเหมือนว่า "การแปลงวัตถุ" เป็นงานทั่วไปที่สามารถจัดการในรูปแบบที่มีความยืดหยุ่น / เป็นนามธรรมโดยรูปแบบ แต่ฉันไม่เห็นวิธีจริงๆ หากไม่มีรูปแบบฉันจะสร้างคลาสแยกต่างหากสำหรับการแปลงแต่ละประเภทตัวอย่างเช่น CourseToSolrInputDocument (หลักสูตรเป็นเอนทิตีไฮเบอร์เนตในแอปพลิเคชันของฉัน) หรือ CourseToCourseDTO แต่ละคลาสการแปลงเหล่านี้อาจมีวิธีสแตติกเดียวที่เรียกconvert()ว่าใช้วัตถุต้นทางเป็นอินพุตและส่งคืนวัตถุเอาต์พุต แต่นั่นไม่ใช่รูปแบบจริงๆใช่ไหม? ดังนั้นฉันจึงเริ่มทำบางสิ่งกับยาชื่อสามัญและสร้างคลาสนี้ที่ใช้ส่วนต่อประสานตัวแปลง แต่อย่างใดรู้สึกโง่ tgo สร้างอินเทอร์เฟซทั่วไปและฉันไม่เห็นประโยชน์นอกเหนือจากความสามารถในการแสดงความยินดีกับการใช้ generics public class CourseToSolrInputDocument implements Converter<Course, SolrInputDocument> { @Override …

21 java  design-patterns  object 

ฉันกำลังทำงานในโครงการที่ประมวลผลคำขอและมีสององค์ประกอบในการร้องขอคือคำสั่งและพารามิเตอร์ ตัวจัดการสำหรับแต่ละคำสั่งนั้นง่ายมาก (<10 บรรทัดมัก <5) มีคำสั่งอย่างน้อย 20 คำและน่าจะมีมากกว่า 50 คำสั่ง ฉันคิดวิธีแก้ปัญหาสองสามข้อ: สวิตช์ใหญ่ / if-else หนึ่งคำสั่ง แผนที่ของคำสั่งไปยังฟังก์ชั่น แผนที่ของคำสั่งไปยังคลาสที่คงที่ / singletons แต่ละคำสั่งทำการตรวจสอบข้อผิดพลาดเล็กน้อยและบิตเดียวที่สามารถแยกออกได้คือการตรวจสอบจำนวนพารามิเตอร์ที่กำหนดไว้สำหรับแต่ละคำสั่ง อะไรจะเป็นทางออกที่ดีที่สุดสำหรับปัญหานี้และเพราะอะไร ฉันยังเปิดรับรูปแบบการออกแบบใด ๆ ที่ฉันอาจพลาดไป ฉันคิดรายการ pro / con ต่อไปนี้สำหรับแต่ละรายการ: สวิตซ์ ข้อดี เก็บคำสั่งทั้งหมดไว้ในฟังก์ชันเดียว เนื่องจากมันเรียบง่ายนี่ทำให้เป็นตารางการค้นหาด้วยภาพ ไม่ต้องวุ่นวายกับแหล่งข้อมูลด้วยฟังก์ชั่นขนาดเล็กจำนวนมาก / คลาสที่สามารถใช้งานได้ในที่เดียว ข้อเสีย นานมาก ยากที่จะเพิ่มคำสั่งโดยทางโปรแกรม (จำเป็นต้องโยงใช้ตัวพิมพ์เล็ก) คำสั่งแผนที่ -> ฟังก์ชั่น ข้อดี ชิ้นเล็กขนาดกัด สามารถเพิ่ม / ลบคำสั่งโดยทางโปรแกรม ข้อเสีย หากทำแบบอินไลน์เหมือนกับสวิตช์ …

21 design  design-patterns  map  switch-statement 

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

21 design-patterns  object-oriented  programming-practices  ruby 

ฉันค่อนข้างใหม่ในทีมผู้พัฒนาของเรา ฉันต้องการข้อโต้แย้งที่รัดกุมและ / หรือตัวอย่าง "หลุมพราง" ดังนั้นในที่สุดเจ้านายของฉันจะเข้าใจถึงข้อดีของ Unobtrusive JavaScript เพื่อให้เขาและคนอื่น ๆ ในทีมหยุดทำสิ่งนี้: <input type="button" class="bow-chicka-wow-wow" onclick="send_some_ajax(); return false;" value="click me..." /> และ <script type="text/javascript"> function send_some_ajax() { // bunch of code ... BUT using jQuery !!! } </script> ฉันแนะนำให้ใช้ลวดลายธรรมดา: <button id="ajaxer" type="button">click me...</button> และ <script type="text/javascript"> // since #ajaxer is also …

21 design-patterns  javascript  jquery 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 7 ปีที่ผ่านมา แบบจำลองข้อมูลของเรามีเกือบ 200 คลาสที่สามารถแบ่งออกเป็นประมาณหนึ่งโหลหน้าที่การทำงาน คงจะเป็นการดีที่จะใช้โดเมน แต่การแยกนั้นไม่สะอาดและเราไม่สามารถเปลี่ยนได้ เรากำลังออกแบบ DAL ของเราใหม่เพื่อใช้ Entity Framework และคำแนะนำส่วนใหญ่ที่ฉันเคยเห็นแนะนำให้ใช้รูปแบบ Repository อย่างไรก็ตามไม่มีตัวอย่างใดที่จัดการกับตัวแบบวัตถุที่ซับซ้อนได้ การใช้งานบางอย่างที่ฉันพบแนะนำให้ใช้ repository ต่อเอนทิตี ดูเหมือนว่าไร้สาระและไม่สามารถบำรุงรักษาได้สำหรับรุ่นที่มีขนาดใหญ่และซับซ้อน จำเป็นหรือไม่ที่จะสร้าง UnitOfWork สำหรับแต่ละการดำเนินการและที่เก็บสำหรับแต่ละเอนทิตี ฉันสามารถจบลงด้วยชั้นเรียนหลายพันชั้น ฉันรู้ว่าสิ่งนี้ไม่สมเหตุสมผล แต่ฉันได้พบแนวทางเล็กน้อยในการใช้ Repository, Unit of Work และ Entity Framework ผ่านโมเดลที่ซับซ้อนและแอปพลิเคชันทางธุรกิจที่สมจริง

21 asp.net-mvc  entity-framework  design-patterns 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว การเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์แบบไม่บล็อกไม่ตรงกันดูเหมือนว่าจะเป็นความโกรธทั้งหมด ฉันมีความเข้าใจแนวคิดพื้นฐานเกี่ยวกับความหมายทั้งหมดนี้ อย่างไรก็ตามสิ่งที่ฉันไม่แน่ใจคือเมื่อใดและรหัสของฉันจะได้ประโยชน์จากการเป็นแบบอะซิงโครนัสหรือวิธีการบล็อก IO การไม่บล็อก ฉันแน่ใจว่าฉันสามารถใช้ห้องสมุดเพื่อทำสิ่งนี้ได้ แต่ฉันสนใจในแนวคิดเชิงลึกมากขึ้นและวิธีการต่าง ๆ ในการนำมันมาใช้เอง มีหนังสือที่ครอบคลุม / แตกหักหรือแหล่งข้อมูลอื่น ๆ ในเรื่องนี้ (เช่นGoFสำหรับรูปแบบการออกแบบหรือK&Rสำหรับ C, tldpสำหรับสิ่งต่าง ๆ เช่นทุบตี) (หมายเหตุ: ฉันไม่แน่ใจว่านี่เป็นคำถามที่ตรงกับคำถามของฉันในการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์การเรียนรู้หรือไม่ )

21 design-patterns  learning  books  architectural-patterns  asynchronous-programming 

ฉันมักจะใช้รูปแบบที่ฉันใช้วิธีการผูกมัดการตั้งค่าวัตถุคล้ายกับBuilderหรือPrototypeรูปแบบ แต่ไม่ได้สร้างวัตถุใหม่ที่มีการเรียกแต่ละวิธีแทนการปรับเปลี่ยนวัตถุเดิม ตัวอย่าง: new Menu().withItem("Eggs").withItem("Hash Browns").withStyle("Diner"); เพียงแค่สงสัยว่ามีชื่อสำหรับรูปแบบนี้หรือไม่และพิจารณาว่าเป็นรูปแบบการต่อต้านหรือไม่เพราะถึงแม้ว่ามันจะสามารถอ่านได้อย่างคล่องแคล่วมากขึ้นก็สามารถนำไปสู่โซ่วิธียาว

21 design-patterns  coding-style  code-quality  patterns-and-practices  method-chaining 

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

21 design-patterns 

ฉันมีรายการผลิตภัณฑ์ ผู้ให้บริการแต่ละรายจะถูกเสนอโดย N ผู้ให้บริการแต่ละรายเสนอราคาให้เราตามวันที่เฉพาะเจาะจง ราคานั้นจะมีผลจนกว่าผู้ให้บริการรายนั้นจะตัดสินใจกำหนดราคาใหม่ ในกรณีนั้นผู้ให้บริการจะแจ้งราคาใหม่พร้อมวันที่ใหม่ ส่วนหัวของตาราง MySQL ในปัจจุบันดูเหมือนว่า: provider_id, product_id, price, date_price_effective ทุก ๆ วันเราจะรวบรวมรายการผลิตภัณฑ์ / ราคาที่มีผลสำหรับวันปัจจุบัน สำหรับแต่ละผลิตภัณฑ์รายการจะมีรายการที่เรียงลำดับของผู้ให้บริการที่มีผลิตภัณฑ์นั้น ๆ ด้วยวิธีนี้เราสามารถสั่งซื้อผลิตภัณฑ์บางอย่างจากใครก็ตามที่เสนอราคาที่ดีที่สุด เพื่อให้ได้ราคาที่มีประสิทธิภาพผมมีคำสั่ง SQL date_price_effective >= NOW()ที่ส่งกลับแถวทั้งหมดที่มี ชุดผลลัพธ์นั้นถูกประมวลผลด้วยสคริปต์ ruby ​​ซึ่งทำการเรียงลำดับและกรองข้อมูลที่จำเป็นเพื่อรับไฟล์ที่มีลักษณะดังนี้: product_id_1,provider_1,provider_3,provider8,provider_10... product_id_2,provider_3,provider_2,provider1,provider_10... มันใช้งานได้ดีสำหรับวัตถุประสงค์ของเรา แต่ฉันยังคงมีอาการคันที่ตาราง SQL อาจไม่ใช่วิธีที่ดีที่สุดในการจัดเก็บข้อมูลประเภทนี้ ฉันมีความรู้สึกว่าปัญหาแบบนี้ได้รับการแก้ไขก่อนหน้านี้ในรูปแบบที่สร้างสรรค์มากขึ้น มีวิธีที่ดีกว่าในการจัดเก็บข้อมูลนี้นอกเหนือจากใน SQL? หรือถ้าใช้ SQL มีวิธีที่ดีกว่าที่ฉันใช้อยู่หรือไม่?

21 design-patterns  database 

ฉันไม่เห็นความแตกต่างระหว่าง MVC และ MVVM อย่างชัดเจน ฉันรู้สึกว่า Command ใน ViewModel นั้นเหมือนกับวิธี Action ใน Controller และทั้ง Controller และ ViewModel จะแจ้งเตือนให้ View ทำการรีเฟรชตัวเองหลังจากแก้ไขสถานะของ Model ผ่าน Data Binding ความแตกต่างที่สำคัญระหว่างสองรูปแบบคืออะไร?

21 asp.net  design-patterns  silverlight 

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

21 design-patterns  constructors  builder-pattern 

ฉันเพิ่งลบคำตอบjavaของฉันในการตรวจสอบรหัสที่เริ่มต้นเช่นนี้: private Person(PersonBuilder builder) { หยุด. ธงแดง PersonBuilder จะสร้างบุคคล มันรู้เกี่ยวกับบุคคล คลาส Person ไม่ควรรู้อะไรเกี่ยวกับ PersonBuilder - เป็นเพียงประเภทที่ไม่เปลี่ยนรูป คุณสร้างคัปปลิ้งแบบวงกลมตรงนี้โดยที่ A ขึ้นอยู่กับ B ซึ่งขึ้นอยู่กับ A บุคคลนั้นควร จำกัด พารามิเตอร์ของตน ลูกค้าที่เต็มใจสร้างบุคคลโดยไม่สร้างมันควรจะสามารถทำเช่นนั้นได้ ฉันถูกตบด้วย downvote และบอกว่า (อ้างถึง) การตั้งค่าสถานะสีแดงทำไม? การใช้งานที่นี่มีรูปร่างเดียวกับที่ Joshua Bloch แสดงในหนังสือ "Effective Java" ของเขา (รายการ # 2) ดังนั้นดูเหมือนว่าวิธีที่ถูกต้องในการนำรูปแบบการสร้างมาใช้ใน Java คือการสร้างชนิดซ้อน (นี่ไม่ใช่สิ่งที่คำถามนี้เกี่ยวกับว่า) และจากนั้นสร้างผลิตภัณฑ์ (คลาสของวัตถุที่ถูกสร้างขึ้น ) ใช้การพึ่งพาผู้สร้างเช่นนี้ private …

20 java  design-patterns  coupling  builder-pattern 

มีเหตุผลมากมายว่าทำไมคนรอบข้างจึงชั่วร้ายใน OOP หากจำนวนหรือขนาดของวัตถุที่ต้องการแบ่งปันมีขนาดใหญ่เกินไปที่จะส่งผ่านอย่างมีประสิทธิภาพในพารามิเตอร์ฟังก์ชั่นมักจะทุกคนแนะนำพึ่งพาการฉีดแทนวัตถุทั่วโลก อย่างไรก็ตามในกรณีที่เกือบทุกคนจำเป็นต้องรู้เกี่ยวกับโครงสร้างข้อมูลบางอย่างทำไมการพึ่งพาการฉีดจึงดีกว่าวัตถุระดับโลก ตัวอย่าง (ตัวย่อที่เรียบง่ายเพื่อแสดงจุดโดยทั่วไปโดยไม่ต้องเจาะลึกในแอปพลิเคชันเฉพาะ) มีรถยนต์เสมือนจำนวนมากที่มีคุณสมบัติและสถานะจำนวนมากตั้งแต่ประเภทชื่อสีไปจนถึงความเร็วตำแหน่ง ฯลฯ ผู้ใช้จำนวนมากสามารถควบคุมจากระยะไกลและเหตุการณ์จำนวนมาก (ทั้งผู้ใช้ - เริ่มต้นและอัตโนมัติ) สามารถเปลี่ยนสถานะหรือคุณสมบัติได้มากมาย วิธีการแก้ปัญหาที่ไร้เดียงสาคือการสร้างภาชนะใส่ของโลกเช่น vector<Vehicle> vehicles; ซึ่งสามารถเข้าถึงได้จากทุกที่ วิธีแก้ปัญหาที่เป็นมิตรกับ OOP ก็คือให้มีคอนเทนเนอร์เป็นสมาชิกของคลาสที่จัดการห่วงเหตุการณ์หลักและถูกสร้างอินสแตนซ์ในตัวสร้าง ทุกคลาสที่ต้องการมันและเป็นสมาชิกของเธรดหลักจะได้รับการเข้าถึงคอนเทนเนอร์ผ่านตัวชี้ในตัวสร้างของพวกเขา ตัวอย่างเช่นหากข้อความภายนอกเข้ามาผ่านการเชื่อมต่อเครือข่ายคลาส (หนึ่งสำหรับแต่ละการเชื่อมต่อ) การจัดการการแยกจะใช้เวลามากกว่าและ parser จะเข้าถึงคอนเทนเนอร์ผ่านตัวชี้หรือการอ้างอิง ตอนนี้ถ้าข้อความที่วิเคราะห์คำส่งผลให้เกิดการเปลี่ยนแปลงในองค์ประกอบของคอนเทนเนอร์หรือต้องการข้อมูลบางส่วนเพื่อดำเนินการก็สามารถจัดการได้โดยไม่จำเป็นต้องสลับตัวแปรหลายพันตัวผ่านสัญญาณและช่องเสียบ (หรือแย่กว่านั้น เก็บไว้ใน parser ที่จะเรียกคืนในภายหลังโดยผู้ที่เรียกว่า parser) แน่นอนว่าคลาสทั้งหมดที่ได้รับการเข้าถึงคอนเทนเนอร์ผ่านการฉีดเป็นส่วนหนึ่งของเธรดเดียวกัน เธรดที่แตกต่างกันจะไม่สามารถเข้าถึงได้โดยตรง แต่ทำงานของพวกเขาแล้วส่งสัญญาณไปยังเธรดหลักและสล็อตในเธรดหลักจะอัพเดตคอนเทนเนอร์ อย่างไรก็ตามถ้าส่วนใหญ่ของคลาสจะเข้าถึงคอนเทนเนอร์สิ่งที่ทำให้แตกต่างจากส่วนกลาง หากคลาสจำนวนมากต้องการข้อมูลในคอนเทนเนอร์ไม่ใช่ "วิธีการฉีดพึ่งพา" เป็นเพียงระบบปลอมทั่วโลกใช่หรือไม่ คำตอบหนึ่งก็คือความปลอดภัยของเธรด: แม้ว่าฉันจะระวังไม่ให้ใช้ภาชนะที่ไม่เหมาะสมกับผู้ใช้ทั่วโลกบางทีผู้พัฒนารายอื่นในอนาคตภายใต้แรงกดดันของเส้นตายที่ใกล้จะถึงกระนั้นก็ตาม กรณีการปะทะกัน อย่างไรก็ตามแม้ในกรณีของการฉีดพึ่งพาใครสามารถชี้ให้คนที่ทำงานในหัวข้ออื่นที่นำไปสู่ปัญหาเดียวกัน

20 design-patterns  object-oriented  dependency-injection 

เมื่อใช้ภาษาที่สนับสนุนอาร์กิวเมนต์ที่ตั้งชื่อและเป็นตัวเลือกรูปแบบตัวสร้างจะไม่มีประโยชน์ในทางปฏิบัติอีกต่อไปหรือไม่ ผู้สร้าง: new Builder(requiredA, requiredB).setOptionalA("optional").Build(); อาร์กิวเมนต์ตัวเลือก / ชื่อ: new Object(requiredA, requiredB, optionalA: "optional");

20 design-patterns  builder-pattern