วิธีการจัดการความรับผิดชอบเดียวเมื่อมีการแบ่งปันความรับผิดชอบ?

ฉันมีฐานสองชั้นOperationและTrigger. แต่ละคนมีจำนวนคลาสย่อยที่เชี่ยวชาญในการดำเนินการหรือทริกเกอร์บางประเภท สามารถเรียกเฉพาะTrigger OperationขณะสามารถเรียกโดยเฉพาะเจาะจงOperationTrigger

ฉันต้องเขียนโค้ดที่แม็พOperationกับที่ได้รับTrigger(หรือกลับกัน) แต่ฉันไม่แน่ใจว่าจะใส่ไว้ที่ไหน

ในกรณีนี้รหัสไม่ได้เป็นของชั้นหนึ่งหรือชั้นอื่น ๆ อย่างชัดเจน ดังนั้นในแง่ของหลักการความรับผิดชอบเดี่ยวฉันไม่แน่ใจว่าควรจะใช้รหัสใด

ฉันเห็นตัวเลือกสามตัวที่ใช้งานได้ทั้งหมด ในขณะที่ 1 & 2 ดูเหมือนจะเป็นทางเลือกของซีแมนทิกส์ แต่ 3 หมายถึงแนวทางที่แตกต่างอย่างสิ้นเชิง

1. bool Triggers(Operation o)ทริกเกอร์เช่น
2. bool TriggeredBy(Trigger t)วิธีการใช้งานเช่น
3. bool MappingExists(Trigger t, Operation o)ในระดับใหม่ทั้งหมดซึ่งจัดการการทำแผนที่เช่น

ฉันจะตัดสินใจได้อย่างไรว่าจะวางรหัสการแมปที่ใช้ร่วมกันอย่างไรในหลักการความรับผิดชอบเดียว

วิธีการจัดการความรับผิดชอบเดียวเมื่อมีการแบ่งปันความรับผิดชอบ?

แก้ไข 1

ดังนั้นรหัสจริงจะเป็นแบบนี้ คุณสมบัติทั้งหมดที่มีอย่างใดอย่างหนึ่งstring, Guid, หรือcollection<string> enumโดยพื้นฐานแล้วพวกเขาเป็นเพียงตัวแทนของข้อมูลขนาดเล็ก

แก้ไข 2

สาเหตุของการส่งคืนชนิดบูล ชั้นอื่นจะไปกินคอลเลกชันของและคอลเลกชันของTrigger Operationมันต้องการที่จะทราบว่าการทำแผนที่ที่มีอยู่ระหว่างและTrigger Operationมันจะใช้ข้อมูลนั้นเพื่อสร้างรายงาน

ฉันจะคิดถึงมันด้วยวิธีนี้: มันจะกำหนดได้อย่างไรว่า Operation ใดที่ Trigger ที่จะถูกทริกเกอร์ จะต้องเป็นอัลกอริทึมที่สามารถเปลี่ยนแปลงได้ตลอดเวลาหรือพัฒนาเป็นอัลกอริธึมหลายอย่าง การวางไว้ในคลาส Trigger หรือ Operation หมายความว่าคลาสเหล่านั้นจะสามารถจัดการกับสถานการณ์ดังกล่าวได้ในอนาคต โปรดทราบว่าฉันไม่เห็นมันง่ายเหมือนการทำแผนที่เนื่องจากอาจมีมากกว่านั้น

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

โปรดทราบว่าข้อสันนิษฐานหลักในสายการคิดนี้คือการเขียนรหัสขั้นต่ำ (เช่นสามคลาสในปัจจุบัน) แต่เพื่อหลีกเลี่ยงการปรับเปลี่ยนครั้งใหญ่หากการทำงานจำเป็นต้องมีการขยายในอนาคตโดยไม่ทำให้สมมติฐานว่าจะมีวิธีเดียว กำหนดว่า Trigger ตัวใดที่ทำให้เกิดการใช้งาน

หวังว่านี่จะช่วยได้ แม้ว่าการตอบสนองจะคล้ายกับ user61852 การให้เหตุผลต่างกัน เป็นผลให้การดำเนินการจะแตกต่างกัน (เช่นมีวิธีการที่ชัดเจนแทนการเอาชนะเท่ากับดังนั้นจำนวนของวิธีการที่สามารถพัฒนาตลอดเวลาขึ้นอยู่กับความต้องการ)

เคยทำมาแล้ว

ตัวเลือก # 3

ฉันไม่รู้ว่าคุณจะใช้ภาษาอะไร แต่ฉันจะใช้โค้ดหลอกที่คล้ายกันมากกับ Java หากภาษาของคุณคือ C # คุณอาจมีส่วนต่อประสานและโครงสร้างคล้ายกัน

มีคลาส Mapping หรืออินเตอร์เฟส:

public interface Mapping {
    public void setObject1(Object o);
    public void setObject2(Object o);
    public Object getObjecto1();
    public Object getObjecto2();
}

• แทนที่equals()เมธอดของการMappingรวบรวมดังนั้นMappingสามารถถูกสอบถามว่ามีการแม็พที่กำหนดหรือไม่
• วัตถุโดยเฉพาะควรมีequals()วิธีการadecuate เช่นกัน
• ยังใช้อินเตอร์เฟสComparableเพื่อให้คุณสามารถเรียงลำดับรายงานได้

คุณสามารถใส่การแม็พไว้ในคอลเล็กชันได้

List<Mapping> list = new ArrayList<Mapping>();
Hat hat = new Hat();
Bag bag = new Bag();
list.add(new Mapping(hat,bag));

หลังจากนั้นคุณสามารถถาม:

// let's say you have a variable named x which is of type Mapping

if ( list.contains(x) ){
    // do some thing
}

4. แบ่งรหัสของคุณออกเป็นบิตขนาดเล็ก

ขณะนี้คุณมีคลาส A ที่รู้เกี่ยวกับคลาส B และคลาส B ที่รู้เกี่ยวกับคลาส A. นั่นคือการมีเพศสัมพันธ์มากมายที่เกิดขึ้น

โดยคำจำกัดความ A กำลังดำเนินการอย่างน้อยการดำเนินงานของตัวเองและการตรวจสอบว่า B ควรจะทำงาน การย้อนกลับเป็นจริงกับ B. คลาสใดก็ตามที่เรียกว่าอันดับแรกควรจะสามารถดูผลลัพธ์และดูว่าจำเป็นต้องเรียกใช้สิ่งต่อไปหรือไม่

ลองแยกข้อต่อนั้นโดยแบ่งชั้นเรียนของคุณออกเป็นส่วนประกอบที่เล็กลง ฉันชอบที่จะแสดงความคิดเห็นที่ด้านบนของแต่ละชั้นอธิบายเป็นภาษาอังกฤษธรรมดาสิ่งที่มันทำ หากคุณต้องการใช้คำเช่น AND หรือมากกว่าประโยคหนึ่งหรือสองประโยคคุณต้องพิจารณาแยกย่อย ตามกฎทั่วไปอะไรหลังจาก "และ" ควรอยู่ในชั้นเรียนของตนเอง

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