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

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

28 object-oriented  anti-patterns  solid 

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

28 agile  anti-patterns 

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

28 bad-code  anti-patterns  patterns-and-practices  design-patterns 

ฉันได้อ่านความคิดเห็นที่แตกต่างกันเกี่ยวกับรูปแบบซิงเกิล บางคนยืนยันว่าควรหลีกเลี่ยงค่าใช้จ่ายและอื่น ๆ ที่สามารถเป็นประโยชน์ในบางสถานการณ์ สถานการณ์หนึ่งที่ฉันใช้ singletons คือเมื่อฉันต้องการโรงงาน (สมมติว่าวัตถุประเภท f) เพื่อสร้างวัตถุของคลาส A แน่นอนโรงงานถูกสร้างขึ้นครั้งเดียวโดยใช้พารามิเตอร์การกำหนดค่าบางอย่างจากนั้นจะใช้แต่ละครั้งที่วัตถุของ พิมพ์ A ถูกสร้างขึ้น ดังนั้นทุกส่วนของรหัสที่ต้องการอินสแตนซ์ A ดึงค่าซิงเกิลตันและสร้างอินสแตนซ์ใหม่เช่น F& f = F::instance(); boost::shared_ptr<A> a = f.createA(); ดังนั้นสถานการณ์ทั่วไปของฉันก็คือ ฉันต้องการอินสแตนซ์เดียวของคลาสอย่างใดอย่างหนึ่งด้วยเหตุผลการปรับให้เหมาะสม (ฉันไม่ต้องการวัตถุหลายโรงงาน) หรือสำหรับการแบ่งปันสถานะทั่วไป (เช่นโรงงานทราบจำนวนอินสแตนซ์ของ A ที่ยังคงสามารถสร้างได้) ฉันต้องการวิธีการเข้าถึง f ของอินสแตนซ์นี้ในสถานที่ต่าง ๆ ของรหัส ฉันไม่สนใจในการอภิปรายว่ารูปแบบนี้ดีหรือไม่ดี แต่สมมติว่าฉันต้องการหลีกเลี่ยงการใช้ซิงเกิลตันฉันสามารถใช้รูปแบบอื่นแบบใดได้บ้าง แนวคิดที่ฉันมีคือ (1) นำวัตถุของโรงงานออกจากรีจิสตรีหรือ (2) เพื่อสร้างโรงงานในบางช่วงระหว่างการเริ่มต้นโปรแกรมแล้วส่งโรงงานเป็นพารามิเตอร์ ในโซลูชัน (1) ตัวรีจิสตรีนั้นเป็นซิงเกิลดังนั้นฉันเพิ่งเปลี่ยนปัญหาการไม่ใช้ซิงเกิลตันจากโรงงานไปยังรีจิสตรี ในกรณี (2) …

27 design-patterns  programming-practices  anti-patterns  singleton 

นี่เป็นกฎข้อหนึ่งที่ซ้ำแล้วซ้ำอีกและทำให้ฉันงงงวย Nulls เป็นความชั่วร้ายและควรหลีกเลี่ยงเมื่อใดก็ตามที่เป็นไปได้ แต่จากความไร้เดียงสาของฉันให้ฉันกรีดร้อง - บางครั้งคุณค่าอาจหายไปอย่างมีความหมาย! โปรดให้ฉันถามสิ่งนี้ในตัวอย่างที่มาจากรหัสที่น่ากลัวที่ต่อต้านการขี่แบบนี้ฉันกำลังทำงานอยู่ในขณะนี้ นี่คือที่หลักของมันเป็นเกมที่มีผู้เล่นหลายคนทางเว็บซึ่งผู้เล่นทั้งสองวิ่งไปพร้อมกัน (เช่นในโปเกมอนและตรงข้ามกับหมากรุก) หลังจากนั้นแต่ละครั้งเซิร์ฟเวอร์จะเผยแพร่รายการของการอัปเดตรหัส JS ฝั่งไคลเอ็นต์ ชั้นอัปเดต: public class GameUpdate { public Player player; // other stuff } คลาสนี้ได้รับการต่อเนื่องเป็น JSON และส่งไปยังผู้เล่นที่เชื่อมต่อ การอัปเดตส่วนใหญ่จะมีผู้เล่นเชื่อมโยงกับพวกเขาตามปกติ - หลังจากทั้งหมดคุณจำเป็นต้องรู้ว่าผู้เล่นคนใดที่ทำในเทิร์นนี้ อย่างไรก็ตามการอัปเดตบางอย่างไม่สามารถเชื่อมโยง Player ได้อย่างมีความหมาย ตัวอย่าง: เกมถูกบังคับเนื่องจากมีการ จำกัด การเลี้ยวโดยไม่มีการกระทำเกิน สำหรับการอัปเดตดังกล่าวฉันคิดว่ามันมีความหมายที่จะให้ผู้เล่นเป็นโมฆะ แน่นอนฉันสามารถ "แก้ไข" รหัสนี้โดยใช้การสืบทอด: public class GameUpdate { // stuff } public class …

26 anti-patterns  null 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันมี codebase ที่โปรแกรมเมอร์มักจะห่อสิ่งต่าง ๆ ในพื้นที่ที่ไม่สมเหตุสมผล ตัวอย่างเช่นให้บันทึกข้อผิดพลาดเรามีคุณสามารถเข้าสู่ระบบผ่าน ErrorLog.Log(ex, "friendly message"); เขาเพิ่มวิธีการอื่น ๆ อีกมากมายเพื่อให้งานเดียวกันนั้นสำเร็จ เช่น SomeClass.Log(ex, "friendly message"); ซึ่งจะหมุนไปรอบ ๆ และเรียกวิธีแรก สิ่งนี้จะเพิ่มระดับความซับซ้อนโดยไม่มีประโยชน์เพิ่มเติม มีรูปแบบการต่อต้านเพื่ออธิบายสิ่งนี้หรือไม่?

26 design-patterns  anti-patterns 

ฉันเห็นในจำนวนมากซอฟต์แวร์เดิมและบทเรียนที่ไม่ดีบนอินเทอร์เน็ตที่แนะนำให้ใช้exit(-1), return -1หรือคล้ายกันที่จะเป็นตัวแทน "เลิกผิดปกติ" ปัญหาคือใน POSIX อย่างน้อย-1ไม่เคยมีมาก่อนและไม่ใช่รหัสสถานะที่ถูกต้อง man 3 exitแสดงให้เห็นว่าexit()ผลตอบแทนที่คุ้มค่าของการstatus & 0377ไปยังผู้ปกครองที่มีความหมายว่าจะกลายเป็น-1 255สำหรับระบบที่ไม่ใช่ POSIX EXIT_FAILUREขอแนะนำให้พกพาได้ แต่ฉันไม่เคยเห็น "-1 หมายถึงการสิ้นสุดที่ผิดปกติ" ร่วมกับ "EXIT_FAILURE อาจเป็นสิ่งที่นอกเหนือจาก 1" ซึ่งบ่งชี้ว่าพวกเขาเชื่ออย่างชัดเจนว่า "-1" นั้นเป็นเรื่องปกติแม้ในระบบที่ไม่ใช่ POSIX ต่อไปนี้เป็นตัวอย่างของคำถาม StackOverflowที่ทำให้เกิดปัญหานี้ ซอฟต์แวร์ "unrealircd" เป็นตัวอย่างของโปรแกรมที่ใช้exit(-1)ในการยกเลิกโปรแกรม systemdในทางปฏิบัตินี้ทำให้ยากที่จะติดต่อกับ รูปแบบการต่อต้านนี้มาจากไหน มันถูกต้องในบางบริบท?

22 programming-practices  c  history  anti-patterns 

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

21 anti-patterns  comments 

ฉันมักจะเผชิญหน้ากับผู้ช่วยหรือใช้คลาสใน Java หรือภาษาอะไรก็ได้ ดังนั้นฉันจึงถามตัวเองว่านี่เป็น Anti Pattern หรือไม่และการมีอยู่ของคลาสเหล่านี้เป็นเพียงการขาดการออกแบบและสถาปัตยกรรมของซอฟต์แวร์ บ่อยครั้งที่คลาสเหล่านี้ถูก จำกัด ด้วยวิธีการคงที่ซึ่งทำสิ่งต่างๆมากมาย แต่ส่วนใหญ่มันแน่นอนขึ้นอยู่กับบริบทและรัฐเต็ม คำถามของฉันคืออะไรความคิดเห็นของคุณเกี่ยวกับประเภทของผู้ช่วยคงที่ / ใช้ประโยชน์เช่นชั้นเรียนเพราะข้อได้เปรียบแน่นอนว่าการร้องขออย่างรวดเร็วโดยใช้เพียงชื่อชั้นเรียน แล้วคุณจะหลีกเลี่ยงการใช้คลาสประเภทนี้ในระดับใด ในความคิดของฉันคำหลัก "คงที่" ควรได้รับอนุญาตภายในการประกาศของคลาส (Java) และไม่ได้สำหรับวิธีการ ในความคิดของฉันคือการใช้วิธีนี้อาจเป็นทางเลือกที่ดีและตรงกลางเพื่อให้สามารถรวม Procuedural- และ OO-Paradigms ใน Java และหลีกเลี่ยงการใช้คำหลักที่ผิดพลาด เพิ่มเติมเนื่องจากคำตอบ: ตอนแรกฉันคิดว่ามันถูกกฎหมายอย่างสมบูรณ์เพื่อให้สามารถรวมกระบวนทัศน์ที่แตกต่างกันและแม้กระทั่งใช้ภาษาสคริปต์ตีความตีความรันไทม์ภายในเครื่องหรือรหัสที่รวบรวม vm ประสบการณ์ของฉันคือระหว่างกระบวนการพัฒนาโครงการผู้ช่วยเหลือและสิ่งของประเภทนั้นหรืออะไรก็ตามที่ชื่อกำลังเติบโตและเติบโตและใช้ในทุกมุมที่ลืมของ codebase ซึ่ง แต่เดิมได้รับการออกแบบให้เป็นแบบแยกส่วนและยืดหยุ่น และเนื่องจากไม่มีเวลาที่จะทำการปรับโครงสร้างใหม่หรือคิดเกี่ยวกับการออกแบบอีกครั้งคุณเพียงแค่ทำให้มันแย่ลงในช่วงเวลานั้น ฉันคิดว่าstaticควรถูกลบออกจาก Java โดยเฉพาะอย่างยิ่งตอนนี้ที่เป็นไปได้ที่จะใช้องค์ประกอบภาษาที่ซับซ้อนยิ่งขึ้น

19 design-patterns  anti-patterns  static 

ฉันพบว่าตัวเองมักจะค้นหาคำถามออนไลน์และวิธีแก้ปัญหาหลายอย่างรวมถึงพจนานุกรม อย่างไรก็ตามเมื่อใดก็ตามที่ฉันพยายามที่จะใช้พวกเขาฉันได้กลิ่นที่น่ากลัวนี้ในรหัสของฉัน เช่นทุกครั้งที่ฉันต้องการใช้ค่า: int x; if (dict.TryGetValue("key", out x)) { DoSomethingWith(x); } นั่นคือโค้ด 4 บรรทัดที่จะทำสิ่งต่อไปนี้: DoSomethingWith(dict["key"]) ฉันได้ยินมาว่าการใช้คีย์เวิร์ด out เป็นรูปแบบการต่อต้านเพราะทำให้ฟังก์ชั่นกลายพันธุ์พารามิเตอร์ของพวกเขา นอกจากนี้ฉันพบว่าตัวเองมักต้องการพจนานุกรม "กลับด้าน" ที่ฉันพลิกคีย์และค่าต่างๆ ในทำนองเดียวกันฉันมักจะทำซ้ำผ่านรายการในพจนานุกรมและพบว่าตนเองกำลังแปลงคีย์หรือค่าไปยังรายการ ฯลฯ เพื่อทำสิ่งนี้ให้ดีขึ้น ฉันรู้สึกว่ามีวิธีการใช้พจนานุกรมที่ดีกว่าและสง่างามกว่าอยู่เกือบตลอดเวลา แต่ฉันรู้สึกแย่

19 c#  anti-patterns  code-smell  dictionary  out-parameters 

WebApplication ของเราคือการใช้เพื่อแมข้อยกเว้นบางประการExceptionMapper Responseเราบันทึกข้อความข้อยกเว้นก่อนที่จะส่งข้อยกเว้นใหม่ดังนี้: catch (SomeException ex) { LOG.error(ex.getMessage()); throw new MyException(ex.getMessage()); } เราจะไม่ได้อีกครั้งการขว้างปายกเว้นเดียวกันดังนั้นคำถามของฉันคือถ้าเรื่องนี้จะได้รับการพิจารณาเข้าสู่ระบบและโยน antipattern และจะเป็นการดีกว่าถ้าจะลบการบันทึกในสถานที่ที่คล้ายกันและย้ายไปยังExceptionMapperคลาสต่างๆดังนี้: @Provider public class MyExceptionMapper implements ExceptionMapper<MyException> { // bla bla @Override public Response toResponse(final MyException ex) { LOG.error(ex.getMessage()); return Response.status(400).entity("something").build(); } }

18 java  anti-patterns 

บทความ TDWTF วันนี้เริ่มต้นด้วยคำสารภาพจากผู้แต่ง: ฉันไม่ทราบว่ารูปแบบการต่อต้าน For-Case นั้นเป็นอย่างไรจนกระทั่งเมื่อไม่นานมานี้เมื่อมีบทความที่ประณามว่าเป็นรูปแบบการต่อต้าน ฉันแน่ใจว่าฉันอาจจะใช้มันในบางจุด แต่ฉันไม่เคยรู้ว่ามันโดยชื่อ มันคิดว่าเป็น antipattern ตำราเรียนที่โดยทั่วไปหมายถึงความเข้าใจผิดของการวนรอบคำสั่งกรณีปัญหาการแก้ไขหรือการรวมกันของทั้งสาม จากนั้นเขาก็ดำเนินการราวกับว่าผู้อ่านโดยธรรมชาติรู้ว่าสิ่งที่ต่อต้านรูปแบบกรณีเป็นโดยไม่ต้องอธิบายเพิ่มเติมใด ๆ แต่ฉันทำไม่ได้! ฉันไม่ได้เห็น "น้ำท่วมของบทความ" ที่ Remy พูดถึงและการอ้างอิงที่สำคัญเท่านั้นที่ฉันสามารถหาได้ใน Google (นอกเหนือจากบทความของ Remy) คือโพสต์บล็อกโดย Raymond Chenเกี่ยวกับantipattern for-ifซึ่งเห็นได้ชัดว่าเกี่ยวข้อง . เขาไม่ได้กำหนด "รูปแบบการต่อต้านกรณี" เช่นกัน "รูปแบบการต่อต้านกรณี" คืออะไรที่คนพวกนี้พูดถึงและอะไรที่ทำให้เป็นรูปแบบการต่อต้าน?

17 anti-patterns 

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

17 design-patterns  anti-patterns  loops 

ฉันอ่านเกี่ยวกับรหัสที่พบบ่อยมีกลิ่นในหนังสือ Refactoring Martin Fowler ของ ในบริบทนั้นฉันสงสัยเกี่ยวกับรูปแบบที่ฉันเห็นในฐานรหัสและไม่มีใครสามารถคิดว่ามันเป็นรูปแบบการต่อต้าน รูปแบบเป็นสิ่งหนึ่งที่วัตถุถูกส่งผ่านเป็นอาร์กิวเมนต์หนึ่งหรือหลายวิธีซึ่งทั้งหมดนี้เปลี่ยนสถานะของวัตถุ แต่ไม่มีใครกลับวัตถุ ดังนั้นจึงขึ้นอยู่กับการส่งผ่านโดยอ้างอิงธรรมชาติของ (ในกรณีนี้) C # /. NET var something = new Thing(); // ... Foo(something); int result = Bar(something, 42); Baz(something); ฉันพบว่า (โดยเฉพาะอย่างยิ่งเมื่อวิธีการไม่ได้ตั้งชื่ออย่างเหมาะสม) ฉันต้องมองหาวิธีการดังกล่าวเพื่อทำความเข้าใจว่าสถานะของวัตถุมีการเปลี่ยนแปลง มันทำให้เข้าใจรหัสมากขึ้นเนื่องจากฉันต้องการติดตาม call-stack หลายระดับ ฉันต้องการเสนอให้ปรับปรุงโค้ดดังกล่าวเพื่อส่งคืนออบเจ็กต์อื่น (โคลน) ด้วยสถานะใหม่หรืออะไรก็ตามที่จำเป็นในการเปลี่ยนออบเจ็กต์ที่ไซต์การโทร var something1 = new Thing(); // ... // Let's return a new instance …

17 code-smell  anti-patterns  parameters 

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

17 unit-testing  anti-patterns  unit-test-data