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

เมื่อออกแบบ schema ฐานข้อมูลเชิงสัมพันธ์สำหรับเว็บแอปพลิเคชันฉันมักจะพบกรณีที่ฉันท้ายสร้างตารางเพียงเพื่อประกอบด้วยหนึ่งแถวและแถวเดียวเท่านั้น รู้สึกว่าเป็นวิธีที่ผิดในการออกแบบ แต่ฉันไม่สามารถหาอะไรที่ดีกว่าอย่างมีนัยสำคัญได้หรือว่าเป็น "วิธีที่ถูกต้องในการทำมัน" ตัวอย่างล่าสุดคือไซต์ที่ให้ผู้ใช้ควบคุมเนื้อหาบนหน้าแรกด้วยตนเอง มีหน้าแรกเพียงหน้าเดียว ฉันสร้างตารางที่มีฟิลด์ที่จำเป็นทั้งหมดเพื่อสร้างโฮมเพจเช่นฟิลด์ข้อความสำหรับพื้นที่ที่มีข้อความอธิบาย ฟิลด์สำหรับจัดเก็บชื่อของไฟล์ภาพขนาดใหญ่ คีย์ต่างประเทศบางตัวที่ชี้ไปยังบทความที่จะให้ความสำคัญกับหน้าแรก ฯลฯ ทำงานได้ แต่รู้สึกผิดที่มีตารางที่มีแถวเดียว ในอดีตที่ผ่านมาฉันได้ลองการออกแบบอื่น ๆ เช่นการอนุญาตให้มีหลายแถวในตารางหน้าแรกและการเลือกแบบสุ่ม ฉันได้ลองเพิ่มเขตข้อมูลบูลีนชื่อ "ใช้งานอยู่" และเลือกหนึ่งในหน้าแรกที่ใช้งานอยู่แบบสุ่ม ฉันพยายามบังคับให้แถวเดียวใช้งานได้ตลอดเวลาตามที่กำหนดในตรรกะของแอปพลิเคชัน ฉันไม่ได้พยายามสร้างตารางหน้าแรกและมีรายการอื่น ๆ เช่นบทความเพื่อให้มีฟิลด์บูลีนที่มีชื่อเช่น featured_on_homepage ในกรณีส่วนใหญ่ฉันสามารถสร้างหน้าแรกด้วยค่าคงที่จำนวนมากในไฟล์การตั้งค่า ปัญหาหลักของไฟล์การตั้งค่าคืออยู่ภายใต้การควบคุมของนักพัฒนาซอฟต์แวร์ เนื่องจากสิ่งที่ชอบเนื้อหาของโฮมเพจเป็นสิ่งที่ผู้ใช้จะต้องแก้ไขจึงต้องไปที่ฐานข้อมูล ในหลาย ๆ เว็บไซต์ฉันไม่มีปัญหานี้เพราะฉันสามารถสร้างสิ่งต่าง ๆ เช่นหน้าแรกด้วยแบบสอบถามเช่นการเลือกบทความใหม่ล่าสุดห้ารายการ แต่เมื่อฉันมีหน้าที่ดูแลด้วยตนเองด้วยข้อกำหนดที่เข้มงวดมันจะยุ่งยากในการสร้างแบบจำลองในฐานข้อมูล แต่ลองจินตนาการว่าคุณมีโต๊ะรูปถ่ายและโต๊ะบทความ ข้อกำหนดคือหน้าแรกจะแสดงภาพถ่ายห้าภาพบทความสามบทความและข้อความสองบล็อกโดยผู้ใช้ควบคุมด้วยตนเอง คุณทำแบบนั้นในฐานข้อมูลอย่างถูกต้องได้อย่างไร นอกจากนี้ฉันมีปัญหาการสร้างแบบจำลองในกรณีอื่น ๆ นอกเหนือจากหน้าแรกเพียง มันเป็นเพียงตัวอย่างที่ง่ายที่สุดและใช้ได้โดยทั่วไปที่ฉันสามารถหาได้

12 design-patterns  database-development  database 

มีคำถามที่คล้ายกันอยู่สองสามข้อ 1 ,2 ,3 ,4แต่ดูเหมือนว่าไม่ใช่ในกรณีของคำถามนี้และการแก้ปัญหาก็ดูดีที่สุด นี่เป็นคำถามทั่วไปของ OOP โดยสมมติว่ามีหลายรูปแบบชื่อสามัญและมิกซ์อินมีอยู่ ภาษาจริงที่ใช้คือ OOP Javascript (Typescript) แต่เป็นปัญหาเดียวกันใน Java หรือ C ++ ฉันมีลำดับชั้นของชั้นเรียนแบบขนานซึ่งบางครั้งก็มีพฤติกรรมที่เหมือนกัน (ส่วนต่อประสานและการใช้งาน) แต่บางครั้งก็มีพฤติกรรมที่ 'ได้รับการป้องกัน' ของตัวเอง ภาพประกอบดังนี้: นี้สำหรับวัตถุประสงค์ในการประกอบการอธิบายเท่านั้น ; มันไม่ใช่แผนภาพคลาสที่แท้จริง หากต้องการอ่าน: สิ่งใดก็ตามในลำดับชั้นทั่วไป (กลาง) จะแชร์กันระหว่างทั้ง Canvas (ซ้าย) และ SVG (ขวา) ด้วยการแบ่งปันฉันหมายถึงทั้งอินเทอร์เฟซและการใช้งาน สิ่งใดก็ตามที่อยู่บนคอลัมน์ซ้ายหรือขวาหมายถึงพฤติกรรม (วิธีการและสมาชิก) เฉพาะสำหรับลำดับชั้นนั้น ตัวอย่างเช่น: ทั้งลำดับชั้นซ้ายและขวาใช้กลไกการตรวจสอบความถูกต้องเดียวกันแสดงเป็นวิธีการเดียว ( Viewee.validate()) ในลำดับชั้นทั่วไป paint()เพียงลำดับชั้นของผ้าใบมีวิธีการ วิธีนี้เรียกวิธีการทาสีบนเด็กทุกคน ลำดับชั้น SVG จำเป็นต้องแทนที่addChild()วิธีการCompositeแต่ไม่ได้เป็นกรณีที่มีลำดับชั้นของผืนผ้าใบ โครงสร้างจากลำดับชั้นทั้งสองไม่สามารถผสมกันได้ …

12 design-patterns  object-oriented  inheritance  multiple-inheritance  mixins 

ฉันได้พูดคุยกับเพื่อนร่วมงานของฉันในวันนี้เกี่ยวกับโครงร่างเว็บของ Python และความประทับใจของเราที่มีต่อพวกเขา ฉันบอกเขาว่าฉันคิดว่า Flask ที่มีคำขอทั่วโลกมีกลิ่นไม่ดีและเป็นรูปแบบการต่อต้าน เอกสารพูดเกี่ยวกับบริบทคำขอ: ในทางตรงกันข้ามระหว่างการจัดการคำขอมีกฎอื่นอยู่สองข้อ: ในขณะที่คำขอใช้งานอยู่วัตถุบริบทท้องถิ่น (flask.request และอื่น ๆ ) ชี้ไปที่คำขอปัจจุบัน รหัสใด ๆ สามารถถือวัตถุเหล่านี้ได้ตลอดเวลา ฉันคิดว่าฉันเข้าใจแนวคิดเบื้องหลังการตัดสินใจออกแบบนี้ - เพื่อทำให้แอปพลิเคชันง่ายขึ้น เป็นเพียงการประนีประนอมเช่นในกรณีของThread Locals : ใช่มันไม่ใช่ความคิดที่สดใสในการใช้เธรดท้องถิ่น พวกเขาทำให้เกิดปัญหาสำหรับเซิร์ฟเวอร์ที่ไม่ได้ขึ้นอยู่กับแนวคิดของเธรดและทำให้แอปพลิเคชันขนาดใหญ่ยากต่อการบำรุงรักษา อย่างไรก็ตาม Flask ไม่ได้ออกแบบมาสำหรับแอพพลิเคชั่นขนาดใหญ่หรือเซิร์ฟเวอร์แบบอะซิงโครนัส Flask ต้องการทำให้รวดเร็วและง่ายต่อการเขียนเว็บแอปพลิเคชันแบบดั้งเดิม การแพตช์ออบเจกต์โกลบอลกับข้อมูลการร้องขอปัจจุบันเป็นรูปแบบการต่อต้านหรือไม่? ฉันเชื่อว่าเป็นเพราะอยู่ในมุมมองของวิเคราะห์รหัสคงที่ทั่วโลกแม้ว่ามันจะไม่ และฉันในฐานะโปรแกรมเมอร์จะไม่เข้าใจวิธีการทำงานโดยไม่อ่านเอกสารอย่างละเอียด และนี้มีผลกระทบในการทดสอบ เป็นการดีที่จะส่งคำขอเป็นอาร์กิวเมนต์เพื่อดู ฉันคิดว่าสามารถอ่านได้ชัดเจนและง่ายขึ้นในการดีบัก และหลีกเลี่ยงสถานะโลก

12 design-patterns  python  anti-patterns  flask 

บริบท ฉันได้ใช้กับลำดับชั้นของวัตถุ (ต้นไม้นิพจน์) รูปแบบผู้เข้าชม "หลอก" (หลอกเพราะมันไม่ได้ใช้ส่งสองครั้ง): public interface MyInterface { void Accept(SomeClass operationClass); } public class MyImpl : MyInterface { public void Accept(SomeClass operationClass) { operationClass.DoSomething(); operationClass.DoSomethingElse(); // ... and so on ... } } การออกแบบนี้เป็นที่ตั้งคำถาม แต่ค่อนข้างสะดวกสบายเนื่องจากจำนวนการใช้งานของ MyInterface มีความสำคัญ (~ 50 หรือมากกว่า) และฉันไม่จำเป็นต้องเพิ่มการดำเนินการเพิ่มเติม การใช้งานแต่ละอย่างนั้นไม่ซ้ำกัน (เป็นนิพจน์หรือตัวดำเนินการที่แตกต่างกัน) และบางรายการเป็นคอมโพสิต (เช่นโหนดโอเปอเรเตอร์ที่จะมีโอเปอเรเตอร์ / โหนดใบไม้) Traversal …

12 c#  design-patterns  object-oriented  visitor-pattern 

เมื่อฉันพยายามออกแบบโซลูชัน OO ฉันมักใช้การสร้างแบบจำลองCRCโดยที่ฉันแสดงรายการชื่อคลาส (คำนาม) สิ่งที่พวกเขาทำ (คำกริยา) และวิธีที่พวกเขาทำงานร่วมกับคลาสอื่น ๆ บล็อกนี้มีสิ่งด้านล่างที่จะพูดเกี่ยวกับวิธีการที่เป็นคำนามคำกริยานี้ ...This approach, which I will call “noun and verb,” is so limited I’ll dare to call it brain damaged.... คำถามของฉันคือมีเทคนิคการสร้างแบบจำลองที่ดีกว่าที่จะใช้วิธีการ OO หรือไม่?

12 design  object-oriented  design-patterns 

หลักการ open-closed (OCP) ระบุว่าควรเปิดวัตถุสำหรับส่วนขยาย แต่ปิดเพื่อทำการปรับเปลี่ยน ฉันเชื่อว่าฉันเข้าใจและใช้งานร่วมกับ SRP เพื่อสร้างคลาสที่ทำสิ่งเดียวเท่านั้น และฉันพยายามสร้างวิธีการขนาดเล็กจำนวนมากที่ทำให้สามารถแยกการควบคุมพฤติกรรมทั้งหมดออกเป็นวิธีที่อาจขยายหรือแทนที่ในคลาสย่อยบางประเภท ดังนั้นฉันจบลงด้วยคลาสที่มีคะแนนส่วนขยายมากมายไม่ว่าจะเป็น: การฉีดและองค์ประกอบ, เหตุการณ์, การมอบหมาย ฯลฯ พิจารณาคลาสที่เรียบง่ายและขยายได้ดังต่อไปนี้ class PaycheckCalculator { // ... protected decimal GetOvertimeFactor() { return 2.0M; } } ตอนนี้พูดเช่นว่าการOvertimeFactorเปลี่ยนแปลง 1.5 ตั้งแต่ระดับดังกล่าวข้างต้นได้รับการออกแบบมาเพื่อขยายฉันสามารถ subclass OvertimeFactorและกลับที่แตกต่างกัน แต่ ... แม้จะมีคลาสที่ถูกออกแบบมาสำหรับการขยายและการยึดติดกับ OCP ฉันจะแก้ไขวิธีการที่เป็นปัญหามากกว่าซับคลาสและแทนที่วิธีการที่มีปัญหา ด้วยเหตุนี้ฉันจึงละเมิดส่วนหนึ่งของความพยายามของ OCP ที่จะทำให้สำเร็จ รู้สึกเหมือนฉันเพิ่งขี้เกียจเพราะสิ่งที่กล่าวมานั้นง่ายกว่านิดหน่อย ฉันเข้าใจ OCP ผิดหรือเปล่า? ฉันควรจะทำอะไรที่แตกต่างออกไปจริงๆเหรอ? คุณใช้ประโยชน์จาก OCP ต่างกันหรือไม่ อัปเดต …

12 design  design-patterns  architecture  object-oriented 

ในบทความจำนวนมากทั่วทั้งเว็บคำว่า Inversion of Control และ Dependency Inversion Principle ดูเหมือนจะสับสนและถูกนำมาใช้เป็นคำพ้องความหมาย (ความสับสนเพิ่มเติมถูกบังคับใช้โดยเครื่องมือที่เรียกว่า "ตู้คอนเทนเนอร์ DI" และ "IoC บทความ Wikipediaทำงานได้ดีมากที่พยายามอธิบายว่า IoC นั้นไม่เหมือนกับ DI: inversion of control (IoC) อธิบายถึงการออกแบบที่ส่วนที่กำหนดเองของโปรแกรมคอมพิวเตอร์ได้รับการไหลของการควบคุมจากไลบรารีทั่วไปที่สามารถใช้ซ้ำได้ ดังนั้น DIP จึงเกี่ยวกับการมีโมดูลของคุณขึ้นอยู่กับ abstractions มากกว่าการใช้งานที่เป็นรูปธรรม และ IoC กำลังควบคุมการไหลของโปรแกรมของคุณไปยังโมดูลอื่น และสิ่งหนึ่งที่คุณสามารถมีโมดูลนี้คือแก้ไขการพึ่งพาที่รันไทม์ ความแตกต่างนี้ดูยุติธรรม แต่ฉันไม่เคยเห็นใครพูดถึงแอปพลิเคชันอื่น ๆ ของหลักการ IoC นอกเหนือจากการแก้ไขการพึ่งพา คำจำกัดความของ Wikipedia นั้นค่อนข้างกว้างและดูเหมือนว่าคุณสามารถทำได้มากขึ้นด้วยโมดูลที่สามารถโทรเข้ารหัสที่กำหนดเองตามการกำหนดค่าและตรรกะภายในบางอย่าง ดังนั้นนี่เป็นคำถามที่ฉันยังไม่สามารถเข้าใจได้: ความสัมพันธ์ที่แท้จริงระหว่าง IoC และกรมทรัพย์สินทางปัญญาคืออะไร? IoC ทำหน้าที่เป็นเครื่องมือในการดำเนินการของ DIP หรือไม่? …

12 design-patterns  inversion-of-control  dependency-inversion 

บทเรียนจำนวนมากเกี่ยวกับ DDD ที่ฉันศึกษาส่วนใหญ่จะครอบคลุมทฤษฎี พวกเขาทั้งหมดมีตัวอย่างรหัสพื้นฐาน (Pluralsight และคล้ายคลึงกัน) บางคนพยายามสร้างบทเรียนที่ครอบคลุม DDD ด้วย EF บนเว็บ หากคุณเริ่มศึกษาพวกเขาเพียงชั่วครู่ - คุณสังเกตได้อย่างรวดเร็วว่าพวกเขาแตกต่างกันมาก บางคนแนะนำให้แอพพลิเคชั่นมีน้อยที่สุดและเพื่อหลีกเลี่ยงการแนะนำเลเยอร์เพิ่มเติมเช่นที่เก็บข้อมูลด้านบนของ EFคนอื่น ๆ กำลังสร้างเลเยอร์เพิ่มเติมอย่างแน่นอนซึ่งมักจะละเมิด SRP ด้วยการฉีดDbContextเข้าไปใน Aggregate Roots ฉันขอโทษอย่างมากถ้าฉันถามคำถามตามความคิดเห็น แต่ ... เมื่อมาถึงการปฏิบัติ - Entity Framework เป็นหนึ่งใน ORMs ที่ทรงพลังและใช้กันอย่างแพร่หลาย คุณจะไม่พบหลักสูตรที่ครอบคลุมที่ครอบคลุม DDD ด้วยโชคไม่ดี ประเด็นสำคัญ: Entity Framework นำ UoW & Repository ( DbSet) ออกจากกล่อง รุ่นของคุณกับ EF มีคุณสมบัติการนำทาง กับ EF …

12 c#  design-patterns  object-oriented-design  domain-driven-design  entity-framework 

MVC ค่อนข้างตรงไปตรงมา มีรูปแบบตัวควบคุมและมุมมอง เมื่อเราสร้างเว็บไซต์มันทั้งหมดมารวมกันเป็น ' ไคลเอนต์ส่งคำขอคำหลัก REST ไปยังเซิร์ฟเวอร์ -> เซิร์ฟเวอร์ตรงกับ URL ที่ร้องขอไปยังการดำเนินการควบคุม -> ซึ่งจากนั้นเรียกรูปแบบ (s) สำหรับการรวบรวมข้อมูล / การประมวลผลได้รับผล -> และส่งคืนผลลัพธ์กลับไปยังลูกค้าเป็นหน้า HTML (ดู) ' ถ้าเรากำลังพูดถึง RESTful API เว็บเซอร์วิสอย่างแท้จริง จากนั้นโฟลว์ที่มีลักษณะคล้าย ' ไคลเอนต์จะส่งคำขอคำหลัก REST ไปยังเซิร์ฟเวอร์ -> เซิร์ฟเวอร์จับคู่ URL ที่ร้องขอไปยังแอ็คชั่นคอนโทรลเลอร์ -> ซึ่งจะเรียกโมเดลเพื่อรวบรวม / ประมวลผลข้อมูลรับผลลัพธ์ -> และส่งกลับ ผลลัพธ์กลับไปยังไคลเอ็นต์ใน JSON ' เหมือนเมื่อก่อน แต่ไม่มี 'มุมมอง' ... หรือมากกว่านั้น …

12 design-patterns  mvc  rest  api  api-design 

ชื่อนี้มีความหมายเกินความจริงและมันอาจเป็นความไม่ชำนาญของฉันกับรูปแบบ แต่นี่คือเหตุผลของฉัน: "ปกติ" หรือเนื้อหาที่ตรงไปตรงมาของการใช้งานเอนทิตีคือการใช้พวกเขาเป็นวัตถุและ subclassing พฤติกรรมที่พบบ่อย สิ่งนี้นำไปสู่ปัญหาแบบคลาสสิกของ "is EvilTreesubclass of Treeor Enemy?" หากเรายอมให้มีการสืบทอดหลายครั้งปัญหาเพชรจะเกิดขึ้น เราแทนสามารถดึงการทำงานรวมกันTreeและEnemyขึ้นไปลำดับชั้นซึ่งนำไปสู่การเรียนพระเจ้าหรือเราจงใจสามารถออกจากพฤติกรรมของเราTreeและEntityการเรียน (ทำให้พวกเขาเชื่อมต่อในกรณีที่รุนแรง) เพื่อให้EvilTreeสามารถดำเนินการที่ตัวเอง - ซึ่งจะนำไปสู่ SomewhatEvilTreeการทำสำเนารหัสถ้าเราเคยมี ระบบ Entity-Component พยายามที่จะแก้ปัญหานี้โดยการหารTreeและEnemyวัตถุเป็นส่วนประกอบที่แตกต่างกัน - พูดPosition, HealthและAI- และดำเนินการระบบเช่นAISystemที่มีการเปลี่ยนแปลงตำแหน่งของ Entitiy ตามการตัดสินใจของเอไอ จนถึงดีมาก แต่จะเกิดอะไรขึ้นหากEvilTreeสามารถหยิบพลังและจัดการความเสียหายได้? ก่อนอื่นเราต้องการ a CollisionSystemและ a DamageSystem(เราอาจมีสิ่งเหล่านี้อยู่แล้ว) CollisionSystemความต้องการในการสื่อสารกับDamageSystemทุกครั้งที่สองสิ่งชนCollisionSystemส่งข้อความถึงDamageSystemสุขภาพเพื่อที่จะสามารถลบ ความเสียหายยังได้รับอิทธิพลจากการเติมพลังดังนั้นเราต้องเก็บมันไว้ที่ไหนซักแห่ง เราสร้างใหม่PowerupComponentที่เราแนบกับหน่วยงาน? แต่แล้วDamageSystemจำเป็นต้องรู้เกี่ยวกับบางสิ่งบางอย่างมันค่อนข้างจะไม่รู้อะไรเลย - นอกจากนี้ยังมีบางสิ่งที่สร้างความเสียหายที่ไม่สามารถรับพลังได้ (เช่นกSpike) เราอนุญาตให้มีPowerupSystemการแก้ไข a StatComponentที่ใช้สำหรับการคำนวณความเสียหายที่คล้ายกับคำตอบนี้หรือไม่? แต่ตอนนี้ทั้งสองระบบเข้าถึงข้อมูลเดียวกัน เมื่อเกมของเรามีความซับซ้อนมากขึ้นมันจะกลายเป็นกราฟพึ่งพาไม่มีตัวตนที่องค์ประกอบร่วมกันระหว่างระบบต่างๆ ณ จุดนี้เราสามารถใช้ตัวแปรคงที่ทั่วโลกและกำจัดแผ่นเหล็กทั้งหมด มีวิธีที่มีประสิทธิภาพในการแก้ปัญหานี้หรือไม่? …

11 design-patterns  reactive  entity-component-system 

Java และ. NET มีตัวรวบรวมขยะที่ยอดเยี่ยมที่จัดการหน่วยความจำสำหรับคุณและรูปแบบที่สะดวกสำหรับการปล่อยวัตถุภายนอก ( Closeable, IDisposable) ได้อย่างรวดเร็วแต่เฉพาะในกรณีที่พวกเขาเป็นเจ้าของวัตถุเดียว ในบางระบบทรัพยากรอาจจำเป็นต้องใช้อย่างอิสระโดยสององค์ประกอบและจะได้รับการปล่อยตัวก็ต่อเมื่อทั้งสององค์ประกอบปล่อยทรัพยากร ใน C ++ ยุคใหม่คุณจะแก้ปัญหานี้ด้วย a shared_ptrซึ่งจะปล่อยทรัพยากรอย่างแน่นอนเมื่อทุกอย่างshared_ptrถูกทำลาย มีรูปแบบเอกสารที่ผ่านการพิสูจน์แล้วสำหรับการจัดการและปล่อยทรัพยากรที่มีราคาแพงซึ่งไม่มีเจ้าของคนเดียวในระบบที่รวบรวมขยะแบบไม่มุ่งเน้นวัตถุหรือไม่?

11 java  c#  design-patterns  garbage-collection  reference-counting 

เมื่อฉันพยายามสร้างส่วนต่อประสานสำหรับโปรแกรมเฉพาะฉันมักจะพยายามหลีกเลี่ยงการโยนข้อยกเว้นที่ขึ้นอยู่กับอินพุตที่ไม่ผ่านการตรวจสอบ ดังนั้นสิ่งที่มักจะเกิดขึ้นคือฉันคิดว่าโค้ดบางส่วนเช่นนี้ (นี่เป็นเพียงตัวอย่างเพื่อประโยชน์ของตัวอย่างไม่ต้องสนใจฟังก์ชั่นที่ใช้งานตัวอย่างใน Java): public static String padToEvenOriginal(int evenSize, String string) { if (evenSize % 2 == 1) { throw new IllegalArgumentException("evenSize argument is not even"); } if (string.length() >= evenSize) { return string; } StringBuilder sb = new StringBuilder(evenSize); sb.append(string); for (int i = string.length(); i < evenSize; i++) …

11 design  design-patterns  programming-practices  performance  validation 

เรามีสามชั้นในใบสมัครของเรา ชั้นบริการเพื่อให้ API ภายนอก เลเยอร์ BO สำหรับตรรกะทางธุรกิจของเราและเลเยอร์ DAO สำหรับการเชื่อมต่อฐานข้อมูลของเรา สมมติว่าทุกครั้งที่เราอัปเดตไฟล์เราต้องการเปลี่ยนบางอย่างในโฟลเดอร์เช่น 'วันที่แก้ไขล่าสุด' ต้องทำสิ่งนี้ในการทำธุรกรรม อาจประสบความสำเร็จและทั้งไฟล์และโฟลเดอร์ได้รับการแก้ไข หรือมีความล้มเหลวและธุรกรรมได้รับการย้อนกลับดังนั้นวัตถุทั้งสองอยู่ในสถานะก่อนหน้า "แก้ไขโฟลเดอร์เมื่อไฟล์ได้รับการแก้ไข" - ปฏิกิริยาเป็นตรรกะทางธุรกิจอย่างแท้จริง นี่ก็หมายความว่ามันอยู่ในเลเยอร์ BO อย่างไรก็ตามเราใช้ Objectify สำหรับฐานข้อมูลของเราดังนั้นในการเริ่มต้นธุรกรรมที่เราต้องเรียก ofy (). transact (... ) ถ้าเราเรียกใช้ฟังก์ชันนี้ในเลเยอร์ BO สิ่งนี้จะหยุดการออกแบบของเราเนื่องจากจะมีการเรียกเฉพาะฐานข้อมูล (Objectify) ในชั้นธุรกิจของเรา อะไรจะเป็นทางออกที่สะอาดสำหรับปัญหานี้

11 java  design  design-patterns  transaction 

ฉันได้รับรหัส Java เพื่อดูซึ่งจำลองการแข่งรถซึ่งรวมถึงการใช้เครื่องรัฐขั้นพื้นฐาน นี่ไม่ใช่เครื่องคำนวณทางวิทยาศาสตร์คอมพิวเตอร์แบบดั้งเดิม แต่เป็นเพียงวัตถุที่มีหลายสถานะและสามารถสลับระหว่างสถานะต่าง ๆ ตามชุดการคำนวณ เพื่ออธิบายเพียงแค่ปัญหาฉันมีคลาสรถยนต์พร้อมคลาส enum ซ้อนกันซึ่งกำหนดค่าคงที่สำหรับสถานะของรถยนต์ (เช่น OFF, IDLE, DRIVE, REVERSE และอื่น ๆ ) ภายในคลาสรถยนต์เดียวกันนี้ฉันมีฟังก์ชั่นการอัปเดตซึ่งโดยทั่วไปประกอบด้วยคำสั่งสวิตช์ขนาดใหญ่ซึ่งเปลี่ยนสถานะปัจจุบันของรถยนต์ทำการคำนวณบางอย่างและเปลี่ยนสถานะรถยนต์ เท่าที่ฉันเห็นรัฐ Cars ใช้ในชั้นเรียนของตัวเองเท่านั้น คำถามของฉันคือนี่เป็นวิธีที่ดีที่สุดในการจัดการกับการใช้งานกลไกสถานะตามธรรมชาติที่อธิบายไว้ข้างต้นหรือไม่? มันฟังดูเหมือนโซลูชันที่ชัดเจนที่สุด แต่ก่อนหน้านี้ฉันเคยได้ยินมาเสมอว่า ปัญหาหลักที่ฉันเห็นที่นี่คือคำสั่ง switch อาจมีขนาดใหญ่มากเมื่อเราเพิ่มสถานะเพิ่มเติม (ถ้าจำเป็น) และรหัสอาจไม่สะดวกและยากต่อการบำรุงรักษา อะไรจะเป็นทางออกที่ดีกว่าสำหรับปัญหานี้?

11 design  design-patterns  object-oriented  switch-statement 

ฉันพยายามทำตามหลักการ DRY ในการเขียนโปรแกรมของฉันอย่างหนักที่สุดเท่าที่จะทำได้ เมื่อไม่นานมานี้ฉันได้เรียนรู้รูปแบบการออกแบบใน OOP แล้วและฉันก็ทำซ้ำตัวเองค่อนข้างมาก ฉันสร้างรูปแบบ Repository พร้อมกับรูปแบบ Factory และ Gateway เพื่อจัดการกับความคงทนของฉัน ฉันใช้ฐานข้อมูลในแอปพลิเคชันของฉัน แต่ไม่ควรทำเช่นนี้เพราะฉันควรจะสามารถสลับเกตเวย์และเปลี่ยนไปใช้ความพยายามชนิดอื่นได้หากฉันต้องการ ปัญหาที่ฉันสร้างเพื่อตัวเองคือฉันสร้างวัตถุเดียวกันสำหรับจำนวนตารางที่ฉันมี commentsตัวอย่างเหล่านี้จะเป็นวัตถุที่ฉันต้องการที่จะจัดการกับตาราง class Comment extends Model { protected $id; protected $author; protected $text; protected $date; } class CommentFactory implements iFactory { public function createFrom(array $data) { return new Comment($data); } } class CommentGateway implements iGateway …

11 design-patterns  object-oriented  php