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

การออกแบบโดยสัญญา (DbC) เป็นวิธีการตั้งโปรแกรมป้องกันหรือไม่ เป็นวิธีหนึ่งในการเขียนโปรแกรมที่ดีกว่าในบางกรณีมากกว่าวิธีอื่นหรือไม่

26 design-patterns  contract  defensive-programming 

ใน Javascript มีเทคนิคที่เด่นชัดบางประการสำหรับการสร้างและจัดการคลาส / เนมสเปซในจาวาสคริปต์ ฉันอยากรู้ว่าสถานการณ์ใดที่รับประกันโดยใช้เทคนิคหนึ่งกับอีกเทคนิคหนึ่ง ฉันต้องการที่จะเลือกและติดกับมันก้าวไปข้างหน้า ฉันเขียนรหัสองค์กรที่ได้รับการบำรุงรักษาและใช้งานร่วมกันในหลาย ๆ ทีมและฉันต้องการที่จะรู้ว่าวิธีที่ดีที่สุดในการเขียนจาวาสคริปต์คืออะไร? ฉันมักจะชอบฟังก์ชั่นนิรนามที่ดำเนินการเอง แต่ฉันอยากรู้ว่าชุมชนโหวตให้กับเทคนิคเหล่านี้อย่างไร ต้นแบบ: function obj() { } obj.prototype.test = function() { alert('Hello?'); }; var obj2 = new obj(); obj2.test(); ฟังก์ชั่นไม่เปิดเผยตัวตนปิดตัวเอง: //Self-Executing Anonymous Function (function( skillet, $, undefined ) { //Private Property var isHot = true; //Public Property skillet.ingredient = "Bacon …

26 javascript  design-patterns 

ฉันช่วยจัดการทีมภายนอกที่เริ่มพัฒนาผลิตภัณฑ์ใหม่ที่มีอยู่บางรุ่น ในอดีตทีมนี้มักจะใช้รูปแบบของโครงการเดียวในโซลูชันเดียวสำหรับโมดูลประมาณ 30 โมดูลใน Visual Studio ซึ่งทำงานร่วมกันเพื่อสร้างโครงสร้างที่ปรับใช้ได้ สิ่งนี้มีผลกระทบที่เป็นอันตรายต่อการสร้างความน่าเชื่อถือและคุณภาพเนื่องจากพวกเขาไม่ได้ส่งซอร์สโค้ดที่ทันสมัยที่สุดมาให้เราเสมอ เราพยายามที่จะกดพวกเขาเพื่อรวมรหัสอ้างอิงทั้งหมดในโซลูชันเดียว แต่เราได้รับการต่อต้าน - โดยเฉพาะพวกเขาพูดคุยเกี่ยวกับการพึ่งพาซึ่งกันและกันระหว่างโมดูล (อ่าน "โครงการ" ใน Visual Studio) เพิ่มขึ้นหากทุกอย่างอยู่ใน ไฟล์โซลูชันเดียว ไม่มีการใช้รหัสใดในโซลูชันแยกต่างหากที่อื่น ฉันยืนยันว่านี่เป็นเรื่องไร้สาระและรูปแบบการพัฒนาที่ดีจะหลีกเลี่ยงปัญหาดังกล่าว ทีมที่มีปัญหายังดำเนินการแก้ไขข้อผิดพลาดและการพัฒนาคุณสมบัติใหม่ในผลิตภัณฑ์ที่มีอยู่ซึ่งประสบการณ์ที่ได้รับนั้นเต็มไปด้วยปัญหาที่พูดได้น้อยที่สุดและได้รับความทุกข์ทรมานจากปัญหาเดียวกัน เราถูกปฏิเสธการเข้าถึงแหล่งควบคุม ( TFS ) ของพวกเขาและวิธีการที่เราดำเนินการเพื่อรวมรหัสฐานคือการพยายามและลดจำนวนของการอัปเดตที่ขาดหายไปและอย่างน้อยก็ลดลงเป็นครั้งคราว (ใช่แล้ว - แนะนำให้รู้จักกับผลิตภัณฑ์) โดยการพูดว่า "ส่ง ZIP ของโฟลเดอร์โซลูชันทั้งหมดให้เราเพื่อให้เราสามารถคลายซิปเปิดใน Visual Studio และกดF5 สำหรับการทดสอบ "ในแง่ของโครงสร้างและคุณภาพทั่วไปรหัสนั้นค่อนข้างแย่และยากที่จะให้การสนับสนุนประสบการณ์นี้เป็นสาเหตุที่ฉันตั้งใจจะทำให้กระบวนการทำงานถูกต้องในช่วงต้นของการพัฒนาให้เร็วที่สุดเท่าที่จะทำได้ มีบางอย่างที่ฉันขาดหายไปหรือไม่? มีเหตุผลที่ดีที่จะแยกรหัสทั้งหมดออกไหม สำหรับเงินของฉันมันจะต้องมีเหตุผลที่น่าสนใจดังนั้นมันจึงเป็นความรู้ทั่วไป แต่ฉันก็เต็มใจที่จะยอมรับว่าฉันไม่รู้ทุกอย่าง

26 c#  design-patterns  visual-studio 

คำถามนี้ถูกโยกย้ายจาก Code Exchange Stack Stack เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 6 ปีที่แล้ว ขณะนี้ฉันกำลังออกแบบระบบ Entityของฉันใหม่สำหรับ C ++ และฉันมีผู้จัดการจำนวนมาก ในการออกแบบของฉันฉันมีชั้นเรียนเหล่านี้เพื่อผูกห้องสมุดของฉันเข้าด้วยกัน ฉันได้ยินสิ่งเลวร้ายมากมายเมื่อพูดถึงคลาส "ผู้จัดการ" บางทีฉันอาจไม่ได้ตั้งชื่อชั้นเรียนของฉันอย่างเหมาะสม อย่างไรก็ตามฉันไม่รู้ว่าจะตั้งชื่อพวกเขาอย่างไร ผู้จัดการส่วนใหญ่ในห้องสมุดของฉันประกอบด้วยชั้นเรียนเหล่านี้ (แม้ว่ามันจะแตกต่างกันเล็กน้อย): คอนเทนเนอร์ - คอนเทนเนอร์สำหรับวัตถุในตัวจัดการ คุณสมบัติ - คุณลักษณะสำหรับวัตถุในผู้จัดการ ในการออกแบบใหม่สำหรับห้องสมุดของฉันฉันมีชั้นเรียนเฉพาะเหล่านี้เพื่อผูกห้องสมุดของฉันเข้าด้วยกัน ComponentManager - จัดการส่วนประกอบใน Entity System ComponentContainer ComponentAttributes ฉาก * - อ้างอิงถึงฉาก (ดูด้านล่าง) SystemManager - จัดการระบบในระบบองค์กร SystemContainer ฉาก * …

26 design  design-patterns  c++  class  entity-component-system 

มีโครงการที่ฉันกำลังทำอยู่ที่ต้องการผลิตเว็บแอปพลิเคชันที่จะจัดการรายการงานระหว่างผู้ใช้หลายคน นี่คือรายการงานหลักที่มีรายการงานกระจายโดยผู้ใช้ที่ได้รับอนุญาต ผู้ใช้แต่ละคนมีบัญชีของตนเองเพื่อเข้าสู่ระบบและดูงานที่ได้รับมอบหมาย เป็นไปได้ที่ผู้ใช้หลายคนจะมีภารกิจเดียวที่เหมือนกัน ฉันกำลังพยายามที่จะออกรายละเอียดของโครงการออกมาจากสิ่งนี้ในขณะที่ฉันกำลังดิ้นรนมากขึ้นด้วยแนวคิดโดยรวมของวิธีการจัดการกับสถานการณ์ต่อไปนี้ แต่ถ้ามันช่วยฉันใช้ Java, EclipseLink และ GWT กับ RequestFactory ฐานข้อมูลคือ PostgreSQL ดังนั้นปัญหาเกี่ยวกับความคิดที่ฉันพยายามจะกระทบยอดคือ: หากงานเดียวที่เกิดขึ้นกับผู้ใช้หลายคนเปลี่ยนแปลงในทางใด ๆ เช่นงานที่ทำเสร็จแล้วถูกลบ ฯลฯ รายการงานของผู้ใช้ทั้งหมดที่มีงานนี้จะได้รับการอัปเดต รูปแบบการออกแบบใดที่ช่วยในการนำฟังก์ชั่นนี้ไปใช้? รูปแบบบางอย่างที่ฉันดูเป็นผู้สังเกตการณ์และผู้ไกล่เกลี่ย - มีรูปแบบอื่น ๆ ที่ควรพิจารณาในสิ่งเหล่านี้หรือไม่? สมมติว่ามีผู้ใช้สองคนเปลี่ยนงานเดียวกันในเวลาเดียวกัน ก่อนอื่นฉันควรอนุญาตให้สถานการณ์นั้นเกิดขึ้นหรือฉันควรล็อคไว้จนกว่าจะมีคนหนึ่งหรืออีกคนหนึ่งทำการเปลี่ยนแปลง? ประการที่สองถ้าฉันไม่ใส่กุญแจฉันจะกระทบยอดการเปลี่ยนแปลงที่จะยอมรับได้อย่างไร สิ่งนี้เกี่ยวข้องกับสถานการณ์ใน 1 เนื่องจากผู้ใช้ 1 สามารถส่งข้อมูลและก่อนที่ผู้ใช้ 2 จะได้รับข้อมูลที่อัปเดตเขา / เธออาจดำเนินการต่อไปและส่งการเปลี่ยนแปลงของเขา / เธอ ฉันกำลังมองหาจุดชี้แนะคำแนะนำหรือเคล็ดลับใด ๆ ที่คุณสามารถให้ในการซิงค์ข้อมูลระหว่างอินสแตนซ์ต่าง ๆ ของเว็บแอพนี้อย่างถูกต้อง ฉันจะขอบคุณมันมาก!

26 design  web-development  design-patterns  web-applications 

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

25 design  design-patterns  object-oriented  encapsulation 

การพยายามออกแบบ API สำหรับแอปพลิเคชันภายนอกที่มีการคาดการณ์ล่วงหน้าสำหรับการเปลี่ยนแปลงนั้นไม่ใช่เรื่องง่าย แต่การคิดล่วงหน้าเล็กน้อยจะทำให้ชีวิตง่ายขึ้นในภายหลัง ฉันกำลังพยายามสร้างโครงร่างที่จะรองรับการเปลี่ยนแปลงในอนาคตในขณะที่ยังคงเข้ากันได้แบบย้อนกลับโดยปล่อยให้ตัวจัดการเวอร์ชันก่อนหน้าเข้าแทนที่ ข้อกังวลหลักของบทความนี้คือรูปแบบใดที่ควรปฏิบัติตามสำหรับจุดสิ้นสุดที่กำหนดไว้ทั้งหมดสำหรับผลิตภัณฑ์ / บริษัท ที่กำหนด โครงการฐาน ได้รับเทมเพลต URL ฐานของhttps://rest.product.com/ผมได้วางแผนว่าบริการทั้งหมดอาศัยอยู่ภายใต้/apiพร้อมกับ/authและปลายทางที่ไม่ใช่ส่วนที่เหลืออื่น ๆ /docเช่น ดังนั้นฉันสามารถสร้างจุดปลายพื้นฐานดังนี้: https://rest.product.com/api/... https://rest.product.com/auth/login https://rest.product.com/auth/logout https://rest.product.com/doc/... จุดบริการ ตอนนี้สำหรับปลายทางเอง ความกังวลเกี่ยวกับPOST, GET, DELETEไม่ได้เป็นวัตถุประสงค์หลักของบทความนี้และเป็นกังวลกับการกระทำเหล่านั้นเอง จุดปลายสามารถแบ่งออกเป็นเนมสเปซและการกระทำได้ แต่ละการกระทำจะต้องนำเสนอตัวเองในวิธีที่จะสนับสนุนการเปลี่ยนแปลงขั้นพื้นฐานในประเภทผลตอบแทนหรือพารามิเตอร์ที่จำเป็น การใช้บริการแชทสมมุติที่ผู้ใช้ที่ลงทะเบียนสามารถส่งข้อความเราอาจมีจุดสิ้นสุดดังต่อไปนี้: https://rest.product.com/api/messages/list/{user} https://rest.product.com/api/messages/send ตอนนี้เพื่อเพิ่มการรองรับเวอร์ชันสำหรับการเปลี่ยนแปลง API ในอนาคตซึ่งอาจแตกหัก เราสามารถเพิ่มลายเซ็นเวอร์ชันหลังจาก/api/หรือหลังจาก/messages/นั้น เมื่อกำหนดsendจุดสิ้นสุดเราจะได้สิ่งต่อไปนี้สำหรับ v1 https://rest.product.com/api/v1/messages/send https://rest.product.com/api/messages/v1/send ดังนั้นคำถามแรกของฉันคือสถานที่ที่แนะนำสำหรับตัวระบุรุ่นคืออะไร ผู้จัดการรหัสควบคุม ดังนั้นตอนนี้เราได้สร้างขึ้นแล้วเราจำเป็นต้องสนับสนุนเวอร์ชันก่อนหน้าดังนั้นเราจึงต้องจัดการกับรหัสสำหรับเวอร์ชั่นใหม่แต่ละเวอร์ชั่นซึ่งอาจเลิกใช้ไปตามกาลเวลา สมมติว่าเรากำลังเขียนจุดปลายใน Java เราสามารถจัดการสิ่งนี้ผ่านแพ็คเกจ package com.product.messages.v1; public interface MessageController { …

25 design  design-patterns  web-services  rest  services 

ฉันมีอินเทอร์เฟซที่มีฟังก์ชันการทำงานที่กำหนดไว้จำนวนหนึ่ง สมมติว่า: interface BakeryInterface { public function createCookies(); public function createIceCream(); } สิ่งนี้ทำงานได้ดีสำหรับการนำไปใช้งานส่วนใหญ่ของอินเทอร์เฟซ แต่ในบางกรณีฉันต้องเพิ่มฟังก์ชันใหม่บางอย่าง (เช่นอาจรีดเป็นวิธีใหม่createBrownies()) วิธีการที่ชัดเจน / ไร้เดียงสาในการทำเช่นนี้คือการขยายส่วนต่อประสาน: interface BrownieBakeryInterface extends BakeryInterface { public function createBrownies(); } แต่มีข้อเสียใหญ่ที่ฉันไม่สามารถเพิ่มฟังก์ชั่นใหม่โดยไม่ต้องปรับเปลี่ยน API ที่มีอยู่ (เช่นการเปลี่ยนคลาสเพื่อใช้อินเทอร์เฟซใหม่) ฉันกำลังคิดเกี่ยวกับการใช้อะแดปเตอร์เพื่อเพิ่มฟังก์ชันการทำงานหลังจาก instantiation: class BrownieAdapter { private brownieBakery; public function construct(BakeryInterface bakery) { this->brownieBakery = bakery; } public function createBrownies() …

25 object-oriented  design-patterns  adapter 

วันนี้มีคำถามโผล่ในใจของฉัน: วิธีที่เราใช้ Javascript กับเกือบทุกอย่างที่ถือว่าเป็นแนวปฏิบัติที่ดีในการพัฒนาซอฟต์แวร์แบบดั้งเดิมหรือไม่? ฉันมีชุดคำถาม / ข้อสังเกตที่เกี่ยวข้องกับคำชี้แจงนี้ แต่เพื่อให้เป็นไปตามรูปแบบของ StackExchange มันจะดีกว่าถ้าฉันแยกพวกเขาออกเป็นคำถามที่แตกต่างกัน โมดูลที่ต้องการ รหัส Javascript มาตรฐานทุกวันนี้ดูเหมือนว่า: const someModule = require('./someModule') module.exports = function doSomethingWithRequest() { // do stuff someModule.someFunc() // do other stuff } ข้อดี การห่อหุ้ม: โมดูลทำงานแบบสแตนด์อโลนและรู้ทุกอย่างที่จำเป็นในการทำหน้าที่ของมัน ลูกค้าสามารถใช้โมดูลได้ง่ายขึ้น ข้อเสีย การตรวจสอบได้แย่: นี่คือมาตรฐานเมื่อไม่ได้ใช้ DI แต่ในภาษาแบบไดนามิกเช่นจาวาสคริปต์ไว้ก็สามารถโกง * โดยโมดูลเหมือนหรือmockeryrewire แน่นอนมันละเมิดกรม - ไม่ต้องสับสนกับการพึ่งพาการฉีด - เนื่องจากฉันสามารถนำเข้าโมดูลที่เป็นรูปธรรมได้เท่านั้น มันอาจละเมิดOCP - …

24 design-patterns  javascript 

ฉันอ่านC # ออกแบบ Essentials ฉันกำลังอ่านเกี่ยวกับรูปแบบตัววนซ้ำ ฉันเข้าใจวิธีการนำไปใช้อย่างสมบูรณ์ แต่ฉันไม่เข้าใจความสำคัญหรือดูกรณีการใช้งาน ในหนังสือจะมีตัวอย่างให้ในกรณีที่มีคนต้องการได้รับรายชื่อของวัตถุ พวกเขาจะได้ทำเช่นนี้โดยการเปิดเผยทรัพย์สินของประชาชนเช่นหรือIList<T>Array หนังสือเล่มนี้เขียน ปัญหาเกี่ยวกับเรื่องนี้คือการเป็นตัวแทนภายในในทั้งสองชั้นเรียนเหล่านี้ได้สัมผัสกับโครงการภายนอก การเป็นตัวแทนภายในคืออะไร? ความจริงมันเป็นarrayหรือIList<T>? ฉันไม่เข้าใจจริงๆว่าทำไมสิ่งนี้เป็นสิ่งที่ไม่ดีสำหรับผู้บริโภค (โปรแกรมเมอร์ที่เรียกสิ่งนี้) รู้ ... หนังสือบอกว่ารูปแบบนี้ใช้งานได้โดยเปิดเผยGetEnumeratorฟังก์ชั่นของมันเพื่อให้เราสามารถเรียกGetEnumerator()และเปิดเผย 'รายการ' ด้วยวิธีนี้ ฉันคิดว่ารูปแบบนี้มีสถานที่ (เหมือนทั้งหมด) ในบางสถานการณ์ แต่ฉันไม่เห็นว่าที่ไหนและเมื่อไหร่

24 design-patterns  iterator 

ในบางรหัสของฉันฉันมีโรงงานแบบคงที่เช่นนี้: public class SomeFactory { // Static class private SomeFactory() {...} public static Foo createFoo() {...} public static Foo createFooerFoo() {...} } ในระหว่างการตรวจสอบรหัสมันก็เสนอว่าควรจะเป็นซิงเกิลตันและฉีด ดังนั้นควรมีลักษณะดังนี้: public class SomeFactory { public SomeFactory() {} public Foo createFoo() {...} public Foo createFooerFoo() {...} } บางสิ่งที่ควรเน้น: โรงงานทั้งสองไร้สัญชาติ ข้อแตกต่างระหว่างเมธอดคือขอบเขต (อินสแตนซ์ vs คงที่) การใช้งานเหมือนกัน Foo เป็นถั่วที่ไม่มีส่วนต่อประสาน ข้อโต้แย้งที่ฉันได้รับจากการคงที่คือ: …

24 java  design-patterns  singleton  factory-method 

วิธีง่าย ๆ ในการรักษาการตั้งค่าของแอปพลิเคชัน Java จะถูกแสดงด้วยไฟล์ข้อความที่มีนามสกุล ".properties" ที่มีตัวระบุของแต่ละการตั้งค่าที่เกี่ยวข้องกับค่าเฉพาะ (ค่านี้อาจเป็นตัวเลขสตริงวันที่ ฯลฯ ) . C # ใช้วิธีการที่คล้ายกัน แต่ไฟล์ข้อความจะต้องมีชื่อว่า "App.config" ในทั้งสองกรณีในซอร์สโค้ดคุณต้องเริ่มต้นคลาสเฉพาะสำหรับการอ่านการตั้งค่า: คลาสนี้มีวิธีการส่งคืนค่า (เป็นสตริง) ที่เกี่ยวข้องกับตัวระบุการตั้งค่าที่ระบุ // Java example Properties config = new Properties(); config.load(...); String valueStr = config.getProperty("listening-port"); // ... // C# example NameValueCollection setting = ConfigurationManager.AppSettings; string valueStr = setting["listening-port"]; // ... ในทั้งสองกรณีเราควรแยกสตริงที่โหลดจากไฟล์การกำหนดค่าและกำหนดค่าที่แปลงให้กับวัตถุที่พิมพ์ที่เกี่ยวข้อง (ข้อผิดพลาดในการแยกวิเคราะห์อาจเกิดขึ้นในช่วงนี้) …

24 java  c#  design-patterns  object-oriented 

สมมติว่าฉันมีขั้นตอนที่ทำสิ่งต่าง ๆ : void doStuff(initalParams) { ... } ตอนนี้ฉันค้นพบแล้วว่า ขั้นตอนที่จะมีขนาดใหญ่ผมแบ่งมันออกเป็นขั้นตอนขนาดเล็กหลาย ๆ และเร็ว ๆ นี้ฉันตระหนักดีว่ามีชนิดของรัฐจะเป็นประโยชน์ในขณะที่ทำสิ่งเพื่อที่ฉันจะต้องผ่านพารามิเตอร์น้อยระหว่างขั้นตอนเล็ก ๆ ดังนั้นฉันแยกมันออกเป็นคลาสของตัวเอง: class StuffDoer { private someInternalState; public Start(initalParams) { ... } // some private helper procedures here ... } แล้วฉันจะเรียกมันว่า: new StuffDoer().Start(initialParams); หรือเช่นนี้ new StuffDoer(initialParams).Start(); และนี่คือสิ่งที่รู้สึกผิด เมื่อใช้. NET หรือ Java API ฉันไม่เคยโทรnew SomeApiClass().Start(...);ซึ่งทำให้ฉันสงสัยว่าฉันทำผิด แน่นอนว่าฉันสามารถทำให้คอนสตรัคเตอร์ของ StuffDoer …

24 design-patterns  object-oriented  language-agnostic 

ฉันรู้ว่าเมื่อสร้างแอปพลิเคชั่น (ดั้งเดิมหรือเว็บ) เช่นใน Apple AppStore หรือ Google Play app store นั้นเป็นเรื่องธรรมดามากที่จะใช้สถาปัตยกรรม Model-View-Controller อย่างไรก็ตามมันมีเหตุผลที่จะสร้างแอพพลิเคชั่นที่ใช้สถาปัตยกรรม Component-Entity-System ทั่วไปในเอ็นจิ้นเกมหรือไม่?

24 design-patterns  architecture  mvc  game-development  applications 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange โอนย้าย 8 ปีที่แล้ว ฉันไม่เข้าใจรูปแบบการออกแบบ "สะพาน" เลย ฉันได้ผ่านเว็บไซต์ต่าง ๆ แต่พวกเขาไม่ได้ช่วย ใครช่วยฉันในการทำความเข้าใจสิ่งนี้

24 design-patterns