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

สมมติว่าฉันมีวิธี public List<User> GetBatchOfUsers(IEnumerable<int> userIDs) { List<User> users = new List<User>(); // some database stuff return users; } ฉันได้อ่านว่ามันจะดีกว่าที่จะกลับมาอินเตอร์เฟซ (อย่างใดอย่างหนึ่งIListหรือIEnumerable) Listเมื่อเทียบกับกลับ ข้อโต้แย้งบางประการที่ฉันเคยได้ยินเกี่ยวกับการทำเช่นนั้นคือมันซ่อนข้อมูลและให้ความยืดหยุ่นแก่นักพัฒนา API ในการเปลี่ยนการแสดงข้อมูลภายในในภายหลัง ความกังวลของฉันเกี่ยวกับการส่งคืนIEnumerableคือคุณสูญเสียฟังก์ชันการทำงานเช่นการเข้าถึงแบบสุ่มและCountคุณสมบัติ ฉันรู้ว่าการยอมรับIEnumerableพารามิเตอร์เป็นสิ่งที่สมเหตุสมผลเนื่องจากทำให้ผู้บริโภคมีความยืดหยุ่นที่ดีที่สุดในการส่งข้อมูลไปยังวิธีการของฉันซึ่งเป็นข้อกำหนดที่เรียบง่ายสำหรับวิธีการใช้งาน แนวปฏิบัติที่ดีที่สุดสำหรับประเภทส่งคืนคืออะไร

9 c#  interfaces  class 

ฉันคิดว่าฉันเข้าใจข้อ จำกัด ที่แท้จริงของการรวบรวมความแตกต่างของเวลาและความหลากหลายของเวลาทำงาน แต่อะไรคือความแตกต่างทางแนวคิดระหว่างอินเตอร์เฟสที่ชัดเจน (polymorphism แบบรันไทม์คือฟังก์ชันเสมือนและพอยน์เตอร์ / การอ้างอิง) และอินเทอร์เฟซโดยปริยาย (polymorphism เวลาคอมไพล์เช่น . ความคิดของฉันคือวัตถุสองชิ้นที่มีส่วนต่อประสานที่ชัดเจนเหมือนกันจะต้องเป็นวัตถุประเภทเดียวกัน (หรือมีบรรพบุรุษร่วมกัน) ในขณะที่วัตถุสองชิ้นที่มีส่วนต่อประสานแบบเดียวกันนั้นไม่จำเป็นต้องเป็นวัตถุชนิดเดียวกัน อินเทอร์เฟซที่พวกเขาทั้งสองเสนอสามารถมีฟังก์ชันการทำงานที่แตกต่างกันมาก ความคิดใด ๆ เกี่ยวกับเรื่องนี้? และหากวัตถุสองชิ้นมีอินเตอร์เฟสแบบนัยเดียวกันเหตุผลอะไร (ข้างๆประโยชน์ทางเทคนิคของการไม่ต้องใช้การส่งข้อมูลแบบไดนามิกที่มีตารางการค้นหาฟังก์ชั่นเสมือน ฯลฯ ) จะไม่มีวัตถุเหล่านี้สืบทอดมาจากวัตถุพื้นฐานที่ประกาศอินเตอร์เฟสนั้น ทำให้เป็นอินเทอร์เฟซที่ชัดเจนหรือไม่ อีกวิธีในการบอกว่า: คุณสามารถให้กรณีที่วัตถุสองอย่างที่เสนออินเทอร์เฟซแบบเดียวกัน (และสามารถใช้เป็นชนิดของคลาสเทมเพลตตัวอย่าง) ไม่ควรสืบทอดมาจากคลาสพื้นฐานที่ทำให้อินเทอร์เฟซนั้นชัดเจน? บางโพสต์ที่เกี่ยวข้อง: https://stackoverflow.com/a/7264550/635125 https://stackoverflow.com/a/7264689/635125 https://stackoverflow.com/a/8009872/635125 นี่คือตัวอย่างที่จะทำให้คำถามนี้เป็นรูปธรรมมากขึ้น: การเชื่อมต่อโดยนัย: class Class1 { public: void interfaceFunc(); void otherFunc1(); }; class Class2 { public: void interfaceFunc(); …

9 templates  interfaces  polymorphism  duck-typing  explicit 

เป้าหมายของฉันคือการกำหนดสัญญาระหว่างชั้นเรียน ฉันชอบการพิมพ์เป็ดและทั้งหมด แต่ฉันต้องการกำหนดอินเทอร์เฟซระหว่างเลเยอร์ต่าง ๆ ของแอปพลิเคชันของฉันเพื่อกำหนดอย่างชัดเจนซึ่งเป็นวิธีการโทรจากภายนอกและเป็นวิธีการเสริมที่เลเยอร์อื่นไม่ควรใช้ . ตัวอย่างเช่นใน Java ฉันสามารถกำหนดอินเตอร์เฟส Persistor ด้วยวิธีการเช่น get () และ save () จากนั้นกำหนดคลาส JdbcPersistor ด้วยวิธีการทั้งหมดที่ฉันต้องการเพื่อคงอยู่ในฐานข้อมูล และบางที RestPersistor อีกอันที่มีวิธีการอื่นสำหรับการบันทึกใน restserver ระยะไกล ฉันไม่ได้ขออินเทอร์เฟซใน Ruby เพียงเพื่อให้รู้ว่ามีวิธีที่เป็นระเบียบจะทำให้ความแตกต่างนี้หรือไม่ ฉันชอบทับทิม แต่ฉันทำงานเฉพาะในโครงการขนาดเล็กเท่านั้น

9 ruby  dynamic-typing  interfaces