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

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

10 design-patterns  object-oriented-design  database-design  data-structures 

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

10 python  object-oriented-design  exceptions 

ดังนั้นฉันเพิ่งทำ refactorings สำคัญบางอย่างกับรหัสของฉัน หนึ่งในสิ่งสำคัญที่ฉันพยายามทำคือแยกชั้นเรียนออกเป็นวัตถุข้อมูลและวัตถุผู้ปฏิบัติงาน สิ่งนี้ได้รับแรงบันดาลใจเหนือสิ่งอื่นใดตามมาตราของClean Code นี้ : ผสมผสาน ความสับสนนี้บางครั้งนำไปสู่โครงสร้างข้อมูลแบบไฮบริดที่โชคร้ายนั่นคือวัตถุครึ่งหนึ่งและโครงสร้างข้อมูลครึ่งหนึ่ง พวกเขามีฟังก์ชั่นที่ทำสิ่งที่สำคัญและพวกเขายังมีตัวแปรสาธารณะหรือสาธารณะ accessors และ mutators ที่สำหรับทุก intents และวัตถุประสงค์ทำให้ตัวแปรส่วนตัวสาธารณะสาธารณะดึงดูดฟังก์ชั่นภายนอกอื่น ๆ ที่จะใช้ตัวแปรเหล่านั้นวิธีที่โปรแกรมขั้นตอนจะใช้ โครงสร้างข้อมูล. ลูกผสมดังกล่าวทำให้ยากที่จะเพิ่มฟังก์ชั่นใหม่ แต่ก็ทำให้มันยากที่จะเพิ่มโครงสร้างข้อมูลใหม่ พวกเขาเลวร้ายที่สุดของทั้งสองโลก หลีกเลี่ยงการสร้างพวกเขา พวกเขาบ่งบอกถึงการออกแบบที่ยุ่งเหยิงซึ่งผู้เขียนไม่แน่ใจหรือแย่กว่านั้นไม่รู้ว่าพวกเขาต้องการการปกป้องจากฟังก์ชั่นหรือประเภทใด เมื่อเร็ว ๆ นี้ฉันกำลังดูรหัสไปยังหนึ่งในวัตถุงานของฉัน (ที่เกิดขึ้นกับรูปแบบผู้เข้าชม ) และเห็นสิ่งนี้: @Override public void visit(MarketTrade trade) { this.data.handleTrade(trade); updateRun(trade); } private void updateRun(MarketTrade newTrade) { if(this.data.getLastAggressor() != newTrade.getAggressor()) { this.data.setRunLength(0); …

10 java  object-oriented-design  data-structures  clean-code  code-smell 

ฉันอ่านClean Codeและบทความออนไลน์มากมายเกี่ยวกับ SOLID เมื่อเร็ว ๆ นี้และยิ่งฉันอ่านมากเท่าไหร่ฉันก็ยิ่งรู้สึกว่าไม่รู้อะไรเลย สมมติว่าผมสร้างโปรแกรมประยุกต์บนเว็บโดยใช้ ASP.NET MVC 3. สมมติว่าผมมีUsersControllerกับCreateการกระทำเช่นนี้ public class UsersController : Controller { public ActionResult Create(CreateUserViewModel viewModel) { } } ในวิธีการกระทำนั้นฉันต้องการบันทึกผู้ใช้ไปยังฐานข้อมูลหากข้อมูลที่ป้อนนั้นถูกต้อง ตอนนี้ตามหลักการความรับผิดชอบเดี่ยววัตถุควรมีความรับผิดชอบเดียวและความรับผิดชอบนั้นควรถูกห่อหุ้มทั้งหมดโดยชั้นเรียน บริการทั้งหมดของ บริษัท ควรสอดคล้องกับความรับผิดชอบนั้น เนื่องจากการตรวจสอบความถูกต้องและการบันทึกลงในฐานข้อมูลเป็นความรับผิดชอบที่แยกกันสองอย่างฉันจึงควรสร้างคลาสแยกต่างหากเพื่อจัดการกับสิ่งเหล่านี้: public class UsersController : Controller { private ICreateUserValidator validator; private IUserService service; public UsersController(ICreateUserValidator validator, IUserService service) { this.validator = …

10 object-oriented-design  solid  single-responsibility 

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

10 functional-programming  object-oriented-design 

ฉันมีชั้นเรียนที่คำนวณรายได้สุทธิต่อปีของคนงาน มันมีค่าคงที่คิดเป็นร้อยละภาษี แต่วันหนึ่งอัตราภาษีมีการเปลี่ยนแปลงดังนั้นฉันต้องแก้ไขรหัส การกระทำของการแก้ไขค่าคงที่นี้บ่งบอกถึงการละเมิดหลักการ Open-Closedเนื่องจากมันเป็นหลักว่าชั้นควรจะปิดเพื่อแก้ไข?

10 object-oriented  object-oriented-design  solid 

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

10 design-patterns  object-oriented-design 

(ฉันเคยเห็นคำถามนี้แต่คำตอบแรกเป็นเรื่องเกี่ยวกับคุณสมบัติอัตโนมัติมากกว่าเกี่ยวกับการออกแบบและคำตอบที่สองบอกว่าซ่อนรหัสการจัดเก็บข้อมูลจากผู้บริโภคซึ่งฉันไม่แน่ใจว่าเป็นสิ่งที่ฉันต้องการ / รหัสของฉันทำ ดังนั้นฉันต้องการฟังความเห็นอื่น ๆ ) ฉันมีเอนทิตีที่คล้ายกันมากสองรายการHolidayDiscountและRentalDiscountนั่นคือส่วนลดที่มีความยาวเนื่องจาก 'ถ้าอย่างน้อยที่สุดจะnumberOfDaysใช้percentส่วนลดได้' ตารางมี fks ไปยังเอนทิตีพาเรนต์ที่แตกต่างกันและใช้ในสถานที่ต่าง ๆ แต่ที่ที่ใช้จะมีตรรกะทั่วไปเพื่อรับส่วนลดสูงสุดที่เกี่ยวข้อง ตัวอย่างเช่น a HolidayOfferมีจำนวนHolidayDiscountsและเมื่อคำนวณต้นทุนเราต้องหาส่วนลดที่เกี่ยวข้อง RentalDiscountsเหมือนกันสำหรับเช่าและ เนื่องจากตรรกะเหมือนกันฉันต้องการเก็บไว้ในที่เดียว นั่นคือสิ่งที่วิธีต่อไปนี้เพรดิเคตและตัวเปรียบเทียบทำ: Optional<LengthDiscount> getMaxApplicableLengthDiscount(List<LengthDiscount> discounts, int daysToStay) { if (discounts.isEmpty()) { return Optional.empty(); } return discounts.stream() .filter(new DiscountIsApplicablePredicate(daysToStay)) .max(new DiscountMinDaysComparator()); } public class DiscountIsApplicablePredicate implements Predicate<LengthDiscount> { private final long daysToStay; public DiscountIsApplicablePredicate(long …

10 java  object-oriented  object-oriented-design  code-quality 

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

9 object-oriented-design  class-design  abstraction  code-reuse  dry 

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

9 design-patterns  object-oriented-design  domain-driven-design  enterprise-architecture 

ฉันอ่านคำตอบนี้: https://softwareengineering.stackexchange.com/a/234254/173318โปรดแก้ไขความเข้าใจของฉัน กฎธุรกิจหมายถึงรายการขั้นตอนของธุรกิจในโลกแห่งความเป็นจริง (ไม่มีรหัส) ตรรกะทางธุรกิจหมายถึงกระบวนการในการแปลงกฎเกณฑ์ทางธุรกิจเป็นรหัสและรหัส / ประเภทของรหัสที่ระบุว่าเป็น "ตรรกะทางธุรกิจ" และชั้นบริการใช้ทำอะไร ถ้าฉันอ่านคำตอบนี้ฟังดูไม่ต่างกับตรรกะทางธุรกิจhttps://stackoverflow.com/a/4817935/4190539 ชั้นบริการเป็นที่สำหรับตรรกะทางธุรกิจและที่เก็บซึ่งกันและกันหรือไม่?

9 design-patterns  object-oriented-design  business-logic 

ฉันสงสัยว่ามันคืออะไรที่ทำให้ Iterator เป็นพิเศษเมื่อเทียบกับสิ่งก่อสร้างที่คล้ายกันอื่น ๆ และทำให้Gang of Fourแสดงว่าเป็นรูปแบบการออกแบบ Iterator ขึ้นอยู่กับความแตกต่าง (ลำดับชั้นของคอลเลกชันที่มีอินเตอร์เฟซทั่วไป) และการแยกข้อกังวล (การวนซ้ำในการรวบรวมควรเป็นอิสระจากวิธีการจัดโครงสร้างข้อมูล) แต่จะเกิดอะไรขึ้นถ้าเราแทนที่ลำดับชั้นของคอลเลกชันด้วยเช่นลำดับชั้นของวัตถุทางคณิตศาสตร์ (จำนวนเต็ม, ลอย, ซับซ้อน, เมทริกซ์ ฯลฯ ) และตัววนซ้ำโดยคลาสที่แสดงถึงการดำเนินการบางอย่างที่เกี่ยวข้องกับวัตถุเหล่านี้ แผนภาพคลาสจะเหมือนกัน เราอาจพบตัวอย่างที่คล้ายกันอื่น ๆ อีกมากมายเช่น Writer, Painter, Encoder และคนที่ดีกว่าซึ่งทำงานในลักษณะเดียวกัน อย่างไรก็ตามฉันไม่เคยได้ยินชื่อเหล่านี้เรียกว่ารูปแบบการออกแบบ แล้วอะไรที่ทำให้ Iterator มีความพิเศษ? ความจริงที่ว่ามันซับซ้อนกว่าเพราะต้องมีสถานะที่ไม่แน่นอนในการจัดเก็บตำแหน่งปัจจุบันภายในคอลเลกชันหรือไม่? แต่แล้วรัฐที่ไม่แน่นอนมักจะไม่ได้รับการพิจารณาว่าเป็นที่น่าพอใจ เพื่อชี้แจงประเด็นของฉันให้ฉันยกตัวอย่างรายละเอียดเพิ่มเติม นี่คือปัญหาการออกแบบของเรา: สมมติว่าเรามีลำดับชั้นของชั้นเรียนและการดำเนินการที่กำหนดไว้ในวัตถุของชั้นเรียนเหล่านี้ อินเทอร์เฟซของการดำเนินการนี้จะเหมือนกันสำหรับแต่ละคลาส แต่การใช้งานอาจแตกต่างกันโดยสิ้นเชิง นอกจากนี้ยังสันนิษฐานว่ามันสมเหตุสมผลที่จะใช้การดำเนินการหลายครั้งบนวัตถุเดียวกันพูดด้วยพารามิเตอร์ที่แตกต่างกัน นี่คือทางออกที่สมเหตุสมผลสำหรับปัญหาการออกแบบของเรา (ในทางปฏิบัติทั่วไปของรูปแบบตัววนซ้ำ): สำหรับการแยกความกังวลการใช้งานของการดำเนินการไม่ควรเพิ่มเป็นฟังก์ชั่นไปยังลำดับชั้นของระดับเดิม (วัตถุตัวถูกดำเนินการ) เนื่องจากเราต้องการที่จะใช้การดำเนินการหลายครั้งในตัวถูกดำเนินการเดียวกันมันควรจะเป็นตัวแทนของวัตถุที่มีการอ้างอิงถึงตัวถูกดำเนินการไม่เพียงแค่ฟังก์ชั่น ดังนั้นวัตถุตัวถูกดำเนินการควรให้ฟังก์ชั่นที่ส่งกลับวัตถุที่เป็นตัวแทนของการดำเนินการ วัตถุนี้มีฟังก์ชั่นที่ดำเนินการตามจริง ตัวอย่าง: มีชั้นฐานหรืออินเตอร์เฟซที่เป็นMathObject(ชื่อโง่ฉันรู้ว่าอาจจะมีคนที่มีความคิดที่ดี.) กับการเรียนมาและMyInteger …

9 design-patterns  object-oriented-design  iterator 

หลังจากอ่านและค้นคว้า DDD มาหนึ่งเดือนฉันตัดสินใจเริ่มโครงการของตัวเองและสร้าง DDD ด้วยบริบทที่ล้อมรอบเหล่านี้> ลูกค้า ผลิตภัณฑ์ สั่งซื้อ การเรียกเก็บเงิน แต่ละบริบทที่ถูกล้อมรอบมี API ส่วนที่เหลือเป็นเลเยอร์การนำเสนอเลเยอร์โดเมนชั้นถาวร จนถึงตอนนี้โค้ดก็ทำงานได้อย่างราบรื่น แต่มาจากโลกใบใหญ่ที่ฉันยังคงพยายามหาข้อมูลต่อไปนี้: เมื่อฉันต้องการสร้างลูกค้าใหม่ออกใบแจ้งหนี้ใหม่สร้างคำสั่งซื้อใหม่ที่ฉันต้องการตัวอย่างเช่นรายการการเข้าถึงของประเทศ ฉัน: ก) สร้างรายชื่อประเทศในแต่ละปีก่อนคริสต์ศักราช b) สร้างประเทศ BC -> API และใช้เพื่อรับรายชื่อประเทศที่มี c) ใช้ API ของบุคคลที่สามและดึงข้อมูลผ่านเลเยอร์ anticoruption ในแต่ละ BC เมื่อรวมเข้ากับ API ของบุคคลที่สามโดยใช้เลเยอร์ต่อต้านการคอร์รัปชั่นหรือเลเยอร์อะแดปเตอร์จะต้องมีข้อมูลใดบ้างในโมเดลโดเมนของฉัน ตัวอย่างเช่นถ้าฉันต้องการรวม zendesk API กับ Client BC ฉันต้องการเพียง ticketID ในโดเมนของฉันหรือฉันต้องดึงข้อมูลทั้งหมดจาก Zendesk ที่ฉันต้องการเข้าถึงและใช้งานใน Client BC หรือไม่ หากแอป MVC …

9 design-patterns  object-oriented-design  domain-driven-design 

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

9 object-oriented-design 

เราทำการทดสอบหน่วยและการปรับโครงสร้างวัตถุทางธุรกิจของเราอีกมากมายและดูเหมือนว่าฉันมีความคิดเห็นที่แตกต่างกันมากในการออกแบบชั้นเรียนมากกว่าเพื่อนคนอื่น ๆ ตัวอย่างคลาสที่ฉันไม่ใช่แฟนของ: public class Foo { private string field1; private string field2; private string field3; private string field4; private string field5; public Foo() { } public Foo(string in1, string in2) { field1 = in1; field2 = in2; } public Foo(string in1, string in2, string in3, string in4) { field1 …

9 c#  object-oriented-design  class-design  class