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

ฉันพยายาม refactor ใบสมัครของฉันเป็น MVC แต่ฉันติดอยู่ที่ส่วน M ในแอปที่มีฐานข้อมูลสำรองโมเดลจะถูกนำไปใช้ในรหัสแอปใช่ไหม แต่แล้วอะไรคือสิ่งที่อยู่ในฐานข้อมูล - นั่นไม่ใช่แบบจำลองหรือไม่ (ฉันไม่ได้ใช้ฐานข้อมูลเป็นที่เก็บวัตถุแบบง่าย - ข้อมูลในฐานข้อมูลเป็นสินทรัพย์ขององค์กร)

14 design-patterns  mvc 

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

14 design-patterns  complexity  customer-relations 

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

14 object-oriented  design-patterns  coding 

ฉันเห็นสิ่งนี้มากมายในระบบเดิมของเราในที่ทำงาน - ฟังก์ชั่นที่เป็นไปตามนี้: bool todo = false; if(cond1) { ... // lots of code here if(cond2) todo = true; ... // some other code here } if(todo) { ... } ฟังก์ชั่นนี้มีสองส่วน ส่วนแรกทำการประมวลผลบางอย่าง (อาจมีลูปผลข้างเคียงและอื่น ๆ ) และตามวิธีที่อาจตั้งค่าสถานะ "todo" ส่วนที่สองจะดำเนินการก็ต่อเมื่อมีการตั้งค่าสถานะ "todo" ดูเหมือนจะเป็นวิธีที่น่าเกลียดในการทำสิ่งต่าง ๆ และฉันคิดว่ากรณีส่วนใหญ่ที่ฉันใช้เวลาในการทำความเข้าใจจริง ๆ แล้วสามารถนำกลับมาใช้ใหม่ได้เพื่อหลีกเลี่ยงการใช้ธง แต่นี่เป็นรูปแบบการต่อต้านที่แท้จริงความคิดที่ไม่ดีหรือเป็นที่ยอมรับอย่างสมบูรณ์หรือไม่? refactorization ชัดเจนแรกจะตัดเป็นสองวิธี อย่างไรก็ตามคำถามของฉันเกี่ยวกับว่ามีความต้องการ (ในภาษา OO …

14 design-patterns  anti-patterns  patterns-and-practices 

ฉันต้องออกแบบลำดับชั้นของชั้นเรียนสำหรับโครงการ C # ของฉัน โดยพื้นฐานแล้วฟังก์ชันของคลาสนั้นคล้ายกับคลาสของ WinForms ดังนั้นให้ลองใช้ชุดเครื่องมือ WinForms เป็นตัวอย่าง (อย่างไรก็ตามฉันไม่สามารถใช้ WinForms หรือ WPF ได้) มีคุณสมบัติและฟังก์ชั่นหลักบางอย่างที่ทุกชั้นต้องการ ขนาดตำแหน่งสีการมองเห็น (จริง / เท็จ) วิธีการวาด ฯลฯ ฉันต้องการคำแนะนำด้านการออกแบบฉันใช้การออกแบบที่มีคลาสเบสและอินเทอร์เฟซที่เป็นนามธรรมซึ่งไม่ใช่ประเภทจริง ๆ แต่ชอบพฤติกรรมมากกว่า นี่เป็นการออกแบบที่ดีหรือไม่? ถ้าไม่สิ่งที่จะเป็นการออกแบบที่ดีกว่า รหัสมีลักษณะดังนี้: abstract class Control { public int Width { get; set; } public int Height { get; set; } public int BackColor { get; …

14 c#  object-oriented  design-patterns  class-design 

สำหรับการกำหนดผมต้องไปหาที่ของแก๊งสี่รูปแบบการออกแบบการเรียนjava.io.Readerและ subclasses ของมันjava.io.PushbackReader, java.io.BufferedReaderและjava.io.FilterReaderถูกสร้างขึ้นด้วย ตามโพสต์นี้รูปแบบการออกแบบจะเป็นรูปแบบมัณฑนากร นี้จะทำให้รู้สึกถึงฉันถ้าPushbackReader, BufferedReaderและFilterReaderสามารถที่จะตกแต่งที่จะใช้ในเวลาเดียวกัน, BufferedPushbackFilterReaderการสร้างได้อย่างมีประสิทธิภาพ นั่นเป็นแนวคิดหรือไม่?

14 java  design-patterns 

ฉันเคยใช้ MVP และ MVC ในอดีตและฉันชอบ MVP มากกว่าเพราะมันควบคุมการไหลของการดำเนินการที่ดีขึ้นมากในความคิดของฉัน ฉันได้สร้างโครงสร้างพื้นฐานของฉัน (คลาสที่เก็บข้อมูล / พื้นที่เก็บข้อมูล) และใช้งานได้อย่างไม่มีปัญหาเมื่อทำการเข้ารหัสข้อมูลตัวอย่างอย่างหนักดังนั้นตอนนี้ฉันจึงย้ายไปยัง GUI และเตรียม MVP ของฉัน หมวดก ฉันได้เห็น MVP โดยใช้มุมมองเป็นจุดเริ่มต้นซึ่งอยู่ในวิธีการสร้างมุมมองที่สร้างพรีเซนเตอร์ซึ่งจะสร้างแบบจำลองเชื่อมโยงเหตุการณ์ตามความจำเป็น ฉันยังเห็นผู้นำเสนอเป็นจุดเริ่มต้นที่มุมมองโมเดลและผู้นำเสนอถูกสร้างขึ้นผู้นำเสนอนี้จะได้รับวัตถุมุมมองและแบบจำลองในตัวสร้างเพื่อโยงเหตุการณ์ เช่นเดียวกับใน 2 แต่รูปแบบไม่ผ่านไปยังผู้นำเสนอ แต่โมเดลเป็นคลาสสแตติกที่เรียกเมธอดและส่งคืนการตอบกลับโดยตรง มาตรา B ในแง่ของการรักษามุมมองและรูปแบบในการซิงค์ฉันได้เห็น เมื่อใดก็ตามที่ค่าในมุมมองเปลี่ยนไปเช่นTextChangedเหตุการณ์ใน. Net / C # นี่เป็นการยิงDataChangedEventที่ผ่านเข้าไปในแบบจำลองเพื่อให้ซิงค์อยู่ตลอดเวลา DataChangedEventและที่มีการเปลี่ยนแปลงรูปแบบคือเหตุการณ์พื้นหลังมันฟังแล้วมุมมองที่มีการปรับปรุงทางความคิดเดียวกันของการเพิ่ม เมื่อผู้ใช้ต้องการที่จะกระทำการเปลี่ยนแปลงSaveEventมันก็จะผ่านเข้าไปในแบบจำลองเพื่อทำการบันทึก ในกรณีนี้แบบจำลองเลียนแบบมุมมองข้อมูลและประมวลผลการกระทำ คล้ายกับ # b1 อย่างไรก็ตามมุมมองจะไม่ซิงค์กับโมเดลตลอดเวลา แต่เมื่อผู้ใช้ต้องการที่จะยอมรับการเปลี่ยนแปลงSaveEventถูกไล่ออกและผู้นำเสนอคว้ารายละเอียดล่าสุดและส่งพวกเขาไปยังรูปแบบ ในกรณีนี้โมเดลไม่ทราบเกี่ยวกับข้อมูลมุมมองจนกว่าจะต้องดำเนินการกับมันซึ่งในกรณีนี้โมเดลจะถูกส่งผ่านรายละเอียดที่จำเป็นทั้งหมด หมวด C การแสดงวัตถุธุรกิจในมุมมองเช่นวัตถุ (MyClass) ไม่ใช่ข้อมูลดั้งเดิม (int, double) …

14 c#  design  design-patterns  winforms 

"จำนวนอาร์กิวเมนต์ที่เหมาะสมที่สุดสำหรับฟังก์ชั่นคือศูนย์" นั้นผิดปกติ จำนวนอาร์กิวเมนต์ที่เหมาะสมที่สุดคือจำนวนที่ต้องการเพื่อให้ฟังก์ชันของคุณปราศจากผลข้างเคียง น้อยกว่านั้นและคุณไม่จำเป็นต้องทำให้หน้าที่ของคุณไม่บริสุทธิ์ดังนั้นบังคับให้คุณหลีกทางให้พ้นจากหลุมแห่งความสำเร็จและไต่ระดับความเจ็บปวด บางครั้ง "ลุงบ๊อบ" ก็พร้อมให้คำแนะนำ บางครั้งเขาผิดอย่างงดงาม คำแนะนำข้อโต้แย้งของเขาเป็นศูนย์เป็นตัวอย่างของสิ่งหลัง ( ที่มา: ความเห็นโดย @David Arno ภายใต้คำถามอื่นบนเว็บไซต์นี้ ) ความคิดเห็นที่ได้รับเพิ่มขึ้นอย่างน่าทึ่งจาก 133 upvotes ซึ่งเป็นเหตุผลที่ฉันต้องการที่จะให้ความสนใจอย่างใกล้ชิดกับบุญของมัน เท่าที่ฉันทราบมีสองวิธีในการเขียนโปรแกรม: การเขียนโปรแกรมการทำงานที่บริสุทธิ์ (สิ่งที่ความคิดเห็นนี้เป็นกำลังใจ) และบอกอย่าถาม (ซึ่งเป็นครั้งคราวแนะนำบนเว็บไซต์นี้เช่นกัน) AFAIK หลักการสองข้อนี้ไม่สามารถใช้ร่วมกันได้ใกล้เคียงกับสิ่งที่ตรงกันข้าม: การทำงานที่บริสุทธิ์สามารถสรุปได้ว่า "เพียงแค่คืนค่าไม่มีผลข้างเคียง" ในขณะที่บอกอย่าถามสามารถสรุปได้ว่า "ไม่คืนสิ่งใดเลย" มีผลข้างเคียงเท่านั้น " นอกจากนี้ฉันยังงุนงงเพราะฉันคิดว่าการบอกอย่าถามถือเป็นแกนหลักของกระบวนทัศน์ OO ในขณะที่ funcitons บริสุทธิ์ถือเป็นแกนหลักของกระบวนทัศน์การทำงาน - ตอนนี้ฉันเห็นฟังก์ชั่นบริสุทธิ์ที่แนะนำใน OO! ฉันคิดว่านักพัฒนาน่าจะเลือกหนึ่งในกระบวนทัศน์เหล่านี้และยึดติดกับมัน? ฉันต้องยอมรับว่าฉันไม่สามารถพาตัวเองไปติดตามได้ บ่อยครั้งที่มันสะดวกสำหรับฉันที่จะคืนค่าและฉันไม่สามารถมองเห็นได้ว่าฉันจะบรรลุสิ่งที่ฉันต้องการเพื่อให้บรรลุเฉพาะกับผลข้างเคียง บ่อยครั้งที่มันสะดวกสำหรับฉันที่จะมีผลข้างเคียงและฉันไม่เห็นจริง ๆ ว่าฉันจะบรรลุสิ่งที่ฉันต้องการได้รับเพียงแค่คืนค่า นอกจากนี้บ่อยครั้ง (ฉันเดาว่ามันน่ากลัว) ฉันมีวิธีการที่ทำทั้งสองอย่าง …

14 design-patterns  pure-function 

ฉันขาดการออกแบบเชิงวัตถุและเชิงเวกเตอร์ ฉันชอบความสามารถโครงสร้างและความปลอดภัยที่วัตถุมอบให้กับสถาปัตยกรรมทั้งหมด แต่ในขณะเดียวกันความเร็วนั้นสำคัญมากสำหรับฉันและการมีตัวแปรลอยแบบง่าย ๆ ในอาเรย์ช่วยในภาษา / ไลบรารีที่ใช้เวกเตอร์เช่น Matlab หรือ numpy ใน Python นี่คือส่วนหนึ่งของรหัสที่ฉันเขียนเพื่ออธิบายจุดของฉัน ปัญหา: การเพิ่มหมายเลขความผันผวนของ Tow หาก x และ y เป็นสองตัวเลขความผันผวนผลรวมของความผันผวนคือ (x ^ 2 + y ^ 2) ^ 0.5 (สมมติว่ามีเงื่อนไขทางคณิตศาสตร์บางอย่าง แต่นั่นไม่ใช่สิ่งสำคัญที่นี่) ฉันต้องการดำเนินการนี้อย่างรวดเร็วและในเวลาเดียวกันฉันต้องแน่ใจว่าผู้คนไม่เพียงเพิ่มความผันผวนในทางที่ผิด (x + y) ทั้งสองอย่างนี้มีความสำคัญ การออกแบบตาม OO จะเป็นดังนี้: from datetime import datetime from pandas import * class Volatility: …

14 design-patterns  object-oriented  python  speed 

ฉันได้เห็นข้อโต้แย้งต่าง ๆ กับ DAO ที่ถูกเรียกจากคอนโทรลเลอร์คลาสโดยตรงและ DAO จากคลาส Model สิ่งประดิษฐ์ฉันรู้สึกว่าถ้าเราติดตาม MVC pattern ตัวควบคุมไม่ควรควบคู่กับ DAO แต่เป็น Model class ควรเรียกใช้ DAO จากภายในและผู้ควบคุมควรเรียกใช้คลาสโมเดลเพราะเราสามารถแยกคลาสโมเดลออกจากเว็บแอปพลิเคชันและแสดงฟังก์ชันการทำงานสำหรับวิธีต่างๆเช่นบริการ REST เพื่อใช้คลาสโมเดลของเรา หากเราเขียนการร้องขอ DAO ในคอนโทรลเลอร์จะไม่สามารถใช้บริการ REST เพื่อนำฟังก์ชันการทำงานกลับมาใช้ใหม่ได้ใช่ไหม ฉันได้สรุปแนวทางทั้งสองด้านล่าง วิธีการ # 1 public class CustomerController extends HttpServlet { proctected void doPost(....) { Customer customer = new Customer("xxxxx","23",1); new CustomerDAO().save(customer); } } วิธีการ …

14 java  mvc  design-patterns  dao 

ฉันกำลังพัฒนา RESTful API และฉันคิดว่ามันสะดวกที่จะใช้ DAO สำหรับทรัพยากรของฉันเพราะแม้ว่าฉันจะใช้หน่วยความจำเพื่อเก็บไว้ แต่ฉันไม่ต้องการปิดประตูให้ใครก็ตามที่ใช้ห้องสมุดของฉันถ้าพวกเขาตัดสินใจที่จะใช้ การใช้ฐานข้อมูลสำหรับ DAO คำถามของฉันคือว่า DAO ควรเป็นซิงเกิลตันหรือไม่ หากไม่ใช่บริการจะมีตัวอย่างของ DAO และจะมีลักษณะเช่นนี้: @Path("eventscheduler") public class EventSchedulerService { private IEventSchedulerDao dao = new EventSchedulerDao(); // in case a different implementation is to be used public void setEventSchedulerDao(IEventSchedulerDao dao) { this.dao = dao; } @Path("{uniqueName}") @GET @Produces(MediaType.APPLICATION_JSON) public Tournament …

14 java  design  design-patterns  singleton  dao 

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

14 design  design-patterns  factory-method  factory 

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

14 design-patterns  mvc 

รูปแบบกลยุทธ์ใช้งานได้ดีเพื่อหลีกเลี่ยงขนาดใหญ่หาก ... สร้างและทำให้ง่ายต่อการเพิ่มหรือแทนที่ฟังก์ชั่น อย่างไรก็ตามมันยังคงมีข้อบกพร่องหนึ่งในความคิดของฉัน ดูเหมือนว่าในการดำเนินการทุกครั้งยังคงต้องมีการสร้างการแยกทาง อาจเป็นไฟล์จากโรงงานหรือไฟล์ข้อมูล เป็นตัวอย่างใช้ระบบการสั่งซื้อ โรงงาน: // All of these classes implement OrderStrategy switch (orderType) { case NEW_ORDER: return new NewOrder(); case CANCELLATION: return new Cancellation(); case RETURN: return new Return(); } รหัสหลังจากนี้ไม่จำเป็นต้องกังวลและมีเพียงที่เดียวที่จะเพิ่มประเภทคำสั่งซื้อใหม่ในขณะนี้ แต่ส่วนของรหัสนี้ยังไม่สามารถขยายได้ การดึงออกมาเป็นไฟล์ข้อมูลช่วยให้อ่านง่ายขึ้น (ฉันรู้ว่าเป็นที่ถกเถียงกัน): <strategies> <order type="NEW_ORDER">com.company.NewOrder</order> <order type="CANCELLATION">com.company.Cancellation</order> <order type="RETURN">com.company.Return</order> </strategies> แต่สิ่งนี้ยังคงเพิ่มรหัสสำเร็จรูปในการประมวลผลไฟล์ข้อมูล - รับได้ง่ายขึ้นหน่วยทดสอบและรหัสที่ค่อนข้างเสถียร แต่ความซับซ้อนเพิ่มเติม …

14 design  design-patterns  unit-testing  strategy 

ฉันไม่แน่ใจว่ารูปแบบการออกแบบใดที่สามารถช่วยแก้ไขปัญหานี้ได้ ฉันมีคลาส 'ผู้ประสานงาน' ซึ่งกำหนดว่าควรใช้คลาสใดของผู้ปฏิบัติงานโดยไม่ต้องทราบเกี่ยวกับประเภทของแรงงานที่มีทั้งหมด - เพียงแค่เรียกใช้ WorkerFactory และดำเนินการตามอินเทอร์เฟซ IWorker ทั่วไป จากนั้นตั้งค่าผู้ปฏิบัติงานที่เหมาะสมให้ทำงานและส่งคืนผลลัพธ์ของวิธี 'DoWork' นี่เป็นเรื่องปกติ ... จนถึงตอนนี้; เรามีข้อกำหนดใหม่สำหรับคลาส Worker ใหม่ "WorkerB" ซึ่งต้องการข้อมูลเพิ่มเติมเช่นพารามิเตอร์อินพุตเพิ่มเติมเพื่อให้สามารถใช้งานได้ มันเหมือนกับว่าเราต้องการวิธีการทำงานหนักที่มีพารามิเตอร์อินพุตเพิ่มเติม ... แต่จากนั้นคนงานที่มีอยู่ทั้งหมดจะต้องใช้วิธีการนั้น - ซึ่งดูเหมือนว่าผิดเพราะคนงานเหล่านั้นไม่ต้องการวิธีการนั้นจริงๆ ฉันจะสร้างสิ่งนี้ใหม่ได้อย่างไรเพื่อให้ผู้ประสานงานไม่ทราบว่ามีการใช้งานของคนงานคนใดและยังอนุญาตให้ผู้ใช้งานแต่ละคนได้รับข้อมูลที่ต้องใช้ในการทำงาน แต่ไม่มีคนงานทำสิ่งที่ไม่จำเป็น มีคนงานที่มีอยู่จำนวนมากอยู่แล้ว ฉันไม่ต้องการเปลี่ยนคนงานคอนกรีตที่มีอยู่เพื่อรองรับความต้องการของคลาส WorkerB ใหม่ ฉันคิดว่าบางทีรูปแบบของ Decorator น่าจะดีที่นี่ แต่ฉันไม่เคยเห็น Decorators ตกแต่งวัตถุด้วยวิธีเดียวกัน แต่ใช้พารามิเตอร์ที่แตกต่างกันมาก่อน ... สถานการณ์ในรหัส: public class Coordinator { public string GetWorkerResult(string workerName, int a, …

14 c#  design-patterns