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

คำถามแบบสั้น มันอยู่ในแนวปฏิบัติที่ดีที่สุดของ DDD และ OOP ในการฉีดบริการกับการเรียกเมธอดเอนทิตีหรือไม่? ตัวอย่างรูปแบบยาว สมมติว่าเรามีกรณี Order-LineItems แบบคลาสสิกใน DDD ที่เรามี Domain Entity ชื่อ Order ซึ่งยังทำหน้าที่เป็น Aggregate Root และ Entity นั้นไม่เพียง แต่ประกอบไปด้วย Value Objects แต่ยังเป็นคอลเลกชันของรายการโฆษณา หน่วยงาน สมมติว่าเราต้องการไวยากรณ์ที่คล่องแคล่วในแอปพลิเคชันของเราเพื่อให้เราสามารถทำสิ่งนี้ (สังเกตไวยากรณ์ในบรรทัดที่ 2 ซึ่งเราเรียกgetLineItemsเมธอด) $order = $orderService->getOrderByID($orderID); foreach($order->getLineItems($orderService) as $lineItem) { ... } เราไม่ต้องการฉีด LineItemRepository ใด ๆ ลงใน OrderEntity เนื่องจากเป็นการละเมิดหลักการหลายอย่างที่ฉันสามารถนึกได้ แต่ความคล่องแคล่วของวากยสัมพันธ์เป็นสิ่งที่เราต้องการจริงๆเพราะมันง่ายต่อการอ่านและบำรุงรักษารวมถึงการทดสอบ พิจารณาโค้ดต่อไปนี้โดยสังเกตวิธีgetLineItemsในOrderEntity: interface …

11 object-oriented  php  domain-driven-design  domain-model  lazy-initialization 

ฉันดู Pycon ของ Raymond Hettinger พูดว่า "Super Considered Super" และเรียนรู้เล็กน้อยเกี่ยวกับ PROON ของ MRO (Method Resolution Order) ซึ่งทำให้ชั้นเรียนเป็น "ผู้ปกครอง" ในลักษณะเชิงเส้น เราสามารถใช้สิ่งนี้เพื่อประโยชน์ของเราเช่นในรหัสด้านล่างเพื่อทำการฉีดพึ่งพา ตอนนี้ตามธรรมชาติฉันต้องการใช้superสำหรับทุกสิ่ง! ในตัวอย่างด้านล่างที่Userระดับประกาศอ้างอิงมันโดยการสืบทอดจากทั้งสองและLoggingService UserServiceนี่ไม่ใช่สิ่งที่พิเศษเป็นพิเศษ ส่วนที่น่าสนใจคือเราสามารถใช้การแก้ไขวิธีสั่งซื้อยังจำลองการอ้างอิงในระหว่างการทดสอบหน่วย โค้ดด้านล่างนี้สร้างสิ่งMockUserServiceที่สืบทอดมาUserServiceและนำเสนอวิธีการที่เราต้องการจำลอง validate_credentialsในตัวอย่างด้านล่างเราให้การดำเนินการของ เพื่อที่จะได้MockUserServiceจัดการกับการโทรใด ๆ ที่validate_credentialsเราจำเป็นต้องวางไว้ก่อนUserServiceใน MRO นี้ทำได้โดยการสร้างชั้นห่อหุ้มรอบUserเรียกว่าMockUserและมีมันสืบทอดมาจากและUserMockUserService ตอนนี้เมื่อเราทำMockUser.authenticateและในทางกลับกันการเรียกใช้มาsuper().validate_credentials() MockUserServiceก่อนUserServiceในการสั่งซื้อวิธีการแก้ปัญหาและเนื่องจากมีการใช้งานที่เป็นรูปธรรมของvalidate_credentialsการดำเนินการนี้จะถูกนำมาใช้ Yay - เราประสบความสำเร็จUserServiceในการทดสอบหน่วยการเรียนรู้ของเรา พิจารณาว่าUserServiceอาจทำการโทรผ่านเครือข่ายหรือฐานข้อมูลราคาแพง - เราเพิ่งลบปัจจัยแฝงของสิ่งนี้ นอกจากนี้ยังไม่มีความเสี่ยงในการUserServiceสัมผัสข้อมูลสด / กระทุ้ง class LoggingService(object): """ Just a contrived logging class …

11 object-oriented  python  dependency-injection  multiple-inheritance 

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

11 object-oriented  object-oriented-design 

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

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

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

การเขียนวัตถุผู้ใช้ในสวิฟท์ แต่คำถามของฉันเกี่ยวข้องกับภาษาที่พิมพ์ออกมาอย่างรุนแรง ผู้ใช้สามารถมีลิงก์จำนวนมาก (FacebookProfile, InstagramProfile, ฯลฯ ) คำถามสองสามข้อเกี่ยวกับเรื่องนี้ เป็นการดีที่จะรวมลิงก์ในวัตถุของตนเองหรือไม่? struct ผู้ใช้ { var firstName: string var lastName: string อีเมล var: สตริง ลิงก์ var: ลิงค์ } ลิงค์โครงสร้าง { var facebook: string var instagram: string var twitter: string } หรือพวกเขาควรจะหลวม? ฉันรู้ว่าทั้งสองวิธีใช้เทคนิคดี แต่สงสัยว่ามีวิธีแนะนำโดยทั่วไปหรือไม่โดยเฉพาะอย่างยิ่งสำหรับการอ่าน struct User { var firstName: string var lastName: string var …

10 java  c#  object-oriented  data-structures  swift-language 

ตัวอย่างเช่นคลาสมักจะมีสมาชิกชั้นเรียนและวิธีการเช่น: public class Cat{ private String name; private int weight; private Image image; public void printInfo(){ System.out.println("Name:"+this.name+",weight:"+this.weight); } public void draw(){ //some draw code which uses this.image } } แต่หลังจากอ่านเกี่ยวกับหลักการความรับผิดชอบเดี่ยวและหลักการเปิดแบบปิดฉันชอบแยกคลาสออกเป็น DTO และคลาสตัวช่วยด้วยวิธีสแตติกเท่านั้นเช่น: public class CatData{ public String name; public int weight; public Image image; } public class CatMethods{ public static …

10 object-oriented  static-methods  dto 

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

10 design  design-patterns  object-oriented  refactoring  clean-code 

เนื่องจากหลักการแยกอินเทอร์เฟซแนะนำว่าลูกค้าไม่ควรถูกบังคับให้ขึ้นอยู่กับวิธีการที่ไม่ได้ใช้ดังนั้นลูกค้าไม่ควรใช้วิธีการที่ว่างเปล่าสำหรับวิธีการอินเทอร์เฟซมิฉะนั้นวิธีการอินเทอร์เฟซนี้ แต่วิธีการที่เป็นรูปธรรม? ฉันควรแยกวิธีการที่ลูกค้าไม่ทุกคนจะใช้หรือไม่ พิจารณาคลาสต่อไปนี้: public class Car{ .... public boolean isQualityPass(){ ... } public int getTax(){ ... } public int getCost(){ ... } } public class CarShop{ ... public int getCarPrice(int carId){ Car car=carList[carId]; int price=car.getTax() + car.getCost()... (some formula); return price; } } ที่โค้ดด้านบน CarShop ไม่ได้ใช้วิธี isQualityPass () ใน …

10 object-oriented  solid 

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

10 design  object-oriented 

ฉันใหม่สำหรับการเขียนโปรแกรมเชิงวัตถุและฉันไม่เข้าใจว่าจุดประสงค์หลักของอะไร ใช่ฉันอ่านว่ามันเป็น "จุดเริ่มต้น" ของโปรแกรม แต่สิ่งที่ฉันไม่เข้าใจคือสิ่งที่ควรจะเป็นในหลัก และความรับผิดชอบของมันคืออะไร? อาจเกิดขึ้นว่าสิ่งที่เขียนในหลักอาจถูกห่อหุ้มในวัตถุอื่น แต่คุณควรใช้วิธีการนี้มากแค่ไหน? นี่คือหลักแรกของฉันที่ฉันเขียนใน Java มันง่ายมาก แต่อาจทำให้คุณเข้าใจข้อสงสัยของฉันดีขึ้น ฉันมีสัตว์ที่เป็นนามธรรมซึ่งขยายโดย "Cat" และ "Dog" ฉันใช้หลักในการสร้างวัตถุบางอย่างและยังเป็น "ส่วนต่อประสาน" กับผู้ใช้ด้วยอย่างที่คุณเห็นฉันใช้คำสั่งแบบมีเงื่อนไขเพื่อ "ถามผู้ใช้" สิ่งที่เขาต้องการจะทำ คำถามของฉันเกิดขึ้นจากความจริงที่ว่าอินเทอร์เฟซสามารถถูกห่อหุ้มในวัตถุอื่นและไม่ให้ความรับผิดชอบหลัก public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("What type of animal do you want to create? \n dog cat"); String type = input.nextLine(); if …

10 java  object-oriented  programming-practices  single-responsibility  entry-point 

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

10 c#  object-oriented  constructors  parameters  type-conversion 

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

10 c#  design-patterns  object-oriented  interfaces  dependency-management 

ฉันมีฐานสองชั้นOperationและTrigger. แต่ละคนมีจำนวนคลาสย่อยที่เชี่ยวชาญในการดำเนินการหรือทริกเกอร์บางประเภท สามารถเรียกเฉพาะTrigger OperationขณะสามารถเรียกโดยเฉพาะเจาะจงOperationTrigger ฉันต้องเขียนโค้ดที่แม็พOperationกับที่ได้รับTrigger(หรือกลับกัน) แต่ฉันไม่แน่ใจว่าจะใส่ไว้ที่ไหน ในกรณีนี้รหัสไม่ได้เป็นของชั้นหนึ่งหรือชั้นอื่น ๆ อย่างชัดเจน ดังนั้นในแง่ของหลักการความรับผิดชอบเดี่ยวฉันไม่แน่ใจว่าควรจะใช้รหัสใด ฉันเห็นตัวเลือกสามตัวที่ใช้งานได้ทั้งหมด ในขณะที่ 1 & 2 ดูเหมือนจะเป็นทางเลือกของซีแมนทิกส์ แต่ 3 หมายถึงแนวทางที่แตกต่างอย่างสิ้นเชิง bool Triggers(Operation o)ทริกเกอร์เช่น bool TriggeredBy(Trigger t)วิธีการใช้งานเช่น bool MappingExists(Trigger t, Operation o)ในระดับใหม่ทั้งหมดซึ่งจัดการการทำแผนที่เช่น ฉันจะตัดสินใจได้อย่างไรว่าจะวางรหัสการแมปที่ใช้ร่วมกันอย่างไรในหลักการความรับผิดชอบเดียว วิธีการจัดการความรับผิดชอบเดียวเมื่อมีการแบ่งปันความรับผิดชอบ? แก้ไข 1 ดังนั้นรหัสจริงจะเป็นแบบนี้ คุณสมบัติทั้งหมดที่มีอย่างใดอย่างหนึ่งstring, Guid, หรือcollection<string> enumโดยพื้นฐานแล้วพวกเขาเป็นเพียงตัวแทนของข้อมูลขนาดเล็ก แก้ไข 2 สาเหตุของการส่งคืนชนิดบูล ชั้นอื่นจะไปกินคอลเลกชันของและคอลเลกชันของTrigger Operationมันต้องการที่จะทราบว่าการทำแผนที่ที่มีอยู่ระหว่างและTrigger Operationมันจะใช้ข้อมูลนั้นเพื่อสร้างรายงาน

10 object-oriented  single-responsibility 

เนื่องจาก Python อนุญาตให้ใช้การสืบทอดหลายแบบการถ่ายทอดทางพันธุกรรมใน Python มีลักษณะอย่างไร ในภาษาที่มีการสืบทอดเดียวเช่น Java การสืบทอดจะถูกใช้เมื่อคุณสามารถพูดได้ว่าวัตถุหนึ่ง "is-a" ของวัตถุอื่นและคุณต้องการแบ่งปันรหัสระหว่างวัตถุ (จากวัตถุหลักไปยังวัตถุลูก) ตัวอย่างเช่นคุณสามารถพูดได้ว่าDogเป็นAnimal: public class Animal {...} public class Dog extends Animal {...} แต่เนื่องจาก Python รองรับการสืบทอดหลายแบบเราจึงสามารถสร้างวัตถุโดยการรวมวัตถุอื่นเข้าด้วยกัน ลองพิจารณาตัวอย่างด้านล่าง: class UserService(object): def validate_credentials(self, username, password): # validate the user credentials are correct pass class LoggingService(object): def log_error(self, error): # log an error pass …

10 object-oriented  python  inheritance  multiple-inheritance