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

ทำไมจึงเป็นประโยชน์ในการใช้รูปแบบกลยุทธ์หากคุณสามารถเขียนโค้ดของคุณใน if / then cases? ตัวอย่างเช่น: ฉันมีคลาส TaxPayer และหนึ่งในวิธีการของมันจะคำนวณภาษีโดยใช้อัลกอริทึมที่แตกต่างกัน เหตุใดจึงไม่มีกรณีและกรณีและคิดว่าอัลกอริธึมที่จะใช้ในวิธีการนั้นแทนที่จะใช้รูปแบบกลยุทธ์หรือไม่ นอกจากนี้ทำไมคุณไม่สามารถใช้วิธีแยกต่างหากสำหรับแต่ละอัลกอริทึมในคลาส TaxPayer ได้ นอกจากนี้มันหมายความว่าอัลกอริทึมที่จะเปลี่ยนที่รันไทม์?

15 design  design-patterns  object-oriented-design  patterns-and-practices  strategy 

เจ้านายของฉันให้โครงการฉันด้วยตรรกะเฉพาะ ฉันต้องพัฒนาเว็บเพจที่มีการนำทางผ่านหลาย ๆ กรณีจนกว่าเขา / เธอจะมาถึงผลิตภัณฑ์ นี่คือรูปแบบเส้นทางของการนำทางในไซต์: สำคัญ! ในหน้าผลิตภัณฑ์เนวิเกเตอร์สามารถเลือกตัวกรองที่ต้องการ ถ้า A เขา / เธอต้องผ่าน B (และแน่นอน C) หรือ C และถึงผลิตภัณฑ์ ถ้า B เขา / เธอจะต้องผ่าน C และเข้าถึงผลิตภัณฑ์ ถ้า C เขา / เธอเข้าถึงผลิตภัณฑ์โดยตรง แน่นอนว่าถ้าฉันเริ่มต้นจาก AI กำลังติดตามเส้นทางที่ยาวที่สุดและเมื่อฉันไปถึงผลิตภัณฑ์ฉันมีตัวกรองที่ใช้งานอยู่ 3 ตัว จนถึงตอนนี้ฉันพัฒนาโค้ดต่อไปนี้ซึ่งใช้งานได้ดี if filter_A if filter_B filter_C() .. else .. else filter_C .. else …

15 design  design-patterns  language-agnostic  conditions  if-statement 

ฉันใช้เวลาพอสมควรในการพัฒนาวิดเจ็ตอย่างง่ายสำหรับโครงการด้วยวิธีต่อไปนี้: var project = project || {}; (function() { project.elements = { prop1: val1, prop2: val2 } project.method1 = function(val) { // Do this } project.method2 = function(val) { // Do that } project.init = function() { project.method1(project.elements.prop1) project.method2(project.elements.prop2) } })() project.init(); แต่ฉันได้เริ่มเปลี่ยนรูปแบบของฉันเป็นดังต่อไปนี้: function Project() { this.elements = { prop1: …

15 design-patterns  javascript  prototyping 

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

15 design-patterns  object-oriented  functions 

ฉันได้อ่านเอกสารประกอบและหัวข้อคำถามอื่น ๆเกี่ยวกับหัวข้อนี้และฉันไม่รู้สึกมั่นใจจริงๆ ฉันไม่เห็นข้อ จำกัด ของการใช้เทคนิคนี้อย่างชัดเจน เศษจะเห็นในขณะนี้เป็นวิธีที่ดีที่สุด ; ทุกกิจกรรมควรเป็นส่วนสนับสนุนอย่างน้อยหนึ่งแฟรกเมนต์และไม่เรียกเลย์เอาต์โดยตรง แฟรกเมนต์ถูกสร้างขึ้นเพื่อ: อนุญาตให้Activityใช้ชิ้นส่วนจำนวนมากเปลี่ยนระหว่างหน่วยเหล่านี้เพื่อนำหน่วยเหล่านี้กลับมาใช้ใหม่ ... ==> Fragmentทั้งหมดขึ้นอยู่กับContextกิจกรรมดังนั้นหากฉันต้องการสิ่งทั่วไปที่ฉันสามารถนำมาใช้ใหม่และจัดการกับกิจกรรมมากมายฉันสามารถ สร้างเลย์เอาต์ที่กำหนดเองของตัวเองหรือมุมมอง ... ฉันจะไม่สนใจเกี่ยวกับเลเยอร์การพัฒนาความซับซ้อนเพิ่มเติมที่ชิ้นส่วนจะเพิ่ม การจัดการความละเอียดที่แตกต่างกันดีกว่า ==> ตกลงสำหรับแท็บเล็ต / โทรศัพท์ในกรณีที่กระบวนการที่ยาวนานซึ่งเราสามารถแสดงสองชิ้น (หรือมากกว่า) ในกิจกรรมเดียวกันในแท็บเล็ตและหนึ่งต่อหนึ่งในโทรศัพท์ แต่ทำไมฉันถึงต้องใช้แฟรกเมนต์เสมอ ? การจัดการการเรียกกลับเพื่อนำทางระหว่าง Fragments (เช่น: หากผู้ใช้เข้าสู่ระบบฉันจะแสดงส่วนอื่นฉันแสดงส่วนอื่น) ===> เพียงแค่ลองดูว่ามีข้อบกพร่องมากมายในการลงชื่อเข้าใช้ SDK ของ Facebook เพราะเหตุนี้เพื่อให้เข้าใจว่าเป็นจริง (?) ... การพิจารณาว่าแอปพลิเคชัน Android นั้นยึดตามกิจกรรม ... การเพิ่มวงจรชีวิตอีกอันในกิจกรรมจะดีกว่าในการออกแบบแอปพลิเคชัน ... ฉันหมายถึงโมดูลสถานการณ์การจัดการข้อมูลและการเชื่อมต่อจะได้รับการออกแบบที่ดีขึ้น ทาง ===> นี่คือคำตอบของใครบางคนที่เคยเห็น Android SDK และ …

15 design-patterns  performance  android  fragmentation 

ลองนึกภาพลูกค้าของคุณต้องการที่จะมีความเป็นไปได้ที่จะเพิ่มคุณสมบัติใหม่ (เช่นสี) ให้กับผลิตภัณฑ์ใน eshop ของพวกเขาใน CMS ของพวกเขา แทนที่จะมีคุณสมบัติเป็นฟิลด์: class Car extends Product { protected String type; protected int seats; } คุณอาจจะทำสิ่งที่ชอบ: class Product { protected String productName; protected Map<String, Property> properties; } class Property { protected String name; protected String value; } นั่นคือการสร้างระบบประเภทของตัวเองอยู่ด้านบนของระบบที่มีอยู่ ฉันรู้สึกเช่นนี้อาจเห็นได้ว่าเป็นการสร้างโดเมนเฉพาะหรือไม่? วิธีนี้เป็นรูปแบบการออกแบบที่รู้จักหรือไม่? คุณจะแก้ปัญหาต่างกันหรือไม่? ฉันรู้ว่ามีภาษาที่ฉันสามารถเพิ่มเขตข้อมูลในรันไทม์ แต่สิ่งที่เกี่ยวกับฐานข้อมูล? คุณอยากจะเพิ่ม / …

15 design-patterns  object-oriented 

ฉันมักจะพบว่าตัวเองคืนบูลีนจากวิธีการที่ใช้ในหลาย ๆ ตำแหน่งเพื่อให้มีตรรกะทั้งหมดรอบวิธีนั้นในที่เดียว วิธีการโทร (ภายใน) ทั้งหมดจำเป็นต้องทราบว่าการดำเนินการนั้นสำเร็จหรือไม่ ฉันใช้ Python แต่คำถามไม่ได้เจาะจงเฉพาะภาษานั้น มีเพียงสองตัวเลือกที่ฉันนึกได้ เพิ่มข้อยกเว้นถึงแม้ว่าสถานการณ์จะไม่ได้ยอดเยี่ยมและอย่าลืมจับข้อยกเว้นนั้นในทุกที่ที่มีการเรียกใช้ฟังก์ชัน คืนบูลีนขณะที่ฉันกำลังทำ นี่คือจริงๆตัวอย่างง่ายๆที่แสดงให้เห็นว่าสิ่งที่ผมพูดถึง import os class DoSomething(object): def remove_file(self, filename): try: os.remove(filename) except OSError: return False return True def process_file(self, filename): do_something() if remove_file(filename): do_something_else() แม้ว่ามันจะใช้งานได้ แต่ฉันไม่ชอบวิธีนี้ในการทำอะไรบางอย่างมัน "มีกลิ่น" และบางครั้งอาจทำให้เกิดการซ้อนกันหลายครั้ง แต่ฉันไม่สามารถคิดถึงวิธีที่ง่ายกว่านี้ได้ ฉันสามารถใช้ปรัชญา LBYL มากขึ้นและใช้os.path.exists(filename)ก่อนที่จะพยายามลบ แต่ก็ไม่รับประกันว่าไฟล์จะไม่ถูกล็อคในระหว่างนี้ (มันไม่น่าเป็นไปได้ แต่เป็นไปได้) และฉันยังต้องพิจารณาว่าการลบนั้นสำเร็จหรือไม่ นี่เป็นการออกแบบที่ "ยอมรับได้" และหากไม่ใช่สิ่งที่จะเป็นวิธีที่ดีกว่าในการออกแบบสิ่งนี้

15 design-patterns  python  boolean 

ปัญหา สมมติว่าฉันมีคลาสที่เรียกว่าDataSourceมีReadDataวิธี (และบางทีคนอื่น ๆ แต่ให้สิ่งที่ง่าย) เพื่ออ่านข้อมูลจาก.mdbไฟล์: var source = new DataSource("myFile.mdb"); var data = source.ReadData(); ไม่กี่ปีต่อมาฉันตัดสินใจว่าฉันต้องการให้สามารถรองรับ.xmlไฟล์เพิ่มเติมจาก.mdbไฟล์เป็นแหล่งข้อมูล การนำไปใช้สำหรับ "การอ่านข้อมูล" นั้นค่อนข้างแตกต่างกันสำหรับ.xmlและ.mdbไฟล์ ดังนั้นถ้าฉันจะออกแบบระบบตั้งแต่เริ่มต้นฉันจะนิยามมันดังนี้: abstract class DataSource { abstract Data ReadData(); static DataSource OpenDataSource(string fileName) { // return MdbDataSource or XmlDataSource, as appropriate } } class MdbDataSource : DataSource { override Data ReadData() { …

15 c#  design-patterns  refactoring  factory-method 

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

15 java  design-patterns 

ฉันต้องการทราบว่ามีรูปแบบการออกแบบใด ๆ สำหรับเว็บนอกเหนือจาก MVC หรือไม่ ฉันรู้ว่ามีรูปแบบการออกแบบเป็น: Registry, Observer, Factory, ActiveRecord, ... และ MVC ชุดของรูปแบบการออกแบบอื่น ๆ และโครงสร้างโฟลเดอร์ มีรูปแบบการออกแบบเช่น MVC เป็นชุดรูปแบบการออกแบบอื่น ๆ หรือไม่? แก้ไข: ภาษาการเขียนโปรแกรมของฉันคือ PHP

15 web-development  php  design-patterns  mvc 

ฉันมีคำถามในขณะที่ออกแบบสถาปัตยกรรมสำหรับโครงการรอบ MVC (เป็นโครงการ SDK C ++ / Marmalade ฉันไม่ได้ใช้กรอบ MVC ใด ๆ โดยเฉพาะฉันกำลังทำอยู่) ในหลาย ๆ บทความ (เช่นเดียวกับบทความเดิมของ Steve Burbek ) ฉันอ่านแนวคิด "MVC triad" ที่ทำให้ฉันรู้สึกแย่ตั้งแต่ที่ฉันใช้แนวคิดนี้ไป เมื่อฉันอ่านครั้งแรกดูเหมือนว่าแอปพลิเคชันจะถูกสร้างขึ้นรอบ ๆ "MVC triad" - หนึ่งชิ้นสำหรับแต่ละส่วน UI ที่ฉันควรจะ - แต่ฉันพบว่ามันค่อนข้างไม่ยืดหยุ่นและฉันคิดว่านั่นไม่ใช่วิธีที่ MVC ตั้งใจใช้ จากนั้นทำการค้นคว้าเพิ่มเติมเกี่ยวกับปัญหาฉันพบตัวอย่างของการมีเพศสัมพันธ์อย่างแน่นหนาของคอนโทรลเลอร์และมุมมองคือความสัมพันธ์แบบ 1 ต่อ 1 - TextEditView มี TextEditController แต่เมื่อฉันกลับไปที่โครงการของฉันฉันพบว่าอาจเป็นประโยชน์ที่จะมีตัวควบคุมหนึ่ง (โดย 'หน่วยทางลอจิคัล' เช่น AddElementController) และหลายมุมมองสำหรับตัวควบคุมนั้น …

15 design  design-patterns  architecture  mvc 

เรากำลังใช้ ASP.NET MVC 2 กับเลเยอร์ควบคุมและมุมมองการนำเสนอและรูปแบบซึ่งประกอบด้วยชั้นตรรกะทางธุรกิจ, ชั้นการเข้าถึงข้อมูล ในชั้นธุรกิจขึ้นไปเพื่อวัตถุประสงค์ส่วนใหญ่การแก้ไขดูเหมือนว่าจะสามารถแสดงทั้งการสร้างวัตถุและการแก้ไขวัตถุ สิ่งนี้สอดคล้องกันกับรูปแบบการออกแบบพื้นที่เก็บข้อมูลของเราซึ่งกำหนดวิธีการ "บันทึก" เราสามารถเช็คอินกระบวนงานที่เก็บไว้ถ้า ID เป็น 0 และสร้างวัตถุใหม่ถ้าเป็น 0 มิฉะนั้นเราสามารถอัปเดตวัตถุที่มีอยู่ได้เนื่องจากรหัสหมวดหมู่ควรตรงกับหนึ่ง ประเด็นหลักของการสนทนาคือถ้าเหมาะสมที่สุดที่จะแยกการแก้ไขซึ่งรวมถึงการสร้างเป็นส่วนต่าง ๆ ของการสร้างและแก้ไขนอกเหนือจากเลเยอร์ DAL ตัวอย่างที่ชัดเจนสามารถแสดงเป็นเส้นทาง: สร้าง - http: // someurl / somearea / edit / 0 แก้ไข - http: // someurl / somearea / edit / 254 เมื่อเทียบกับ สร้าง - http: // someurl / …

15 design  design-patterns  asp.net-mvc 

สิ่งที่ฉันหมายถึงนี่คือเราจะเปลี่ยนจากเทมเพลตบางส่วนT add(T a, T b) ...เป็นรหัสที่สร้างได้อย่างไร ฉันคิดถึงวิธีที่จะบรรลุผลสองสามอย่างนี้เราเก็บฟังก์ชันทั่วไปไว้ใน AST Function_Nodeแล้วทุกครั้งที่เราใช้เราเก็บไว้ในโหนดฟังก์ชั่นดั้งเดิมสำเนาของตัวเองด้วยประเภททั้งหมดที่ถูกTแทนที่ด้วยประเภทที่ กำลังใช้. ยกตัวอย่างเช่นadd<int>(5, 6)จะเก็บสำเนาของฟังก์ชั่นทั่วไปหาaddและทดแทนทุกประเภทT ในการคัดลอกintด้วย ดังนั้นมันจะมีลักษณะดังนี้: struct Function_Node { std::string name; // etc. Type return_type; std::vector<std::pair<Type, std::string>> arguments; std::vector<Function_Node> copies; }; จากนั้นคุณสามารถสร้างรหัสสำหรับสิ่งเหล่านี้และเมื่อคุณเยี่ยมชมFunction_Nodeรายการของสำเนาที่copies.size() > 0คุณเรียกใช้visitFunctionในสำเนาทั้งหมด visitFunction(Function_Node& node) { if (node.copies.size() > 0) { for (auto& node : nodes.copies) { visitFunction(node); } // it's …

15 design-patterns  programming-languages  compiler 

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

15 design-patterns  object-oriented-design  repository 

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

15 design-patterns