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

พื้นหลัง ฉันพัฒนาเกมเป็นงานอดิเรกและกำลังมองหาวิธีที่ดีกว่าในการออกแบบพวกเขา ปัจจุบันฉันใช้วิธีมาตรฐาน OOP (ฉันได้ทำการพัฒนาองค์กรเป็นเวลา 8 ปีแล้ว ยกตัวอย่างเช่น "baddie" public class Baddie:AnimatedSprite //(or StaticSprite if needed, which inherit Sprite) { //sprite base will have things like what texture to use, //what the current position is, the base Update/Draw/GetInput methods, etc.. //an AnimatedSprite contains helpers to animated the player while //a …

11 design-patterns  game-development 

มีคำถามที่เป็นประโยชน์อยู่แล้วในบรรทัดเหล่านี้ (" รูปแบบการออกแบบที่ไม่ใช่ OOP? ") แต่ฉันอยากรู้มากขึ้นเกี่ยวกับมุมมองการเปลี่ยนผ่านสำหรับใครบางคนที่เพิ่งเริ่มต้นด้วยภาษาแบบไดนามิกและพิมพ์อ่อนแอ นั่นคือ: สมมติว่าฉันได้รับการเขียนโปรแกรมใน C ++, C # หรือ Java เป็นเวลาหลายปีและดูดซึมจำนวนมากของภูมิปัญญาตามสายของรูปแบบการออกแบบ GoF ฟาวเลอร์ของรูปแบบของ Enterprise Application สถาปัตยกรรม , หลักการมูลฝอยฯลฯ ตอนนี้ฉัน' การเล่นน้ำใน Ruby, Python, JavaScript และอื่น ๆ และสงสัยว่าความรู้ของฉันใช้อย่างไร สันนิษฐานว่าฉันสามารถทำการแปลโดยตรงในหลายกรณี แต่เกือบจะแน่นอนว่าจะไม่ได้รับประโยชน์เต็มที่จากการตั้งค่าใหม่ของฉัน การพิมพ์แบบเป็ดเพียงอย่างเดียวทำให้ความคิดแบบอินเทอร์เฟซบนหัวของฉันเยอะ อะไรที่ยังคงเหมือนเดิม? การเปลี่ยนแปลงอะไร มีหลักการชี้แนะเช่น SOLID หรือรูปแบบที่เป็นที่ยอมรับ (อาจเป็นเรื่องใหม่ทั้งหมด) ที่มือใหม่ควรรู้หรือไม่?

11 design-patterns  object-oriented  dynamic-typing  solid  weak-typing 

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

11 java  design-patterns  interfaces  strategy 

ข้อดีและข้อเสียของการมีวิธีสร้างวัตถุแบบสแตติกเหนือตัวสร้างคืออะไร class Foo { private Foo(object arg) { } public static Foo Create(object arg) { if (!ValidateParam(arg)) { return null; } return new Foo(arg); } } ไม่กี่คนที่ฉันสามารถคิด: ข้อดี: ส่งคืน null แทนการโยนข้อยกเว้น (ตั้งชื่อTryCreate) สิ่งนี้สามารถทำให้รหัสสั้นลงและสะอาดยิ่งขึ้นในฝั่งไคลเอ็นต์ ลูกค้าไม่ค่อยคาดหวังว่านวกรรมิกจะล้มเหลว สร้างวัตถุประเภทต่าง ๆ ด้วยความหมายที่ชัดเจนเช่นCreatFromName(String name)และCreateFromCsvLine(String csvLine) สามารถส่งคืนวัตถุแคชหากจำเป็นหรือการใช้งานที่ได้รับมา จุดด้อย: ค้นพบน้อยลงและยากต่อการอ่านโค้ด รูปแบบบางอย่างเช่นการจัดลำดับหรือการสะท้อนนั้นยากกว่า (เช่นActivator<Foo>.CreateInstance())

11 design-patterns 

เรามีการพึ่งพาบริการของบุคคลที่สามซึ่งแสดงถึงอินเทอร์เฟซขนาดมหึมาซึ่งเราต้องการเพียง 3 วิธีเท่านั้น นอกจากนี้อินเทอร์เฟซเปลี่ยนบ่อย ... ฉันตัดสินใจที่จะรวมส่วนต่อประสานในชั้นเรียนในโครงการของเราและเปิดเผยวิธีการที่เราต้องการเท่านั้น แต่ผมไม่แน่ใจว่าผมควรจะจัดการกับค่าส่งกลับ ... Storageอินเตอร์เฟซที่ส่งกลับวัตถุของการพิมพ์ เราภายในมีชนิดซึ่งเป็นตัวแทนของเราภายในของStorageModelStorage สิ่งที่คุณจะกลับมาใน mapper นี้StorageหรือStorageModel? เรามี DataService StorageServiceซึ่งได้รับการพึ่งพาของ wrapper injected ขณะนี้ฉันกำลังทำมันโดยทั่วไปดังนี้: public class StorageService { private readonly IExternalStorageWrapper externalStorageWrapper; public StorageService(IExternalStorageWrapper externalStorageWrapper) { this.externalStorageWrapper = externalStorageWrapper; } public StorageModel GetStorage(int storageId) { return this.externalStorageWrapper.GetStorage(storageId).ConvertToStorageModel(); } } public class ExternalStorageWrapper : IExternalStorageWrapper { …

11 c#  design-patterns  programming-practices  code-reviews  wrapper 

สถานการณ์: สแต็ค: Java, Spring, Hibernate รุ่น: แอปพลิเคชันไคลเอนต์ - เซิร์ฟเวอร์ รูปแบบ: Model-View-Controller (MVC) คลาส Service Layer มีพฤติกรรมสามอย่าง: บริการบางอย่างมีกฎเกณฑ์ทางธุรกิจภายในวิธีการและมอบสิทธิ์ให้กับแอปพลิเคชัน ชอบ: EntityManager.save (นิติบุคคล); บริการบางอย่างเรียกฟังก์ชันฐานข้อมูล (ผ่านพารามิเตอร์) ไลค์: CallableStatement cls = con.prepareCall ("{เรียก databaseFunction (args)}"); บริการบางอย่างมีวิธีการที่มีทั้งพฤติกรรม คำถามของฉัน: มีปัญหาในการรับสายบริการโดยตรงหรือไม่ - ฟังก์ชั่นฐานข้อมูล? นี่ถือว่าเป็นการกระทำที่ไม่ดีหรือไม่? แบบจำลองสถาปัตยกรรมจะใช้กับโครงการเช่นนี้ได้อย่างไร มีปัญหาใดบ้างหรือไม่ที่มีการผสมผสานพฤติกรรมในบริการเดียวกัน เช่นการทำธุรกรรมและความสอดคล้อง? ในกรณีของการบำรุงรักษาการห่อหุ้มนี้ทำให้ผู้พัฒนาไม่ชัดเจนว่าเขาควรเปลี่ยนฟังก์ชั่นในฐานข้อมูลหรือไม่? จะหลีกเลี่ยงสิ่งนี้ได้อย่างไร สถานการณ์นี้เกิดขึ้นในแอปพลิเคชันอื่น ๆ ทั่วโลกหรือเป็นเพียงข้อผิดพลาดทางสถาปัตยกรรมหรือไม่?

11 design-patterns  architecture  mvc  code-quality 

ฉันได้เรียน: Aว่าเป็นคอมโพสิตของจำนวนของชั้นเรียนขนาดเล็กB, และCD B, CและDใช้อินเตอร์เฟซIB, ICและIDตามลำดับ ตั้งแต่AรองรับทุกการทำงานของB, CและD, AการดำเนินการIB, ICและIDเช่นกัน แต่นี้โชคไม่ดีที่นำไปสู่การเป็นจำนวนมากเส้นทางใหม่ในการดำเนินการA ชอบมาก interface IB { int Foo {get;} } public class B : IB { public int Foo {get {return 5;}} } interface IC { void Bar(); } public class C : IC { public void Bar() { } } …

11 c#  design-patterns  patterns-and-practices  composition 

เมื่อวางแผนสถาปัตยกรรมสำหรับเว็บแอ็พพลิเคชัน MVC ขนาดกลางขนาดใหญ่คุณจะใช้เลเยอร์ให้เป็นแบบแยกย่อยได้มากที่สุดและง่ายต่อการทดสอบอย่างไร (โดยทั่วไปปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด) สมมติว่าฉันใช้รหัสก่อนเพื่อเข้าถึงข้อมูลของฉัน ฉันต่อสู้กับสิ่งที่จะกำหนด "ตรรกะทางธุรกิจ" เป็นและวิธีที่มันหมายถึงการโต้ตอบกับชั้นข้อมูล ยกตัวอย่างเช่นแอปพลิเคชันการขายยานพาหนะตรรกะทางธุรกิจจะเป็นคลาสที่ทำงานเช่นการคำนวณวงภาษีสำหรับยานพาหนะที่กำหนดเปรียบเทียบสถิติไมล์ต่อแกลลอน ฯลฯ หรือไม่ สำหรับองค์กรธุรกิจ (เช่นรถยนต์รถตู้รถจักรยานยนต์) ฉันจะใส่สิ่งเหล่านี้ในชั้นข้อมูลพร้อมกับDataContextชั้นเรียนของฉัน นอกจากนี้สิ่งที่จะเป็นตรรกะของแอปพลิเคชันซึ่งตรงข้ามกับธุรกิจ - ฉันคาดเดาสิ่งต่าง ๆ เช่นการตรวจสอบการป้อนข้อมูลเซสชัน / ผู้ใช้? ตัวอย่างเช่นตัวควบคุมรถอาจส่งคืนผลลัพธ์การกระทำ / มุมมองที่แสดงรายการรถยนต์สิบอันดับแรกที่กรองตามประเภทและ mpg ที่ดีที่สุด ดังนั้นสมมติว่าฉันมีICarRepository'carRepo' ฉีดเข้าไปในคอนโทรลเลอร์ของฉัน (โดยใช้รูปแบบพื้นที่เก็บข้อมูล / DI) ฉันกรองรถยนต์ของฉันจากพารามิเตอร์วิธีการกระทำเช่นvar cars = carRepo.getCarsByType("hatchback"); ดังนั้นฉันจึงเก็บความรู้การเข้าถึงข้อมูลออกจากตัวควบคุมของฉันโดยใช้ที่เก็บตอนนี้เพื่อให้ตรรกะทางธุรกิจออกจากตัวควบคุมโดยใช้รูปแบบโดเมน - var result = new MpgCalculator (cars); - สมมติว่าฉันต้องการคลาสเครื่องคิดเลขเพราะมันต้องใช้ตรรกะเพิ่มเติมเพื่อคำนวณประสิทธิภาพการใช้เชื้อเพลิงที่ดีที่สุดมากกว่าแค่การโหลด / กรองเอนทิตีจาก DB ดังนั้นตอนนี้ฉันมีชุดข้อมูลสำหรับมุมมองของฉันในการเรนเดอร์ที่ใช้ที่เก็บเพื่อดึงข้อมูลจากเลเยอร์การเข้าถึงข้อมูลและวัตถุเฉพาะโดเมนเพื่อประมวลผลและดำเนินงานที่เกี่ยวข้องกับธุรกิจในข้อมูลนั้น ฉันทำผิดพลาดที่นี่ …

11 design-patterns  mvc  asp.net-mvc  repository  n-tier 

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

11 design  design-patterns  object-oriented  refactoring  single-responsibility 

ช่วยบอกว่าฉันมีแอพเวอร์ชันฟรีและจ่ายเงิน รุ่นที่ต้องชำระเงินเป็นชุดของรุ่นฟรีที่เกี่ยวกับคุณสมบัติที่ผู้ใช้มีความหมายว่ารุ่นที่จ่ายจะมีคุณสมบัติทั้งหมดของแอปฟรีพร้อมกับพิเศษ มีรูปแบบการสลับความพร้อมใช้งานของคุณสมบัติตามธงที่โหลดเมื่อเริ่มต้น (เช่นฟรี / จ่ายเงิน) หรือไม่ ฉันไม่ชอบความคิดที่มีการติดตามรหัสในทุกที่: if(isFreeVersion){ // ... } else { // ... } มี 2 สาขาคอมไพล์แยกต่างหากสำหรับทุกรุ่นไม่ได้ตัวเลือกเพราะมันจะหมายถึงการบำรุงรักษาที่ 2 (หรือมากกว่า) แหล่งที่มาของรหัสที่ดูเหมือนว่าทำไม่ได้ทั่วไปและมีการกล่าวถึงเพิ่มเติมได้ที่นี่: การดูแลรักษาทั้งสองรุ่นซอฟท์แวเฉพาะกิจจากที่เดียวกัน Codebase ในการควบคุมเวอร์ชัน มีวิธีการทำเช่นนี้ในขณะที่ยังคงมีฐานรหัสเดียวและไม่ทิ้งรหัสด้วยคำสั่งแบบมีเงื่อนไขที่ตรวจสอบการตั้งค่าสถานะฟรี / ชำระเงิน ฉันแน่ใจว่ามีการพูดคุยกันหลายครั้งก่อนหน้านี้และฉันแน่ใจว่ามีรูปแบบบางอย่างในการเข้าถึงปัญหานี้ แต่ฉันไม่พบมัน เราใช้ Android / Java

11 design  design-patterns  programming-practices 

ประการแรกฉันรู้ว่าคำถามนี้เชื่อมโยงกับหัวข้อของการพัฒนาเกม แต่ฉันได้ตัดสินใจที่จะถามที่นี่เพราะมันมีปัญหาทั่วไปเกี่ยวกับซอฟต์แวร์ที่ทำให้เกิดปัญหา ในช่วงเดือนที่ผ่านมาฉันได้อ่านมากมายเกี่ยวกับ Entity-Component-Systems และตอนนี้ค่อนข้างสะดวกสบายกับแนวคิด อย่างไรก็ตามมีแง่มุมหนึ่งที่ดูเหมือนจะหายไป 'นิยาม' ที่ชัดเจนและบทความต่าง ๆ ได้เสนอวิธีแก้ไขปัญหาที่แตกต่างกันอย่างสิ้นเชิง: นี่เป็นคำถามว่า ECS ควรทำลายการห่อหุ้มหรือไม่ กล่าวอีกนัยหนึ่งคือสไตล์ OOP ECS (ส่วนประกอบเป็นวัตถุที่มีทั้งสถานะและ behaivour ที่ห่อหุ้มข้อมูลที่เฉพาะเจาะจงกับพวกเขา) เทียบกับECS บริสุทธิ์ (ส่วนประกอบคือโครงสร้างสไตล์ c ที่มีข้อมูลสาธารณะและระบบที่มีฟังก์ชันการทำงานเท่านั้น) โปรดทราบว่าฉันกำลังพัฒนา Framework / API / Engine ใหม่ ดังนั้นเป้าหมายคือสามารถขยายได้อย่างง่ายดายโดยใครก็ตามที่ใช้งาน ซึ่งรวมถึงสิ่งต่าง ๆ เช่นการเพิ่มประเภทการแสดงผลหรือองค์ประกอบการชน ปัญหาเกี่ยวกับวิธีการ OOP ส่วนประกอบต้องเข้าถึงข้อมูลของส่วนประกอบอื่น ๆ เช่นวิธีการดึงขององค์ประกอบการแสดงผลจะต้องเข้าถึงตำแหน่งขององค์ประกอบการแปลง สิ่งนี้สร้างการพึ่งพาในโค้ด ส่วนประกอบต่างๆสามารถเป็นแบบโพลีมอร์ฟิคซึ่งจะนำเสนอความซับซ้อนเพิ่มเติม เช่นอาจมีสไปรต์การเรนเดอร์องค์ประกอบที่แทนที่เมธอดการวาดเสมือนของคอมโพเนนต์การเรนเดอร์ ปัญหาเกี่ยวกับวิธีการที่บริสุทธิ์ เนื่องจาก behaivour polymorphic (เช่นสำหรับการเรนเดอร์) ต้องถูกนำไปใช้ที่ไหนสักแห่งจึงเป็นเพียงการเอาต์ซอร์ซเข้าสู่ระบบ (เช่นระบบเรนเดอร์เรนเดอร์สร้างโหนดเรนเดอร์เรนเดอร์ที่สืบทอดโหนดเรนเดอร์และเพิ่มไปยังเอ็นจิ้นการเรนเดอร์) …

11 design-patterns  object-oriented  game-development  entity-component-system 

ฉันกำลังทำงานเป็นนักพัฒนาเดี่ยวในโครงการปัจจุบันของฉัน ฉันสืบทอดโครงการจากผู้พัฒนารายอื่นซึ่งออกจาก บริษัท ไปแล้ว มันเป็นเว็บแอพพลิเคชั่นรูปแบบมุมมอง - คอนโทรลเลอร์ใน C # มันใช้ Entity Framework สำหรับการทำแผนที่วัตถุสัมพันธ์ และมีคลาสที่แตกต่างกันสองชุดสำหรับประเภทในรูปแบบโดเมน ชุดหนึ่งใช้สำหรับการโต้ตอบกับ ORM และอีกชุดหนึ่งใช้เป็นแบบจำลองในระบบ MVC ตัวอย่างเช่นอาจมีสองคลาสดังนี้: public class Order{ int ID{get;set;} String Customer{get;set;} DateTime DeliveryDate{get;set;} String Description{get;set;} } และ public class OrderModel{ String Customer{get;set;} DateTime DeliveryDate{get;set;} String Description{get;set;} public OrderModel( Order from){ this.Customer= from.Customer; // copy all …

11 design-patterns  database  object-oriented-design 

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

11 design-patterns  object-oriented-design 

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

10 java  design-patterns  dependency-injection 

ฉันกำลังอ่าน Coders at Work และ Brendan Eich อ้างอิงบทความจาก Norvig ตั้งแต่ตอนที่เขาอยู่ที่ Harlequin ว่า "รูปแบบการออกแบบเป็นเพียงแค่ข้อบกพร่องในภาษาการเขียนโปรแกรมของคุณ" ทุกคนสามารถให้ลิงก์ไปยังบทความนี้ได้หรือไม่

10 design-patterns  articles