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

ฉันมีสามคลาสที่เป็นแบบวงกลมขึ้นอยู่กับซึ่งกันและกัน: TestExecuter ดำเนินการตามคำขอของ TestScenario และบันทึกไฟล์รายงานโดยใช้คลาส ReportGenerator ดังนั้น: TestExecuter ขึ้นอยู่กับ ReportGenerator เพื่อสร้างรายงาน ReportGenerator ขึ้นอยู่กับ TestScenario และพารามิเตอร์ที่กำหนดจาก TestExecuter TestScenario ขึ้นอยู่กับ TestExecuter ไม่สามารถหาวิธีที่จะลบการอ้างอิงเหล่านั้นได้ public class TestExecuter { ReportGenerator reportGenerator; public void getReportGenerator() { reportGenerator = ReportGenerator.getInstance(); reportGenerator.setParams(this.params); /* this.params several parameters from TestExecuter class example this.owner */ } public void setTestScenario (TestScenario ts) …

33 design  object-oriented-design  circular-dependency  dependency-analysis 

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

32 design 

ในการเขียนโปรแกรมสิ่งที่เรียกว่า Principle of Least ประหลาดใจ? แนวคิดนี้เกี่ยวข้องกับการออกแบบ API ที่ดีอย่างไร สิ่งนี้ใช้ได้กับการเขียนโปรแกรมเชิงวัตถุเท่านั้นหรือมันซึมซาบเทคนิคการเขียนโปรแกรมอื่น ๆ ด้วยหรือไม่ สิ่งนี้เกี่ยวข้องกับหลักการ "ทำสิ่งเดียวในวิธีการของคุณและทำได้ดีหรือไม่"?

32 design  design-patterns  object-oriented 

ฉันต้องเขียนผู้จัดการระบบการแจ้งเตือน นี่คือข้อกำหนดของฉัน: ฉันต้องสามารถส่งการแจ้งเตือนบนแพลตฟอร์มที่แตกต่างกันซึ่งอาจแตกต่างกันโดยสิ้นเชิง (สำหรับตัวอย่างฉันต้องสามารถส่ง SMS หรืออีเมลได้) บางครั้งการแจ้งเตือนอาจเหมือนกันสำหรับผู้รับทุกคนสำหรับแพลตฟอร์มที่กำหนด แต่บางครั้งอาจเป็นการแจ้งเตือนต่อผู้รับ (หรือหลายคน) ต่อแพลตฟอร์ม การแจ้งเตือนแต่ละครั้งสามารถมีส่วนของข้อมูลเฉพาะแพลตฟอร์มได้ (สำหรับตัวอย่าง MMS ที่มีเสียงหรือภาพ) ระบบจำเป็นต้องปรับขนาดได้ฉันต้องสามารถส่งการแจ้งเตือนจำนวนมากโดยไม่ต้องหยุดทำงานทั้งแอปพลิเคชันหรือเซิร์ฟเวอร์ มันเป็นกระบวนการสองขั้นตอนแรกที่ลูกค้าอาจพิมพ์ข้อความและเลือกแพลตฟอร์มที่จะส่งไปและควรสร้างการแจ้งเตือนเพื่อประมวลผลแบบเรียลไทม์ในภายหลัง จากนั้นระบบจะต้องส่งการแจ้งเตือนไปยังผู้ให้บริการแพลตฟอร์ม สำหรับตอนนี้ฉันจบลงด้วยบางอย่าง แต่ฉันไม่รู้ว่ามันจะปรับขนาดได้หรือถ้ามันเป็นการออกแบบที่ดี ฉันว่าวัตถุต่อไปนี้ (ในภาษาเทียม): Notificationวัตถุทั่วไป: class Notification { String $message; Payload $payload; Collection<Recipient> $recipients; } ปัญหาเกี่ยวกับวัตถุต่อไปนี้จะเกิดอะไรขึ้นถ้าฉันมีผู้รับ 1,000,000? แม้ว่าRecipientวัตถุนั้นจะเล็กมากมันก็จะใช้หน่วยความจำมากเกินไป ฉันสามารถสร้างการแจ้งเตือนได้หนึ่งรายการต่อผู้รับ แต่ผู้ให้บริการแพลตฟอร์มบางรายกำหนดให้ฉันส่งเป็นชุดซึ่งหมายความว่าฉันต้องกำหนดหนึ่งการแจ้งเตือนที่มีผู้รับหลายคน การแจ้งเตือนที่สร้างขึ้นแต่ละครั้งสามารถเก็บไว้ในที่เก็บข้อมูลถาวรเช่น DB หรือ Redis มันจะเป็นการดีหรือไม่ที่จะรวมกันในภายหลังเพื่อให้แน่ใจว่าสามารถปรับขนาดได้หรือไม่? ในขั้นตอนที่สองฉันต้องดำเนินการการแจ้งเตือนนี้ แต่ฉันจะแยกแยะการแจ้งเตือนกับผู้ให้บริการแพลตฟอร์มที่เหมาะสมได้อย่างไร ฉันควรใช้วัตถุเช่นMMSNotificationขยายabstract Notificationหรือไม่ หรือสิ่งที่ต้องการNotification.setType('MMS')? เพื่อให้สามารถประมวลผลการแจ้งเตือนจำนวนมากในเวลาเดียวกันฉันคิดว่าระบบคิวการส่งข้อความเช่น RabbitMQ อาจเป็นเครื่องมือที่เหมาะสม …

32 design  architecture  performance  object-oriented-design  scalability 

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

32 design 

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

32 design  design-patterns  architecture 

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

31 design  design-patterns  builder-pattern 

อัลกอริทึมการค้นหาแบบไบนารีดั้งเดิมใน JDK ใช้จำนวนเต็ม 32 บิตและมีข้อบกพร่องมากเกินไปหาก(low + high) > INT_MAX( http://googleresearch.blogspot.com/2006/06/extra-extra-extra-read-all-about-it-nearly.html ) . หากเราเขียนอัลกอริทึมการค้นหาแบบไบนารี่เดียวกันโดยใช้ (ลงนาม) 64- บิตเราสามารถสันนิษฐานได้ว่าlow + highจะไม่เกิน INT64_MAX เพราะเป็นไปไม่ได้ที่ร่างกายจะมีหน่วยความจำ 10 ^ 18 ไบท์หรือไม่ เมื่อใช้ (ลงนาม) จำนวนเต็ม 64- บิตเพื่อแสดงปริมาณทางกายภาพมันมีเหตุผลที่จะถือว่าอันเดอร์โฟล์และล้นไม่สามารถเกิดขึ้นได้?

31 design  algorithms 

ดังที่ฉันเข้าใจการออกแบบจากบนลงล่างคือการปรับแนวคิดระดับสูงที่เป็นนามธรรมลงในคอนกรีตขนาดเล็กและชิ้นส่วนที่เข้าใจได้จนกว่าจะมีการกำหนด Building Block ที่เล็กที่สุด ในขณะที่ล่างขึ้นบนจะกำหนดส่วนที่ต่ำจากนั้นค่อย ๆ สร้างบล็อกระดับที่สูงขึ้นจนกว่าระบบทั้งหมดจะเกิดขึ้น ในทางปฏิบัติได้มีการกล่าวที่ดีที่สุดในการรวมสองวิธี: เริ่มต้นด้วยข้อกำหนดระดับสูงเพื่อระบุความรู้โดเมนความสัมพันธ์และข้อ จำกัด เมื่อเข้าใจปัญหาได้แล้วจะมีการสร้าง Building Block ที่เล็กที่สุดเพื่อสร้างระบบ กระบวนการของ: การสร้างสเป็คความต้องการ สร้างข้อกำหนดการออกแบบ (พร้อมไดอะแกรม) Implement ส่งมอบ ทำซ้ำ (ในการพัฒนาซ้ำ ๆ แทนที่จะทำทั้งก้อนในแต่ละขั้นตอนเราทำกันเล็กน้อยซ้ำแล้วซ้ำอีกและมีการประชุมประจำวันเพื่อปรับให้เข้ากับความต้องการแบบไดนามิกของลูกค้า) ดูเป็นเรื่องปกติสำหรับฉัน (โดยมีรายละเอียดตามแผน) มันมีข้อบกพร่อง แต่นั่นคือสาเหตุที่เราได้รับการพัฒนาซ้ำ: แทนที่จะใช้เวลาในเฟสเดียวกล่าวว่าการวิเคราะห์ความต้องการเพื่อศึกษาทุกสิ่งที่เป็นไปได้ในความรู้ด้านโดเมนซึ่งอาจมีการเปลี่ยนแปลง (อาจเป็นรายวัน) เราทำการวิเคราะห์เล็กน้อย การออกแบบนิดหน่อยแล้วใช้มัน อีกวิธีคือการทำซ้ำแต่ละครั้งเป็นแบบ mini-waterfall ซึ่งจะทำการวิเคราะห์ในสองสามวัน (หรือหนึ่งสัปดาห์) เช่นเดียวกับการออกแบบ เวลาที่เหลือจะถูกนำไปใช้ในการดำเนินการ มีบางอย่างผิดปกติกับวิธีการจากบนลงล่างร่วมกับการพัฒนาแบบวนซ้ำหรือไม่? ในการเขียนโปรแกรมเรียงความของเขาBottom Upดูเหมือนว่า Paul Graham จะสนับสนุนการสร้างจากล่างขึ้นบนอย่างสมบูรณ์หรือตั้งโปรแกรมจากล่างขึ้นบน แต่ไม่ใช่ช่วงการวิเคราะห์ความต้องการ / การออกแบบ: โปรแกรมเมอร์ Lisp ที่มีประสบการณ์แบ่งโปรแกรมต่างกันออกไป …

31 design  c++  lisp 

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

31 design  architecture  development-process 

ตรงไปตรงมาสวย ฉันกำลังใช้อินเทอร์เฟซ แต่มีคุณสมบัติหนึ่งที่ไม่จำเป็นสำหรับคลาสนี้และอันที่จริงแล้วไม่ควรใช้ แนวคิดแรกของฉันคือทำสิ่งที่ชอบ: int IFoo.Bar { get { raise new NotImplementedException(); } } ฉันคิดว่าไม่มีอะไรผิดปกติกับเรื่องนี้ แต่มันก็ไม่รู้สึก "ถูก" มีใครเคยเจอสถานการณ์ที่คล้ายกันมาก่อนหรือไม่ ถ้าเป็นเช่นนั้นคุณเข้าหามันได้อย่างไร?

31 c#  design  interfaces  implementations 

Userสมมติว่าสำหรับตัวอย่างเช่นคุณมีการประยุกต์ใช้กับการเรียนร่วมกันอย่างกว้างขวางเรียกว่า คลาสนี้จะเปิดเผยข้อมูลทั้งหมดเกี่ยวกับผู้ใช้ ID ชื่อระดับการเข้าถึงแต่ละโมดูลเขตเวลา ฯลฯ ข้อมูลผู้ใช้นั้นถูกอ้างอิงอย่างกว้างขวางทั่วทั้งระบบ แต่ไม่ว่าจะด้วยเหตุผลใดก็ตามระบบได้รับการตั้งค่าเพื่อให้แทนที่จะส่งผู้ใช้วัตถุนี้ไปยังคลาสที่ขึ้นอยู่กับว่าเรากำลังส่งผ่านคุณสมบัติของแต่ละบุคคล คลาสที่ต้องการ ID ผู้ใช้เพียงแค่ต้องการ GUID userIdเป็นพารามิเตอร์บางครั้งเราอาจต้องการชื่อผู้ใช้ด้วยดังนั้นจะถูกส่งผ่านเป็นพารามิเตอร์แยกต่างหาก ในบางกรณีสิ่งนี้จะถูกส่งไปยังแต่ละวิธีดังนั้นค่าจะไม่ถูกเก็บไว้ที่ระดับชั้นเลย ทุกครั้งที่ฉันต้องการเข้าถึงข้อมูลที่แตกต่างจากคลาสผู้ใช้ฉันต้องทำการเปลี่ยนแปลงโดยการเพิ่มพารามิเตอร์และเมื่อการเพิ่มโอเวอร์โหลดใหม่ไม่เหมาะสมฉันต้องเปลี่ยนการอ้างอิงถึงเมธอดหรือตัวสร้างคลาสทุกครั้ง ผู้ใช้เป็นเพียงตัวอย่างเดียว นี่คือการฝึกฝนอย่างกว้างขวางในรหัสของเรา ฉันคิดถูกไหมว่านี่เป็นการละเมิดหลักการเปิด / ปิด? ไม่ใช่แค่การเปลี่ยนคลาสที่มีอยู่ แต่ตั้งค่าไว้ตั้งแต่แรกเพื่อให้การเปลี่ยนแปลงอย่างกว้างขวางมีความเป็นไปได้สูงที่จะเป็นสิ่งจำเป็นในอนาคต? ถ้าเราเพิ่งผ่านไปใน Userวัตถุฉันสามารถเปลี่ยนแปลงชั้นเรียนเล็ก ๆ ที่ฉันทำงานด้วยได้ ถ้าฉันต้องเพิ่มพารามิเตอร์ฉันอาจต้องทำการเปลี่ยนแปลงหลายสิบครั้งเพื่ออ้างอิงไปยังคลาส มีหลักการอื่นใดที่ผิดไปจากการฝึกฝนนี้หรือไม่? การผกผันของการพึ่งพาอาจจะ? แม้ว่าเราจะไม่ได้อ้างถึงสิ่งที่เป็นนามธรรม แต่ก็มีผู้ใช้เพียงประเภทเดียวดังนั้นจึงไม่จำเป็นต้องมีอินเทอร์เฟซผู้ใช้ มีการละเมิดหลักการอื่น ๆ ที่ไม่ใช่แบบแข็งเช่นหลักการตั้งโปรแกรมการป้องกันขั้นพื้นฐานหรือไม่? ตัวสร้างของฉันควรมีลักษณะเช่นนี้: MyConstructor(GUID userid, String username) หรือสิ่งนี้: MyConstructor(User theUser) โพสต์แก้ไข: มีคนแนะนำว่าคำถามนั้นตอบใน "รหัสผ่านหรือวัตถุ?" สิ่งนี้ไม่ได้ตอบคำถามว่าการตัดสินใจไปทางใดมีผลต่อความพยายามในการปฏิบัติตามหลักการของ SOLID ซึ่งเป็นหัวใจหลักของคำถามนี้

30 java  c#  design  solid 

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

30 design  communication  design-decisions 

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

30 design  object-oriented  functional-programming 

สมมติว่าฉันมีไฟล์foo.pyที่มีคลาสFoo: class Foo(object): def __init__(self, data): ... ตอนนี้ฉันต้องการเพิ่มฟังก์ชั่นที่สร้างFooวัตถุในวิธีที่แน่นอนจากแหล่งข้อมูลดิบ ฉันควรวางมันเป็นวิธีการคงที่ใน Foo หรือเป็นฟังก์ชั่นอื่นที่แยกจากกันหรือไม่? class Foo(object): def __init__(self, data): ... # option 1: @staticmethod def fromSourceData(sourceData): return Foo(processData(sourceData)) # option 2: def makeFoo(sourceData): return Foo(processData(sourceData)) ฉันไม่รู้ว่าการอำนวยความสะดวกให้กับผู้ใช้สำคัญกว่าหรือไม่: foo1 = foo.makeFoo(sourceData) หรือไม่ว่าจะสำคัญกว่าหรือไม่ในการรักษาคัปปลิ้งที่ชัดเจนระหว่างเมธอดและคลาส: foo1 = foo.Foo.fromSourceData(sourceData)

30 design  python