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

ตัวอย่าง # 1: ฉันมีมุมมองที่แสดงในแอปพลิเคชัน MVVM ของฉัน (ลองใช้ Silverlight เพื่อจุดประสงค์ในการอภิปราย) และฉันคลิกที่ปุ่มที่ควรพาฉันไปที่หน้าใหม่ ตัวอย่าง # 2: มุมมองเดียวกันนั้นมีปุ่มอื่นที่เมื่อคลิกแล้วควรเปิดมุมมองรายละเอียดในหน้าต่างลูก (กล่องโต้ตอบ) เรารู้ว่าจะมีวัตถุคำสั่งที่เปิดเผยโดย ViewModel ของเราที่เชื่อมโยงกับปุ่มด้วยวิธีการที่ตอบสนองต่อการคลิกของผู้ใช้ แต่ถ้าเช่นนั้นจะเป็นอย่างไร เราจะดำเนินการให้เสร็จสมบูรณ์ได้อย่างไร? แม้ว่าเราใช้ NavigationService ที่เรียกว่าอะไรเราจะบอกอะไร เพื่อให้เฉพาะเจาะจงมากขึ้นในโมเดล View-first แบบดั้งเดิม (เช่นโครงร่างการนำทางตาม URL เช่นบนเว็บหรือเฟรมเวิร์กการนำทางในตัว SL) วัตถุคำสั่งจะต้องรู้ว่ามุมมองใดที่จะแสดงถัดไป ที่ดูเหมือนว่าจะข้ามเส้นเมื่อมันมาถึงการแยกความกังวลที่ส่งเสริมโดยรูปแบบ ในทางกลับกันถ้าปุ่มไม่ได้เชื่อมต่อกับวัตถุคำสั่งและทำตัวเหมือนไฮเปอร์ลิงก์กฎการนาวิเกตอาจถูกกำหนดในมาร์กอัป แต่เราต้องการให้ Views ควบคุมการไหลของแอปพลิเคชันและไม่ใช่การนำทางเป็นเพียงตรรกะทางธุรกิจประเภทอื่นหรือไม่ (ฉันสามารถพูดได้ว่าใช่ในบางกรณีและไม่ใช่ในคนอื่น ๆ ) สำหรับฉันการใช้ยูโทเปียของรูปแบบ MVVM (และฉันเคยได้ยินคนอื่นยอมรับสิ่งนี้) จะต้องมี ViewModel แบบมีสายในลักษณะที่แอปพลิเคชันสามารถเรียกใช้หัว (เช่นไม่มีมุมมอง) นี่เป็นพื้นที่ผิวสำหรับการทดสอบที่ใช้รหัสมากที่สุดและทำให้ Views เป็นสกินที่แท้จริงในแอปพลิเคชัน และ …

33 design-patterns  silverlight  mvvm 

ฉันกำลังทำงานบนระบบที่มีผู้ใช้และผู้ใช้แต่ละคนมีหนึ่งหรือหลายบทบาท เป็นวิธีปฏิบัติที่ดีที่จะใช้ค่า List of Enum กับผู้ใช้หรือไม่ ฉันไม่สามารถคิดอะไรได้ดีไปกว่านี้ แต่มันก็ไม่เป็นไร enum Role{ Admin = 1, User = 2, } class User{ ... List<Role> Roles {get;set;} }

32 design-patterns  object-oriented 

ฉันทำโปรแกรมเว็บมานานแล้วและที่ไหนสักแห่งฉันก็ไม่รู้ว่าทำไมเราถึงทำสิ่งที่เราทำในวันนี้ (หรือเรามาทำสิ่งต่าง ๆ แบบนี้)? ฉันเริ่มต้นด้วยการพัฒนาเว็บ ASP ขั้นพื้นฐานและในช่วงแรกตรรกะการแสดงผลและตรรกะทางธุรกิจได้ปะปนกันบนหน้าเว็บ การพัฒนาฝั่งไคลเอ็นต์มีความแตกต่างกันอย่างมาก (VBScript, รสชาติที่แตกต่างกันของ JavaScript) และเรามีคำเตือนมากมายเกี่ยวกับการตรวจสอบความถูกต้องของฝั่งเซิร์ฟเวอร์ (ดังนั้นฉันจึงอยู่ห่างจากตรรกะฝั่งไคลเอ็นต์) จากนั้นฉันย้ายไปที่ ColdFusion ชั่วครู่หนึ่ง ColdFusion อาจเป็นกรอบการพัฒนาเว็บแรกที่แยกการแสดงผลและตรรกะทางธุรกิจโดยใช้แท็ก ดูเหมือนจะชัดเจนสำหรับฉัน แต่ verbose มากและ ColdFusion ไม่ได้เป็นที่ต้องการของตลาดสูงและดังนั้นฉันจึงเดินหน้าต่อไป จากนั้นฉันก็กระโดดขึ้นไปบนเกวียน ASP.NET และเริ่มใช้วิธี MVC ของพวกเขา ฉันก็รู้ว่า Java ดูเหมือนจะเป็นภาษาหอคอยงาช้างของระบบองค์กรและยังลองใช้วิธี MVC ของพวกเขา ต่อมา ASP.NET พัฒนารูปแบบการออกแบบ MVVM นี้และ Java (แม่นยำ J2EE หรือ JEE) ก็ดิ้นรนและออกมาด้วยวิธีการ MVC2 แต่วันนี้สิ่งที่ฉันได้ค้นพบคือการเขียนโปรแกรมแบ็คเอนด์ไม่ได้อยู่ที่ความตื่นเต้นและความก้าวหน้าอีกต่อไป นอกจากนี้แนวปฏิบัติ MVC บนฝั่งเซิร์ฟเวอร์ดูเหมือนจะล้าสมัยแล้ว …

32 design-patterns  javascript  programming-practices 

เพื่อนของฉันกำลังทำงานให้กับ บริษัท เล็ก ๆ ในโครงการที่ผู้พัฒนาทุกคนจะเกลียด: เขาถูกกดดันให้ปล่อยตัวโดยเร็วที่สุดเขาเป็นคนเดียวที่ดูเหมือนจะสนใจหนี้ทางเทคนิคลูกค้าไม่มีพื้นฐานด้านเทคนิค ฯลฯ เขาเล่าเรื่องซึ่งทำให้ฉันคิดถึงความเหมาะสมของรูปแบบการออกแบบในโครงการเช่นนี้ นี่คือเรื่องราวของ เราต้องแสดงผลิตภัณฑ์ในที่ต่างๆบนเว็บไซต์ ตัวอย่างเช่นผู้จัดการเนื้อหาสามารถดูผลิตภัณฑ์ แต่ยังรวมถึงผู้ใช้หรือคู่ค้าผ่าน API บางครั้งข้อมูลหายไปจากผลิตภัณฑ์ตัวอย่างเช่นกลุ่มหนึ่งไม่มีราคาเมื่อสร้างผลิตภัณฑ์ แต่ยังไม่ได้ระบุราคา บางคนไม่มีคำอธิบาย (คำอธิบายเป็นวัตถุที่ซับซ้อนที่มีประวัติดัดแปลงเนื้อหาที่แปลเป็นภาษาท้องถิ่น ฯลฯ ) บางคนขาดข้อมูลการจัดส่ง แรงบันดาลใจจากการอ่านล่าสุดของฉันเกี่ยวกับรูปแบบการออกแบบผมคิดว่านี่คือโอกาสที่ดีที่จะใช้ที่มีมนต์ขลังรูปแบบวัตถุ Null ดังนั้นฉันจึงทำและทุกอย่างราบรื่นและสะอาด มีเพียงแค่โทรproduct.Price.ToString("c")เพื่อแสดงราคาหรือproduct.Description.Currentแสดงคำอธิบาย; ไม่จำเป็นต้องมีเงื่อนไข จนกระทั่งวันหนึ่งผู้มีส่วนได้เสียขอให้แสดงต่างกันใน API โดยมี a nullใน JSON และยังแตกต่างกันสำหรับผู้จัดการเนื้อหาด้วยการแสดง "ราคาไม่ระบุ [เปลี่ยน]" และฉันต้องฆ่ารูปแบบวัตถุ Null ที่รักของฉันเพราะมันไม่จำเป็นอีกต่อไป ในทำนองเดียวกันฉันต้องลบโรงงานนามธรรมไม่กี่แห่งและผู้สร้างไม่กี่คนฉันลงเอยด้วยการเปลี่ยนรูปแบบ Facade ที่สวยงามของฉันโดยการโทรโดยตรงและน่าเกลียดเพราะอินเทอร์เฟซพื้นฐานเปลี่ยนไปสองครั้งต่อวันเป็นเวลาสามเดือน เมื่อข้อกำหนดบอกว่าวัตถุที่เกี่ยวข้องจะต้องแตกต่างกันขึ้นอยู่กับบริบท มากกว่าสามสัปดาห์ของการทำงานประกอบด้วยการเพิ่มรูปแบบการออกแบบจากนั้นฉีกออกเป็นชิ้น ๆ ในอีกหนึ่งเดือนต่อมาและในที่สุดโค้ดของฉันก็กลายเป็นสปาเก็ตตี้มากพอที่จะเป็นไปไม่ได้ที่จะรักษาโดยใครก็ตาม จะเป็นการดีกว่าหรือที่จะไม่ใช้รูปแบบเหล่านั้นตั้งแต่แรก? อันที่จริงฉันต้องทำงานด้วยตัวเองในโครงการประเภทต่างๆที่ความต้องการมีการเปลี่ยนแปลงอยู่ตลอดเวลาและถูกกำหนดโดยบุคคลที่ไม่ได้อยู่ในใจของการทำงานร่วมกันหรือการเชื่อมโยงของผลิตภัณฑ์ ในบริบทนี้มันไม่สำคัญว่าคุณจะคล่องตัวแค่ไหนคุณจะมาพร้อมกับวิธีการแก้ปัญหาที่สง่างามและเมื่อคุณใช้มันในที่สุดคุณจะได้เรียนรู้ว่าความต้องการเปลี่ยนแปลงไปอย่างมากและโซลูชันที่สง่างามของคุณไม่เหมาะสม ได้อีกต่อไป. อะไรจะเป็นทางออกในกรณีนี้? ไม่ได้ใช้รูปแบบการออกแบบหยุดคิดและเขียนรหัสโดยตรงหรือไม่ …

32 design-patterns  agile  changes 

ในการเขียนโปรแกรมสิ่งที่เรียกว่า Principle of Least ประหลาดใจ? แนวคิดนี้เกี่ยวข้องกับการออกแบบ API ที่ดีอย่างไร สิ่งนี้ใช้ได้กับการเขียนโปรแกรมเชิงวัตถุเท่านั้นหรือมันซึมซาบเทคนิคการเขียนโปรแกรมอื่น ๆ ด้วยหรือไม่ สิ่งนี้เกี่ยวข้องกับหลักการ "ทำสิ่งเดียวในวิธีการของคุณและทำได้ดีหรือไม่"?

32 design  design-patterns  object-oriented 

ฉันกำลังเรียนออกแบบซอฟต์แวร์ที่ฉันควรเลือกซอฟต์แวร์โอเพ่นซอร์สเพื่อวิเคราะห์จากมุมมองการออกแบบซอฟต์แวร์ มันจะต้องเป็นโครงการขนาดใหญ่: ไม่น้อยกว่า 100,000 บรรทัดของรหัส ฉันอยากจะเลือกซอฟต์แวร์ที่ได้รับการออกแบบมาเป็นอย่างดีและออกแบบให้มีความเข้าใจในการออกแบบซอฟต์แวร์ที่ดี โดยการออกแบบที่ดีฉันหมายถึงสิ่งต่าง ๆ เช่นคลาสที่มีความหมายและสถาปัตยกรรมการใช้รูปแบบ (การออกแบบ) ที่ดีการใช้สิ่งที่เป็นนามธรรมการจัดองค์ประกอบที่ดีการประสานที่สูง คุณมีซอฟต์แวร์อะไรบ้างที่จะแนะนำฉัน ทราบว่าซอฟต์แวร์เพียงแค่ต้องมีการออกแบบที่ดีการออกแบบไม่จำเป็นต้องมีเอกสาร! :) มันไม่จำเป็นต้องเป็นแอปพลิเคชั่นสำหรับผู้ใช้ ... มันอาจจะเป็นห้องสมุดเครื่องมือ ฯลฯ ...

32 design  design-patterns  architecture 

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

32 c#  design-patterns 

จากรูปแบบการออกแบบ "Gang of Four" มีวิธี Factory: class Factory(product) case product when a new A when b new B when c new C end new Factory(a) นี่คือเหตุผลที่มีประโยชน์มากขึ้นกว่าที่มีสามชั้นa, bและcและเรียกพวกเขาที?

32 design-patterns 

รูปแบบ "ตัวสร้าง" ถูก จำกัด ให้จัดการกับรูปแบบการต่อต้าน "ตัวสร้างเหลื่อม" หรืออาจกล่าวได้ว่าเป็นการแก้ปัญหาทั่วไปของการสร้างวัตถุที่ไม่เปลี่ยนรูปแบบที่ซับซ้อนมากขึ้นหรือไม่? StringBuilderชั้นจะมีคำว่า "ผู้สร้าง" ในชื่อของมัน แต่มันมีอะไรจะทำอย่างไรกับความเหลื่อมก่อสร้างมันก็ช่วยให้เราได้รวบรวมข้อมูลทั้งหมดที่เราต้องผ่านการสร้างของวัตถุที่ไม่เปลี่ยนรูป สำหรับฉันดูเหมือนว่าคำตอบจะชัดเจนมาก "ใช่" แต่ดูเหมือนจะมีความขัดแย้งในหัวข้อดังนั้นฉันหวังว่าบางคนอาจจะอธิบายได้ ฉันตอบคำถามนี้: โปรแกรมเมอร์ SE: "งานจริง" ที่ถูกต้องในตัวสร้าง? ที่ OP ต้องการสร้างวัตถุ (น่าจะไม่เปลี่ยนรูป) ที่มีต้นไม้ที่ซับซ้อนและความคิดของรูปแบบ "ผู้สร้าง" โผล่ขึ้นมาและในขณะที่ทำการวิจัยผมพบว่า Q&A นี้ซึ่งดูเหมือนว่ารูปแบบการสร้างวัตถุ "StringBuilder" คือไม่ได้เป็นโปรแกรมของ "สร้าง" รูปแบบสำหรับเหตุผลที่ไม่ชัดเจนกับผม: Stackoverflow - StringBuilder และสร้างรูปแบบ (ผู้ที่ตอบคำถามนั้นล้มเหลวในการสร้างจุดที่น่าเชื่อถือเท่าที่ฉันสามารถบอกได้)

31 design  design-patterns  builder-pattern 

ฉันเห็นการใช้งานหลายอย่างของรูปแบบตัวสร้าง (ส่วนใหญ่ใน Java) พวกเขาทั้งหมดมีคลาสเอนทิตี้ (สมมุติว่าPersonคลาส) และคลาสบิลPersonBuilderเดอร์ ผู้สร้าง "สแต็ค" ฟิลด์ที่หลากหลายและส่งกลับค่าnew Personด้วยอาร์กิวเมนต์ที่ส่งผ่าน ทำไมเราต้องมีคลาสผู้สร้างอย่างชัดเจนแทนที่จะใส่เมธอดผู้สร้างทั้งหมดลงในPersonคลาสเอง? ตัวอย่างเช่น: class Person { private String name; private Integer age; public Person() { } Person withName(String name) { this.name = name; return this; } Person withAge(int age) { this.age = age; return this; } } ฉันสามารถพูดได้ Person john = …

31 java  design-patterns  builder-pattern 

ซึ่งเป็นวิธีปฏิบัติที่ยอมรับกันโดยทั่วไประหว่างสองกรณีนี้: function insertIntoDatabase(Account account, Otherthing thing) { database.insertMethod(account.getId(), thing.getId(), thing.getSomeValue()); } หรือ function insertIntoDatabase(long accountId, long thingId, double someValue) { database.insertMethod(accountId, thingId, someValue); } กล่าวอีกนัยหนึ่งโดยทั่วไปแล้วการส่งวัตถุทั้งหมดไปรอบ ๆ

31 design-patterns  object-oriented  programming-practices  coding-standards  encapsulation 

ฉันมีรหัสบางส่วนที่ฉันทำซ้ำแผนที่จนกว่าเงื่อนไขบางอย่างจะเป็นจริงและต่อมาก็ใช้เงื่อนไขนั้นเพื่อทำบางสิ่งเพิ่มเติม ตัวอย่าง: Map<BigInteger, List<String>> map = handler.getMap(); if(map != null && !map.isEmpty()) { for (Map.Entry<BigInteger, List<String>> entry : map.entrySet()) { fillUpList(); if(list.size() > limit) { limitFlag = true; break; } } } else { logger.info("\n>>>>> \n\t 6.1 NO entries to iterate over (for given FC and target) \n"); } if(!limitFlag) …

30 design-patterns  object-oriented  object-oriented-design  clean-code 

ฉันอ่านคำถามที่เกี่ยวข้องมีรูปแบบการออกแบบใดที่ไม่จำเป็นในภาษาไดนามิกเช่น Python หรือไม่? และจดจำคำพูดนี้บน Wikiquote.org สิ่งมหัศจรรย์เกี่ยวกับการพิมพ์แบบไดนามิกคือช่วยให้คุณสามารถแสดงสิ่งที่คำนวณได้ และประเภทของระบบไม่พิมพ์ - ระบบประเภทมักจะตัดสินใจได้และพวกเขา จำกัด ให้คุณเป็นส่วนย่อย ผู้ที่ชื่นชอบระบบแบบสแตติกพูดว่า“ ใช้ได้เลยมันดีพอ โปรแกรมที่น่าสนใจทั้งหมดที่คุณต้องการเขียนจะใช้งานได้ตามประเภท” แต่นั่นไร้สาระ - เมื่อคุณมีระบบพิมพ์คุณจะไม่รู้ด้วยซ้ำว่าโปรแกรมที่น่าสนใจนั้นมีอะไรบ้าง --- วิทยุวิศวกรรมซอฟต์แวร์ตอนที่ 140: Newspeak และประเภทที่เสียบได้ด้วย Gilad Bracha ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

30 design-patterns  python  type-systems  dynamic-typing 

ฉันอยากรู้ว่าอะไรคือข้อเสียของการใช้รูปแบบ ActiveRecord สำหรับการเข้าถึงข้อมูล / วัตถุทางธุรกิจ คนเดียวที่ฉันสามารถนึกได้ว่าอยู่เหนือหัวของฉันคือมันละเมิดหลักการความรับผิดชอบเดียว แต่รูปแบบ AR เป็นเรื่องธรรมดาพอที่เหตุผลนี้เพียงอย่างเดียวดูเหมือนจะไม่ "ดีพอ" ที่จะพิสูจน์ว่าไม่ได้ใช้ (แน่นอน มุมมองอาจเบ้เพราะบ่อยครั้งที่ไม่มีรหัสที่ฉันทำงานด้วยตามหลักการ SOLID ใด ๆ ) โดยส่วนตัวฉันไม่ใช่แฟนของ ActiveRecord (ยกเว้นการเขียนแอพพลิเคชั่น Ruby on Rails ที่ AR ให้ความรู้สึก "เป็นธรรมชาติ") เพราะมันรู้สึกว่าคลาสทำมากเกินไปและการเข้าถึงข้อมูลไม่ควรขึ้นอยู่กับชั้นเรียน เพื่อจัดการ ฉันชอบใช้ที่เก็บที่ส่งคืนออบเจคทางธุรกิจ ส่วนใหญ่ของรหัสที่ฉันทำงานด้วยมีแนวโน้มที่จะใช้รูปแบบของ ActiveRecord ในรูปแบบของ (ฉันไม่ทราบว่าทำไมวิธีการเป็นบูลีน): public class Foo { // properties... public Foo(int fooID) { this.fooID = fooID; } public bool …

30 design-patterns 

เพื่อนร่วมงานของฉันและฉันมีความเห็นต่างกันเกี่ยวกับความสัมพันธ์ระหว่างคลาสพื้นฐานและอินเทอร์เฟซ ฉันเชื่อว่าคลาสไม่ควรใช้อินเทอร์เฟซเว้นแต่ว่าคลาสนั้นสามารถใช้ได้เมื่อต้องการการใช้อินเทอร์เฟซ กล่าวอีกนัยหนึ่งฉันชอบที่จะเห็นรหัสเช่นนี้: interface IFooWorker { void Work(); } abstract class BaseWorker { ... base class behaviors ... public abstract void Work() { } protected string CleanData(string data) { ... } } class DbWorker : BaseWorker, IFooWorker { public void Work() { Repository.AddCleanData(base.CleanData(UI.GetDirtyData())); } } DbWorker คือสิ่งที่ได้รับอินเตอร์เฟส IFooWorker เนื่องจากเป็นการใช้งานอินเทอร์เฟซที่รวดเร็ว สมบูรณ์ตามสัญญา …

30 design-patterns  object-oriented  object-oriented-design  interfaces