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

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

553 design-patterns  dependency-injection  anti-patterns  caching 

สถานการณ์ เมื่อเช้านี้ฉันตอบคำถามใน StackOverflow คำถาม: การแก้ไขวัตถุที่มีอยู่ควรทำในพื้นที่เก็บข้อมูลเลเยอร์หรือบริการ? ตัวอย่างเช่นถ้าฉันมีผู้ใช้ที่มีหนี้ ฉันต้องการเปลี่ยนหนี้ของเขา ฉันควรทำมันใน UserRepository หรือในการให้บริการเช่น BuyingService โดยรับวัตถุแก้ไขและบันทึกมันได้หรือไม่ คำตอบของฉัน: คุณควรปล่อยให้ความรับผิดชอบในการกลายวัตถุเป็นวัตถุเดียวกันนั้นและใช้ที่เก็บเพื่อดึงข้อมูลวัตถุนี้ สถานการณ์ตัวอย่าง: class User { private int debt; // debt in cents private string name; // getters public void makePayment(int cents){ debt -= cents; } } class UserRepository { public User GetUserByName(string name){ // Get appropriate user …

397 design-patterns  layers 

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

328 design-patterns  state  globals 

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

243 design-patterns  coding-standards  interfaces 

ฉันกำลังพิจารณาที่จะสร้างแอปพลิเคชั่นซึ่งที่หลักของมันจะประกอบไปด้วยหาก ... แล้ว ... งบอื่น วัตถุประสงค์ของแอปพลิเคชั่นนี้คือเพื่อให้สามารถทำนายได้ว่าวัวเคลื่อนไปรอบ ๆ ในแนวนอนใด พวกเขาได้รับผลกระทบจากสิ่งต่าง ๆ เช่นดวงอาทิตย์ลมแหล่งอาหารเหตุการณ์ฉับพลัน ฯลฯ แอปพลิเคชันดังกล่าวสามารถจัดการได้อย่างไร? ฉันจินตนาการว่าหลังจากสองสามร้อยประโยค IF มันจะดีเท่าที่คาดเดาไม่ได้ว่าโปรแกรมจะตอบสนองและดีบั๊กอะไรที่นำไปสู่ปฏิกิริยาบางอย่างจะหมายความว่าเราจะต้องสำรวจต้นไม้คำสั่ง IF ทั้งหมดทุกครั้ง ฉันได้อ่านนิดหน่อยเกี่ยวกับเอ็นจิ้นกฎ แต่ฉันไม่เห็นว่าพวกเขาจะรับมือกับความซับซ้อนนี้ได้อย่างไร

214 design  design-patterns  business-rules  prolog  logic-programming 

ฉันอ่านหนังสือชื่อClean Codeของ Robert C. Martin แล้ว ในหนังสือเล่มนี้ฉันได้เห็นวิธีการมากมายในการทำความสะอาดโค้ดเช่นการเขียนฟังก์ชั่นเล็ก ๆ การเลือกชื่ออย่างระมัดระวัง ฯลฯ ดูเหมือนว่าหนังสือที่น่าสนใจที่สุดเกี่ยวกับรหัสที่ฉันอ่าน อย่างไรก็ตามวันนี้เจ้านายของฉันไม่ชอบวิธีที่ฉันเขียนโค้ดหลังจากอ่านหนังสือเล่มนี้ ข้อโต้แย้งของเขาคือ การเขียนฟังก์ชั่นเล็ก ๆ เป็นความเจ็บปวดเพราะมันบังคับให้คุณย้ายเข้าไปในฟังก์ชั่นเล็ก ๆ แต่ละอันเพื่อดูว่าโค้ดกำลังทำอะไรอยู่ ใส่ทุกอย่างไว้ในลูปหลักหลักแม้ว่าลูปหลักจะมีมากกว่า 300 บรรทัดมันจะอ่านเร็วขึ้น เขียนฟังก์ชั่นเล็ก ๆ เท่านั้นหากคุณต้องทำซ้ำรหัส อย่าเขียนฟังก์ชั่นที่มีชื่อของความคิดเห็นใส่รหัสบรรทัดที่ซับซ้อนของคุณ (3-4 บรรทัด) ด้วยความคิดเห็นด้านบน คุณสามารถแก้ไขโค้ดที่ล้มเหลวได้เช่นเดียวกัน สิ่งนี้ขัดต่อทุกสิ่งที่ฉันอ่าน ปกติคุณเขียนรหัสได้อย่างไร หนึ่งวงใหญ่หลักไม่มีฟังก์ชั่นเล็ก ๆ ? ภาษาที่ฉันใช้ส่วนใหญ่เป็นจาวาสคริปต์ ตอนนี้ฉันมีปัญหาในการอ่านเนื่องจากฉันได้ลบฟังก์ชั่นที่ตั้งชื่อไว้อย่างชัดเจนแล้วนำทุกอย่างมารวมกันเป็นวงใหญ่ อย่างไรก็ตามเจ้านายของฉันชอบวิธีนี้ ตัวอย่างหนึ่งคือ: // The way I would write it if (isApplicationInProduction(headers)) { phoneNumber = …

209 design-patterns  refactoring  clean-code  functions 

ฉันพยายามหาทางเลือกในการใช้ตัวแปรทั่วโลกในรหัสดั้งเดิม แต่คำถามนี้ไม่เกี่ยวกับทางเลือกทางเทคนิคผมส่วนใหญ่กังวลเกี่ยวกับคำศัพท์ ทางออกที่ชัดเจนคือการส่งผ่านพารามิเตอร์เข้าสู่ฟังก์ชั่นแทนที่จะใช้โกลบอล ใน codebase ดั้งเดิมนี้หมายความว่าฉันต้องเปลี่ยนฟังก์ชั่นทั้งหมดในสายโซ่ยาวระหว่างจุดที่จะใช้ค่าในที่สุดและฟังก์ชั่นที่ได้รับพารามิเตอร์ก่อน higherlevel(newParam)->level1(newParam)->level2(newParam)->level3(newParam) newParamก่อนหน้านี้ซึ่งเคยเป็นตัวแปรทั่วโลกในตัวอย่างของฉัน แต่มันอาจเป็นค่าฮาร์ดโค้ดที่ก่อนหน้านี้แทน ประเด็นก็คือว่าตอนนี้ค่าของ newParam จะได้รับที่higherlevel()และมีการ "เดินทาง" level3()ทุกวิธีการ ฉันสงสัยว่ามีชื่อ (s)สำหรับสถานการณ์ / รูปแบบเช่นนี้ซึ่งคุณต้องเพิ่มพารามิเตอร์ในฟังก์ชั่นมากมายที่เพียงแค่ "ส่ง" ค่าที่ไม่เปลี่ยนแปลง หวังว่าการใช้คำศัพท์ที่เหมาะสมจะช่วยให้ฉันค้นหาทรัพยากรเพิ่มเติมเกี่ยวกับโซลูชันสำหรับการออกแบบใหม่และอธิบายสถานการณ์นี้ให้เพื่อนร่วมงานทราบ

209 design-patterns  terminology  anti-patterns  parameters  globals 

ฉันเป็นนักพัฒนารุ่นน้องในรุ่นพี่และกำลังดิ้นรนมากกับการเข้าใจความคิดเหตุผล ฉันกำลังอ่านการออกแบบที่ขับเคลื่อนด้วยโดเมน (DDD) และไม่เข้าใจว่าทำไมเราต้องสร้างคลาสจำนวนมาก ถ้าเราทำตามวิธีการออกแบบซอฟต์แวร์เราจะจบด้วยชั้นเรียน 20-30 ชั้นซึ่งสามารถแทนที่ได้ด้วยไฟล์มากที่สุดสองไฟล์และฟังก์ชั่น 3-4 อย่าง ใช่มันอาจยุ่งเหยิง แต่มันสามารถดูแลและอ่านได้มากกว่า เมื่อใดก็ตามที่ฉันต้องการดูว่าบางอย่างEntityTransformationServiceImplทำอะไรฉันต้องติดตามคลาสอินเทอร์เฟซการเรียกใช้ฟังก์ชันการสร้างการสร้างและอื่น ๆ มากมาย คณิตศาสตร์ง่าย ๆ : รหัสจำลอง 60 บรรทัดเทียบกับ 10 คลาส X 10 (สมมติว่าเรามี logics ที่แตกต่างกันโดยสิ้นเชิง) = 600 บรรทัดของรหัสยุ่งกับ 100 ชั้นเรียน + อีกมากมายที่จะรวมและจัดการ อย่าลืมเพิ่มการฉีดพึ่งพา อ่านรหัสยุ่ง 600 เส้น = หนึ่งวัน 100 คลาส = หนึ่งสัปดาห์ยังคงลืมว่าหนึ่งจะทำอะไรเมื่อ ทุกคนบอกว่าง่ายต่อการบำรุงรักษา แต่เพื่ออะไร ทุกครั้งที่คุณเพิ่มฟังก์ชันการทำงานใหม่คุณจะเพิ่มคลาสอีกห้าคลาสด้วยโรงงานหน่วยงานบริการและค่านิยม ฉันรู้สึกว่ารหัสประเภทนี้เคลื่อนที่ช้ากว่ารหัสที่ยุ่งเหยิงมาก สมมติว่าถ้าคุณเขียนรหัสยุ่ง 50K …

209 design-patterns  domain-driven-design  source-code 

มันเป็นความคิดที่ฉันได้ยินซ้ำแล้วซ้ำอีกในหลาย ๆ ที่ บางคนยอมรับมากหรือน้อยว่าเมื่อพยายามแก้ปัญหาอย่างหมดจดใน SQL เกินระดับความซับซ้อนคุณควรจะจัดการมันในรหัส เหตุผลเบื้องหลังแนวคิดนี้ก็คือในกรณีส่วนใหญ่เอ็นจิ้นฐานข้อมูลจะทำงานได้ดีขึ้นในการค้นหาวิธีที่มีประสิทธิภาพสูงสุดในการทำงานให้สำเร็จมากกว่าที่คุณคิดในโค้ด โดยเฉพาะอย่างยิ่งเมื่อพูดถึงสิ่งต่าง ๆ เช่นการทำให้ผลลัพธ์มีเงื่อนไขในการดำเนินการกับข้อมูล เนื้อหาที่มีเครื่องยนต์ที่ทันสมัยอย่างมีประสิทธิภาพ JIT'ing + แคชรุ่นที่รวบรวมคำค้นหาของคุณมันจะทำให้รู้สึกบนพื้นผิว คำถามคือการใช้ประโยชน์จากเอนจินฐานข้อมูลของคุณด้วยวิธีนี้หรือไม่นั้นเป็นวิธีปฏิบัติที่ไม่ดีในการออกแบบ (และสาเหตุ) เส้นจะเบลอมากขึ้นเมื่อตรรกะทั้งหมดอยู่ในฐานข้อมูลและคุณเพียงแค่กดผ่าน ORM

204 design-patterns  sql 

ในฐานะโปรแกรมเมอร์ที่จริงจังคุณจะตอบคำถามMVC คืออะไรได้อย่างไร ในใจของฉัน MVC เป็นหัวข้อที่คลุมเครือและด้วยเหตุนี้หากผู้ชมของคุณเป็นผู้เรียนดังนั้นคุณสามารถอธิบายได้ในแง่ทั่วไปที่ไม่น่าจะเป็นข้อโต้แย้ง อย่างไรก็ตามหากคุณกำลังพูดคุยกับผู้ชมที่มีความรู้โดยเฉพาะผู้สัมภาษณ์ฉันมีความลำบากในการคิดทิศทางที่จะไม่เสี่ยงกับปฏิกิริยาของ "ดีไม่ถูกต้อง! ... " เราทุกคนมีประสบการณ์ในโลกแห่งความเป็นจริงที่แตกต่างกันและฉันก็ไม่ได้พบกับรูปแบบการใช้ MVC เดียวกันสองครั้ง โดยเฉพาะดูเหมือนว่าจะมีข้อขัดแย้งเกี่ยวกับความเข้มงวดคำจำกัดความส่วนประกอบการแยกชิ้นส่วน (ชิ้นส่วนใดที่เหมาะกับที่) ฯลฯ ดังนั้นฉันจะอธิบาย MVCในวิธีที่ถูกต้องกระชับและไม่ขัดแย้งได้อย่างไร

202 design-patterns  mvc  definition 

ฉันได้เห็นประวัติของโครงการห้องสมุดคลาสС # และ Java หลายรายการบน GitHub และ CodePlex และฉันเห็นแนวโน้มของการเปลี่ยนไปใช้คลาสของโรงงานซึ่งต่างจากการอินสแตนซ์วัตถุโดยตรง เหตุใดฉันจึงควรใช้คลาสของโรงงานอย่างกว้างขวาง ฉันมีห้องสมุดที่ค่อนข้างดีที่ซึ่งวัตถุต่าง ๆ ถูกสร้างขึ้นในแบบสมัยเก่า - โดยการเรียกใช้คลาสก่อสร้างสาธารณะ ในช่วงสุดท้ายผู้เขียนได้ทำการเปลี่ยนแปลงอย่างรวดเร็วของการสร้างสาธารณะทั้งหมดของหลายพันชั้นเรียนเป็นภายในและยังสร้างชั้นโรงงานขนาดใหญ่ที่มีCreateXXXวิธีการคงที่หลายพันที่เพียงแค่ส่งคืนวัตถุใหม่โดยการเรียกตัวสร้างภายในของชั้นเรียน API โครงการภายนอกใช้งานไม่ได้ เหตุใดการเปลี่ยนแปลงเช่นนี้จึงมีประโยชน์ อะไรคือประเด็นของการปรับโครงสร้างด้วยวิธีนี้ ประโยชน์ของการแทนที่การเรียกไปยังตัวสร้างคลาสสาธารณะด้วยการเรียกใช้เมธอดสแตติกจากโรงงานคืออะไร? ฉันควรใช้ช่างก่อสร้างสาธารณะเมื่อใดและฉันควรใช้โรงงานเมื่อใด

162 design-patterns  refactoring  constructors  factory 

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

151 design-patterns  api-design  legacy  bad-code 

นับตั้งแต่ครั้งแรกที่ผมได้เรียนรู้เกี่ยวกับแก๊งสี่ (GoF) รูปแบบการออกแบบอย่างน้อย 10 ปีที่ผ่านมาฉันมีความประทับใจที่เหล่านี้ 23 รูปแบบที่ควรจะเป็นเพียงตัวอย่างเล็ก ๆ ของสิ่งที่มีขนาดใหญ่มากซึ่งผมชอบที่จะเรียกพื้นที่รูปแบบ Pattern Spaceสมมุตินี้ประกอบด้วยโซลูชันที่แนะนำทั้งหมด (รู้จักหรือไม่รู้จัก) สำหรับปัญหาการออกแบบซอฟต์แวร์เชิงวัตถุทั่วไป ดังนั้นฉันจึงคาดว่าจำนวนของรูปแบบการออกแบบที่เป็นที่รู้จักและจัดทำเอกสารจะเพิ่มขึ้นอย่างมีนัยสำคัญ มันไม่ได้เกิดขึ้น มากกว่า 20 ปีหลังจากหนังสือ GoF ออกมามีเพียง 12 รูปแบบเพิ่มเติมที่ปรากฏในบทความ Wikipedia ซึ่งส่วนใหญ่เป็นที่นิยมน้อยกว่าต้นฉบับมาก (ฉันไม่ได้รวมรูปแบบการทำงานพร้อมกันที่นี่เพราะครอบคลุมหัวข้อเฉพาะ) อะไรคือเหตุผล? ชุดรูปแบบของ GoF จริง ๆ แล้วครอบคลุมกว่าที่ฉันคิดหรือไม่ ความสนใจในการหารูปแบบใหม่ลดลงหรืออาจเป็นเพราะพวกเขาพบว่าไม่ใช่ทุกสิ่งที่มีประโยชน์ในการออกแบบซอฟต์แวร์? อื่น ๆ อีก?

144 design-patterns  object-oriented-design 

ฉันได้พูดคุยกับหนึ่งในนักพัฒนาอาวุโสของเราที่อยู่ในธุรกิจมา 20 ปี เขาเป็นที่รู้จักกันดีในออนแทรีโอสำหรับบล็อกที่เขาเขียน สิ่งที่แปลกคือสิ่งที่เขาบอกฉัน: เขาบอกว่ามีชิ้นส่วนของรหัสที่เป็นฝันร้ายที่จะทำงานด้วยเพราะมันถูกเขียนจากตำราเรียนและไม่ได้คำนึงถึงโลกแห่งความจริง การเพิ่มฟิลด์ใหม่ลงใน UI / ฐานข้อมูล / ชั้นข้อมูลใช้เวลา 2-3 ชั่วโมงในการทำขณะที่รหัสของเขาใช้เวลา 30 นาที อีกสิ่งหนึ่งก็คือเขาหลีกเลี่ยงรูปแบบการออกแบบเพราะโปรแกรมเมอร์ส่วนใหญ่ไม่เข้าใจพวกเขาและพวกเขาไม่เก่งในด้านการบำรุงรักษา นอกจากนี้ยังมีแนวคิดที่ว่านักพัฒนาเว็บส่วนใหญ่ในแคนาดาต้องการให้ตัวแบบข้อมูลของพวกเขาสืบทอดมาจากคลาส Data Layer แทนที่จะทำให้มันโดดเดี่ยว ฉันถามเขาว่า "มันเป็นมาตรฐานอุตสาหกรรมหรือไม่ที่จะแยกโมเดลออกจากชั้นข้อมูล?" เขาพูดบางครั้ง แต่คนส่วนใหญ่ที่นี่ไม่ชอบทำเพราะมันทำงานมากเกินไป ดูเหมือนว่าเหตุผลของเขาที่ไม่เข้ารหัสโดยใช้วิธีปฏิบัติที่ดีที่สุดคือเพราะมันเป็นฝันร้ายการบำรุงรักษาพนักงานของเราสองคนเข้าใจ (นอกเหนือจากตัวฉันเอง) และทำงานช้าถ้าคุณต้องการผลักดันฟีเจอร์หรือฟิลด์ใหม่ ๆ ในเวลาไม่กี่วัน เวลา. มันแปลกมากที่ได้ยินความเห็นเช่นนี้เนื่องจาก Stack Overflow สนับสนุนให้คนส่วนใหญ่ปฏิบัติตามมาตรฐานอุตสาหกรรม ปัญหาที่เราถูกบังคับให้ต้องทำการเปลี่ยนแปลงฟิลด์และฟีเจอร์ใหม่ ๆ ในเวลาไม่กี่วันหรือไม่ซึ่งเป็นไปไม่ได้ที่จะสรุปรูปแบบที่มั่นคงที่ยืดหยุ่นเพียงพอหรือไม่ นั่นดูเหมือนจะเป็นส่วนสำคัญของสิ่งที่ฉันเข้าใจจากเรื่องนี้ คุณทำอะไรกับข้อความเหล่านี้?

135 design-patterns  industry-standard 

ฉันกำลังมองหาคำแนะนำที่นี่ ฉันกำลังดิ้นรนกับว่ามันจะดีกว่าที่จะกลับเป็นโมฆะหรือค่าที่ว่างเปล่าจากวิธีการเมื่อไม่มีค่าตอบแทนหรือไม่สามารถหาได้ ใช้สองวิธีต่อไปนี้เป็นตัวอย่าง: string ReverseString(string stringToReverse) // takes a string and reverses it. Person FindPerson(int personID) // finds a Person with a matching personID. ในReverseString()ฉันจะพูดกลับสตริงที่ว่างเปล่าเพราะประเภทกลับเป็นสตริงดังนั้นผู้โทรคาดหวังว่า ด้วยวิธีนี้ผู้โทรจะไม่ต้องตรวจสอบเพื่อดูว่ากลับเป็นโมฆะ ในการFindPerson()คืนค่า NULL ดูเหมือนว่าเหมาะสมดีกว่า ไม่ว่า NULL หรือวัตถุ Person ว่างเปล่า ( new Person()) จะถูกส่งคืนหรือไม่ผู้โทรจะต้องตรวจสอบเพื่อดูว่าวัตถุบุคคลนั้นว่างเปล่าหรือว่างเปล่าก่อนที่จะทำอะไรกับมัน (เช่นการโทรUpdateName()) ดังนั้นทำไมไม่เพียงแค่ส่งคืนค่า NULL ที่นี่จากนั้นผู้โทรต้องตรวจสอบค่า NULL เท่านั้น ใครบ้างที่ต่อสู้กับสิ่งนี้? ความช่วยเหลือหรือข้อมูลเชิงลึกใด ๆ ที่ชื่นชม

135 object-oriented  design-patterns  architecture  object-oriented-design