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

บทเรียนจำนวนมากเกี่ยวกับ DDD ที่ฉันศึกษาส่วนใหญ่จะครอบคลุมทฤษฎี พวกเขาทั้งหมดมีตัวอย่างรหัสพื้นฐาน (Pluralsight และคล้ายคลึงกัน) บางคนพยายามสร้างบทเรียนที่ครอบคลุม DDD ด้วย EF บนเว็บ หากคุณเริ่มศึกษาพวกเขาเพียงชั่วครู่ - คุณสังเกตได้อย่างรวดเร็วว่าพวกเขาแตกต่างกันมาก บางคนแนะนำให้แอพพลิเคชั่นมีน้อยที่สุดและเพื่อหลีกเลี่ยงการแนะนำเลเยอร์เพิ่มเติมเช่นที่เก็บข้อมูลด้านบนของ EFคนอื่น ๆ กำลังสร้างเลเยอร์เพิ่มเติมอย่างแน่นอนซึ่งมักจะละเมิด SRP ด้วยการฉีดDbContextเข้าไปใน Aggregate Roots ฉันขอโทษอย่างมากถ้าฉันถามคำถามตามความคิดเห็น แต่ ... เมื่อมาถึงการปฏิบัติ - Entity Framework เป็นหนึ่งใน ORMs ที่ทรงพลังและใช้กันอย่างแพร่หลาย คุณจะไม่พบหลักสูตรที่ครอบคลุมที่ครอบคลุม DDD ด้วยโชคไม่ดี ประเด็นสำคัญ: Entity Framework นำ UoW & Repository ( DbSet) ออกจากกล่อง รุ่นของคุณกับ EF มีคุณสมบัติการนำทาง กับ EF …

12 c#  design-patterns  object-oriented-design  domain-driven-design  entity-framework 

รับคลาส Python ซึ่งจะถูกสร้างอินสแตนซ์เพียงครั้งเดียวคือจะมีเพียงวัตถุเดียวของคลาส ฉันสงสัยในกรณีที่เหมาะสมที่จะสร้างอินสแตนซ์ของคลาสเดียวแทนที่จะทำงานโดยตรงกับคลาสแทน มีคำถามที่คล้ายกันแต่มีจุดเน้นที่แตกต่าง: มันเกี่ยวกับการจัดกลุ่มตัวแปรส่วนกลางและฟังก์ชันในคลาสและ มันไม่ได้เป็นงูหลามที่เฉพาะเจาะจง หลังหมายถึงมันไม่ได้พิจารณาความจริงที่ว่าคลาส (ใน Python) เป็นวัตถุด้วย UPDATE: ใน Python ฉันสามารถทำสิ่งต่อไปนี้กับทั้งคลาสและวัตถุ: class A(object): pass A.some_state_var = True # Then later A.some_state_var = False my_a = A() my_a.some_state_var = True # Then later my_a.some_state_var = False ดังนั้นฉันไม่เห็นวิธีการเลือกระหว่างคลาสและอินสแตนซ์ของคลาสนั้นเกี่ยวกับสถานะ (ใน Python) ฉันสามารถรักษาสถานะด้วยสองอย่างใดอย่างหนึ่ง นอกจากนี้แรงจูงใจในการสร้างคลาส / คลาสอินสแตนซ์ของฉันไม่ได้เกี่ยวกับการบังคับใช้ข้อกำหนดแบบซิงเกิล นอกจากนี้ยังไม่มากนักเกี่ยวกับการสร้างประเภทใหม่ แรงจูงใจคือการจัดกลุ่มรหัสและข้อมูลที่เกี่ยวข้องและมีส่วนต่อประสานกับมัน นี่คือเหตุผลที่ฉันเริ่มต้นแบบเป็นคลาสในแผนภาพคลาส เมื่อพูดถึงการนำไปใช้ฉันเริ่มสงสัยว่าจะยกตัวอย่างชั้นเรียนนี้หรือไม่

11 design  object-oriented  python  object-oriented-design  class-design 

พิจารณาอินเทอร์เฟซ: interface IWaveGenerator { SoundWave GenerateWave(double frequency, double lengthInSeconds); } อินเทอร์เฟซนี้ถูกใช้งานโดยคลาสที่สร้างคลื่นของรูปร่างที่แตกต่างกัน (ตัวอย่างเช่นSineWaveGeneratorและSquareWaveGenerator) ฉันต้องการใช้คลาสที่สร้างSoundWaveจากข้อมูลดนตรีไม่ใช่ข้อมูลเสียงดิบ มันจะได้รับชื่อของโน้ตและระยะเวลาในแง่ของการเต้น (ไม่กี่วินาที) ที่และภายในใช้IWaveGeneratorฟังก์ชั่นในการสร้างSoundWaveตาม คำถามคือควรNoteGeneratorประกอบด้วยIWaveGeneratorหรือควรได้รับมรดกจากการIWaveGeneratorดำเนินการ? ฉันเอนตัวไปยังองค์ประกอบเนื่องจากเหตุผลสองประการ: 1- มันช่วยให้ฉันสามารถฉีดใด ๆIWaveGeneratorไปยังNoteGeneratorแบบไดนามิก นอกจากนี้ฉันต้องการเพียงหนึ่งNoteGeneratorชั้นแทนSineNoteGenerator, SquareNoteGeneratorฯลฯ 2- มีความต้องการไม่ได้ที่จะเปิดเผยอินเตอร์เฟซในระดับต่ำกว่าที่กำหนดโดยNoteGeneratorIWaveGenerator อย่างไรก็ตามฉันโพสต์คำถามนี้เพื่อฟังความคิดเห็นอื่น ๆ เกี่ยวกับเรื่องนี้อาจเป็นจุดที่ฉันไม่ได้คิด BTW: ฉันจะบอกว่าNoteGenerator เป็นแนวคิดIWaveGeneratorเพราะมันสร้างSoundWaves

11 object-oriented  object-oriented-design  inheritance  composition 

ฉันขอโทษถ้านี่เป็นคำถามที่ซับซ้อนอย่างแน่นอน แต่ฉันอยากรู้ว่าแนวทางปฏิบัติที่ดีที่สุดออกไปที่นั่นและฉันดูเหมือนจะไม่พบคำตอบที่ดีใน Google ใน Python ฉันมักจะใช้คลาสที่ว่างเปล่าเป็นคอนเทนเนอร์โครงสร้างข้อมูล super-catchall (เรียงลำดับเหมือนไฟล์ JSON) และเพิ่มคุณสมบัติไปพร้อมกัน: class DataObj: "Catch-all data object" def __init__(self): pass def processData(inputs): data = DataObj() data.a = 1 data.b = "sym" data.c = [2,5,2,1] สิ่งนี้ทำให้ฉันมีความยืดหยุ่นอย่างมากเนื่องจากอ็อบเจกต์คอนเทนเนอร์สามารถเก็บอะไรก็ได้ ดังนั้นหากความต้องการใหม่เกิดขึ้นฉันจะเพิ่มมันเป็นคุณสมบัติอื่นไปยังวัตถุ DataObj (ซึ่งฉันผ่านไปรอบ ๆ ในรหัสของฉัน) อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันรู้สึกประทับใจ (โดยโปรแกรมเมอร์ FP) ว่านี่เป็นการฝึกฝนที่แย่มากเพราะมันยากที่จะอ่านรหัส หนึ่งจะต้องผ่านรหัสทั้งหมดเพื่อคิดออกว่าคุณลักษณะ DataObj จริงมีอะไร คำถาม : ฉันจะเขียนสิ่งนี้ใหม่เพื่อการบำรุงรักษาที่มากขึ้นได้อย่างไรโดยไม่ลดความยืดหยุ่นลง? …

11 python  programming-practices  functional-programming  object-oriented-design 

ฉันสังเกตเห็นบางอย่างในรหัสของฉันในโครงการต่าง ๆ ที่ดูเหมือนว่ากลิ่นรหัสให้ฉันและสิ่งที่ไม่ดีที่จะทำ แต่ฉันไม่สามารถจัดการกับมัน ในขณะที่พยายามเขียน "รหัสสะอาด" ฉันมักจะใช้วิธีส่วนตัวมากเกินไปเพื่อให้อ่านรหัสได้ง่ายขึ้น ปัญหาคือรหัสนั้นสะอาดกว่า แต่ก็ยากกว่าในการทดสอบ (ใช่ฉันรู้ว่าฉันสามารถทดสอบวิธีการส่วนตัว ... ) และโดยทั่วไปดูเหมือนว่านิสัยที่ไม่ดีสำหรับฉัน นี่คือตัวอย่างของคลาสที่อ่านข้อมูลบางอย่างจากไฟล์. csv และส่งคืนกลุ่มลูกค้า (วัตถุอื่นที่มีเขตข้อมูลและแอตทริบิวต์ต่าง ๆ ) public class GroupOfCustomersImporter { //... Call fields .... public GroupOfCustomersImporter(String filePath) { this.filePath = filePath; customers = new HashSet<Customer>(); createCSVReader(); read(); constructTTRP_Instance(); } private void createCSVReader() { //.... } private void …

11 design-patterns  object-oriented-design  clean-code  encapsulation 

ในช่วงไม่กี่ปีที่ผ่านมาภาษาที่ฉันชอบใช้นั้นเพิ่มมากขึ้น ตอนนี้ฉันใช้ภาษาที่เป็น "ลูกผสม": C #, F #, Scala ฉันชอบที่จะออกแบบแอปพลิเคชันของฉันโดยใช้คลาสที่สอดคล้องกับวัตถุโดเมนและใช้คุณสมบัติการทำงานที่ทำให้การเขียนรหัสง่ายขึ้นตรงและปลอดภัยยิ่งขึ้น (โดยเฉพาะอย่างยิ่งเมื่อทำงานกับคอลเลกชัน อย่างไรก็ตามทั้งสองโลก "ปะทะกัน" เมื่อมาถึงรูปแบบการออกแบบ ตัวอย่างเฉพาะที่ฉันเผชิญเมื่อเร็ว ๆ นี้คือรูปแบบการสังเกตการณ์ ฉันต้องการให้ผู้ผลิตแจ้งรหัสอื่น ๆ ("ผู้บริโภค / ผู้สังเกตการณ์" พูดที่เก็บข้อมูล DB ตัวบันทึกและอื่น ๆ ) เมื่อรายการถูกสร้างหรือเปลี่ยนแปลง ตอนแรกฉันทำมัน "ตามหน้าที่" เช่นนี้: producer.foo(item => { updateItemInDb(item); insertLog(item) }) // calls the function passed as argument as an item is processed แต่ตอนนี้ฉันสงสัยว่าฉันควรใช้วิธีการ "OO" …

11 c#  functional-programming  scala  object-oriented-design  f# 

นี่คือปัญหาที่ฉันพบบ่อย: ให้มีโครงการร้านค้าบนเว็บที่มีระดับสินค้า ฉันต้องการเพิ่มคุณสมบัติที่อนุญาตให้ผู้ใช้โพสต์คำวิจารณ์ไปยังผลิตภัณฑ์ ดังนั้นฉันมีคลาสรีวิวซึ่งอ้างอิงผลิตภัณฑ์ ตอนนี้ฉันต้องการวิธีการที่แสดงความเห็นทั้งหมดในผลิตภัณฑ์ มีความเป็นไปได้สองอย่าง: (A) public class Product { ... public Collection<Review> getReviews() {...} } (B) public class Review { ... static public Collection<Review> forProduct( Product product ) {...} } จากการดูรหัสฉันเลือก (A): มันไม่คงที่และไม่ต้องการพารามิเตอร์ อย่างไรก็ตามฉันรู้สึกว่า (A) ละเมิดหลักการความรับผิดชอบเดี่ยว (SRP) และหลักการเปิด (OCP) ในขณะที่ (B) ไม่: (SRP) เมื่อฉันต้องการเปลี่ยนวิธีการรวบรวมความเห็นสำหรับผลิตภัณฑ์ฉันต้องเปลี่ยนระดับสินค้า แต่ควรมีเหตุผลเพียงประการเดียวว่าทำไมต้องเปลี่ยนระดับผลิตภัณฑ์ และนั่นไม่ใช่ความคิดเห็นอย่างแน่นอน หากฉันบรรจุคุณลักษณะทุกอย่างที่มีบางอย่างเกี่ยวกับผลิตภัณฑ์ไว้ใน Product …

11 object-oriented-design  solid 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันต้องการเพิ่มการบันทึกลงในแอปพลิเคชันที่ฉันกำลังทำงานอยู่ ฉันได้เพิ่มการบันทึกก่อนหน้านี้ไม่ใช่ปัญหาที่นี่ แต่จากมุมมองการออกแบบในภาษาเชิงวัตถุอะไรคือวิธีปฏิบัติที่ดีที่สุดสำหรับการบันทึกที่เป็นไปตาม OOP และรูปแบบ หมายเหตุ:ฉันกำลังทำสิ่งนี้ใน C # ดังนั้นตัวอย่างใน C # ยินดีต้อนรับอย่างชัดเจน ฉันต้องการเห็นตัวอย่างใน Java และ Ruby แก้ไข:ฉันใช้ log4net ฉันไม่รู้ว่าวิธีที่ดีที่สุดในการเสียบคืออะไร

11 object-oriented  logging  object-oriented-design 

นี่คือข้อโต้แย้งบางประการสำหรับคุณสมบัติและข้อโต้แย้งของฉัน: ใช้งานง่ายกว่าการเขียนวิธี getter และ setter คู่ของ Getter และ setter เป็นกลิ่นของโค้ด การทำให้ง่ายต่อการเขียนสิ่งเหล่านี้ก็เหมือนกับการทำให้ล้มเหลวในการทดสอบคณิตศาสตร์โดยใช้แบบฟอร์ม Scantron และเติมใน 'C's ทั้งหมด วัตถุที่มีเพียงสถานะสำหรับการคงอยู่ไม่ควรใช้ getters / setters และควรสร้างวัตถุที่ไม่เปลี่ยนรูปในเวลาที่มีอยู่ สิ่งที่สำคัญสำหรับผู้บริโภคของวัตถุคือสิ่งที่มันทำไม่ได้เป็นอย่างไร พฤติกรรมของมันคือสิ่งที่มันทำ; สถานะของมันเป็นอย่างไร หากคุณพบว่าตัวเองสนใจเกี่ยวกับสถานะของวัตถุ (ยกเว้นการคงอยู่แม้ว่าสิ่งนี้จะทำลาย OO) คุณก็ไม่ได้ทำ OOP และสูญเสียข้อดีของมัน พวกเขาให้ข้อบ่งชี้ประสิทธิภาพอย่างคร่าว ๆ กับผู้บริโภค นี่คือสิ่งที่สามารถเปลี่ยนแปลงได้ในอนาคตสำหรับอสังหาริมทรัพย์ใด ๆ ก็ตาม สมมติว่าในรีลีส 1.0 การเข้าถึง PropertyX จะส่งคืนฟิลด์ ในรีลีส 1.5 หากฟิลด์เป็นโมฆะ PropertyX จะใช้รูปแบบวัตถุ Null เพื่อสร้างวัตถุ null ใหม่ ในรุ่น …

11 c#  object-oriented-design 

ในคำจำกัดความของอลันเคย์ที่เน้นวัตถุมีคำจำกัดความนี้บางส่วนที่ฉันไม่เข้าใจ: OOP สำหรับฉันหมายถึงเพียงการส่งข้อความการเก็บรักษาในท้องถิ่นและการป้องกันและการซ่อนกระบวนการของรัฐและการผูกมัดขั้นสุดท้ายของทุกสิ่ง แต่ "LateBinding" หมายถึงอะไร ฉันจะใช้สิ่งนี้กับภาษาอย่าง C # ได้อย่างไร และทำไมเรื่องนี้สำคัญมาก

11 object-oriented  object-oriented-design 

ฉันกำลังทำงานเป็นนักพัฒนาเดี่ยวในโครงการปัจจุบันของฉัน ฉันสืบทอดโครงการจากผู้พัฒนารายอื่นซึ่งออกจาก บริษัท ไปแล้ว มันเป็นเว็บแอพพลิเคชั่นรูปแบบมุมมอง - คอนโทรลเลอร์ใน 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 

ฉันได้ยินวลีที่ถูกโยนและฉันมีข้อโต้แย้งที่ฟังดูบ้าอย่างสมบูรณ์ (ขออภัยถ้าฉันกำลังทำฟางอยู่ที่นี่ไม่ใช่ความตั้งใจของฉัน) โดยทั่วไปจะมีบางอย่างตาม: คุณไม่ต้องการสร้างสิ่งที่เป็นนามธรรมก่อนที่คุณจะรู้ว่ากรณีทั่วไปคืออะไรมิฉะนั้น (1) คุณอาจวางสิ่งต่าง ๆ ในสิ่งที่เป็นนามธรรมของคุณหรือ (2) ไม่สนใจสิ่งที่มีความสำคัญ (1) สำหรับฉันนี่ดูเหมือนว่าโปรแกรมเมอร์ไม่ได้ใช้งานได้จริงพวกเขาได้ตั้งสมมติฐานว่าสิ่งต่าง ๆ จะมีอยู่ในโปรแกรมสุดท้ายที่ไม่ได้ทำงานดังนั้นพวกเขาจึงทำงานร่วมกับสิ่งที่เป็นนามธรรมในระดับต่ำปัญหาไม่ใช่ สิ่งที่เป็นนามธรรมก่อนวัยอันควร (2) การทิ้งสิ่งที่มีความสำคัญเป็นสิ่งหนึ่งอาจเป็นไปได้อย่างสิ้นเชิงที่บางสิ่งจะถูกตัดออกจากข้อมูลจำเพาะที่ในภายหลังกลายเป็นเรื่องสำคัญทางออกสำหรับสิ่งนี้ไม่ได้เกิดขึ้นกับการตัดสินใจของคุณและทรัพยากรเสียเปล่า เดาผิดก็เพื่อให้ได้ข้อมูลเพิ่มเติมจากลูกค้า เราควรทำงานจากนามธรรมลงไปถึงข้อตกลงเพราะนี่เป็นวิธีที่จริงจังที่สุดในการทำสิ่งต่าง ๆ และไม่ใช่วิธีอื่น ๆ ถ้าเราไม่ทำเช่นนั้นเราก็เสี่ยงต่อการเข้าใจผิดของลูกค้าและการสร้างสิ่งต่าง ๆ ที่จำเป็นต้องเปลี่ยน แต่ถ้าเราสร้างเพียงนามธรรมที่ลูกค้าได้กำหนดไว้ในภาษาของพวกเขาเองเราก็ไม่เคยตกอยู่ในความเสี่ยงนี้ ภาพหนึ่งในที่มืดโดยมีการสรุปบางอย่าง) ใช่เป็นไปได้ที่ลูกค้าจะเปลี่ยนใจเกี่ยวกับรายละเอียด แต่สิ่งที่พวกเขาเคยใช้ในการสื่อสารสิ่งที่พวกเขาต้องการมักจะยังคงใช้ได้ ต่อไปนี้เป็นตัวอย่างสมมติว่าลูกค้าต้องการให้คุณสร้างหุ่นยนต์ที่บรรจุถุง: public abstract class BaggingRobot() { private Collection<Item> items; public abstract void bag(Item item); } เรากำลังสร้างบางสิ่งจากนามธรรมที่ลูกค้าใช้โดยไม่ต้องลงรายละเอียดเพิ่มเติมกับสิ่งที่เราไม่รู้ นี่คือความยืดหยุ่นอย่างยิ่งฉันเห็นสิ่งนี้ถูกเรียกว่า "นามธรรมก่อนวัยอันควร" เมื่อในความเป็นจริงมันจะเร็วกว่าที่จะคิดว่าวิธีการบรรจุถุงถูกนำไปใช้อย่างไรพูดหลังจากพูดคุยกับลูกค้าที่พวกเขาต้องการ . เพื่ออัปเดตชั้นเรียนของฉันทั้งหมดที่ฉันต้องทำคือเปลี่ยนลายเซ็น …

10 design  design-patterns  object-oriented-design  development-process  abstraction 

ฉันได้ปรับการออกแบบที่ขับเคลื่อนด้วยโดเมนมาประมาณ 8 ปีแล้วและแม้กระทั่งหลังจากทุกปีเหล่านี้ก็ยังมีสิ่งหนึ่งที่ทำให้ฉันเบื่อ นั่นคือการตรวจสอบระเบียนที่ไม่ซ้ำกันในการจัดเก็บข้อมูลกับวัตถุโดเมน ในเดือนกันยายน 2013 Martin Fowler ได้กล่าวถึงหลักการ TellDonnaAskซึ่งหากเป็นไปได้ควรนำไปใช้กับวัตถุโดเมนทั้งหมดซึ่งควรจะส่งคืนข้อความว่าการดำเนินการเป็นไปอย่างไร (ในการออกแบบเชิงวัตถุ การดำเนินการไม่สำเร็จ) โครงการของฉันมักจะแบ่งออกเป็นหลายส่วนโดยที่สองในนั้นเป็นโดเมน (ที่มีกฎเกณฑ์ทางธุรกิจและไม่มีสิ่งอื่นใดโดเมนนั้นยังคงอยู่อย่างไม่รู้ตัว) และบริการ บริการที่ทราบเกี่ยวกับเลเยอร์พื้นที่เก็บข้อมูลที่ใช้กับข้อมูล CRUD เนื่องจากความเป็นเอกลักษณ์ของคุณสมบัติที่เป็นของวัตถุคือกฎของโดเมน / ธุรกิจจึงควรจะยาวไปยังโมดูลของโดเมนดังนั้นกฎจึงตรงตามที่ควรจะเป็น เพื่อให้สามารถตรวจสอบเอกลักษณ์ของระเบียนคุณต้องค้นหาชุดข้อมูลปัจจุบันซึ่งมักจะเป็นฐานข้อมูลเพื่อค้นหาไม่ว่าจะมีระเบียนอื่นที่มีการสมมติว่าNameมีอยู่แล้ว เมื่อพิจารณาว่าเลเยอร์ของโดเมนนั้นไม่รู้มานานแล้วและไม่รู้ว่าจะดึงข้อมูลได้อย่างไร แต่จะทำอย่างไรกับการดำเนินการกับมันพวกมันไม่สามารถสัมผัสที่เก็บข้อมูลได้ การออกแบบที่ฉันได้รับการปรับตัวแล้วมีลักษณะเช่นนี้: class ProductRepository { // throws Repository.RecordNotFoundException public Product GetBySKU(string sku); } class ProductCrudService { private ProductRepository pr; public ProductCrudService(ProductRepository repository) { pr = repository; } public …

10 object-oriented-design  domain-driven-design  service  unique-data 

ฉันกำลังเขียนเกมใน typescript และตัดสินใจว่าจะลองทำตามแนวคิดของ " การเขียนโปรแกรมด้วยอินเตอร์เฟส " ซึ่งคุณเขียนโค้ดตามอินเตอร์เฟสแทนการใช้งานของวัตถุ ฉันเขียนอินเทอร์เฟซจำนวนมากและคลาสที่ใช้งานพวกเขาจากนั้นถอยกลับและตระหนักว่าคลาสนั้นง่ายพอที่ฉันจะไม่ต้องเปลี่ยนการใช้งานเนื่องจากมีวิธีเดียวที่จะทำสิ่งที่ คลาสทำ (เคลื่อนที่Phaser.Spriteในลักษณะที่ จำกัด เพื่อทำตัวเหมือนรถถัง) จากนั้นฉันจำได้ว่าได้อ่านเมื่อไม่กี่ปีที่ผ่านมาเกี่ยวกับแนวคิดของYAGNIซึ่งโดยพื้นฐานแล้วคุณไม่ควรสร้างรหัสของคุณมากเกินไปเพื่อรวมสิ่งที่คุณไม่เคยใช้ การปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดทุกคลาสควรใช้อินเทอร์เฟซหรือคุณควร จำกัด เฉพาะคลาสที่คุณคาดว่าจะมีการแลกเปลี่ยนในอนาคต

10 object-oriented-design  interfaces  patterns-and-practices