เหตุใด C # จึงใช้วิธีการไม่ใช่เสมือนโดยค่าเริ่มต้น

ต่างจาก Java เหตุใด C # จึงถือว่าเมธอดไม่ใช่ฟังก์ชันเสมือนตามค่าเริ่มต้น มีแนวโน้มที่จะเป็นปัญหาด้านประสิทธิภาพมากกว่าผลลัพธ์ที่เป็นไปได้อื่น ๆ หรือไม่?

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

ชั้นเรียนควรได้รับการออกแบบมาเพื่อการสืบทอดเพื่อให้สามารถใช้ประโยชน์จากมันได้ การมีวิธีการvirtualโดยค่าเริ่มต้นหมายความว่าทุกฟังก์ชันในคลาสสามารถเสียบออกและแทนที่ด้วยฟังก์ชันอื่นได้ซึ่งไม่ใช่สิ่งที่ดีจริงๆ หลายคนเชื่อว่าชั้นเรียนควรจะเป็นไปsealedโดยปริยาย

virtualวิธีการยังสามารถมีผลกระทบเล็กน้อย อย่างไรก็ตามนี่ไม่น่าจะเป็นเหตุผลหลัก

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

เหตุผลส่วนใหญ่อ่านให้ฉันฟังเหมือนข้อโต้แย้ง "ถ้าเราให้พลังคุณอาจทำร้ายตัวเอง" จากโปรแกรมเมอร์?!

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

จำนวนครั้งที่ฉันต้องเขียนโค้ดที่น่าเกลียดและหมดหวัง (หรือละทิ้งการใช้งานและม้วนโซลูชันทางเลือกของฉันเอง) เพราะฉันไม่สามารถลบล้างได้ไกลเกินดุลจำนวนครั้งที่ฉันเคยถูกกัด ( เช่นใน Java) โดยการลบล้างจุดที่นักออกแบบอาจไม่ได้คิดว่าฉันทำได้

การไม่เสมือนโดยค่าเริ่มต้นทำให้ชีวิตของฉันยากขึ้น

UPDATE:มีการชี้ให้เห็น [ค่อนข้างถูกต้อง] ว่าฉันไม่ได้ตอบคำถามจริงๆ ดังนั้น - และขออภัยที่ค่อนข้างช้า ....

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

อย่างไรก็ตามฉันตระหนักดีว่าฉันแค่แสดงความคิดเห็นของฉันไม่ใช่คำตอบที่ชัดเจนที่ Stack Overflow ต้องการ แน่นอนฉันคิดว่าในระดับสูงสุดคำตอบที่ชัดเจน (แต่ไม่เป็นประโยชน์) คือ:

โดยค่าเริ่มต้นจะไม่เสมือนจริงเนื่องจากนักออกแบบภาษามีการตัดสินใจและนั่นคือสิ่งที่พวกเขาเลือก

ตอนนี้ฉันเดาเหตุผลที่แน่นอนที่พวกเขาตัดสินใจว่าเราจะไม่ .... โอ้รอ! บันทึกการสนทนา!

ดังนั้นดูเหมือนว่าคำตอบและความคิดเห็นที่นี่เกี่ยวกับอันตรายของการลบล้าง API และความจำเป็นในการออกแบบอย่างชัดเจนสำหรับการสืบทอดอยู่ในแนวทางที่ถูกต้อง แต่ทั้งหมดขาดแง่มุมที่สำคัญไปชั่วขณะ: ข้อกังวลหลักของ Anders คือการรักษาโดยนัยของคลาสหรือ API สัญญาข้ามรุ่น และฉันคิดว่าเขากังวลมากขึ้นเกี่ยวกับการอนุญาตให้แพลตฟอร์ม. Net / C # เปลี่ยนแปลงภายใต้รหัสแทนที่จะกังวลเกี่ยวกับการเปลี่ยนรหัสผู้ใช้ที่ด้านบนของแพลตฟอร์ม (และมุมมอง "เชิงปฏิบัติ" ของเขาตรงข้ามกับของฉันเพราะเขามองจากอีกด้านหนึ่ง)

(แต่เป็นไปได้ไหมที่พวกเขาเลือกเสมือนโดยค่าเริ่มต้นจากนั้นจึงเพิ่ม "ขั้นสุดท้าย" ผ่าน codebase บางทีมันอาจจะไม่เหมือนกันนัก .. และ Anders ฉลาดกว่าฉันอย่างชัดเจนดังนั้นฉันจะปล่อยให้มันโกหก)

เพราะมันง่ายเกินไปที่จะลืมว่าเมธอดอาจถูกแทนที่และไม่ได้ออกแบบมาเพื่อสิ่งนั้น C # ทำให้คุณคิดก่อนที่จะทำให้มันเสมือนจริง ฉันคิดว่านี่เป็นการตัดสินใจในการออกแบบที่ยอดเยี่ยม บางคน (เช่น Jon Skeet) ได้กล่าวว่าชั้นเรียนควรถูกปิดผนึกโดยค่าเริ่มต้น

เพื่อสรุปสิ่งที่คนอื่นพูดมีสาเหตุสองสามประการ:

1-ใน C # มีหลายสิ่งในไวยากรณ์และความหมายที่มาจาก C ++ โดยตรง ความจริงที่ว่าวิธีการที่ไม่เสมือนโดยค่าเริ่มต้นใน C ++ มีอิทธิพลต่อ C #

2-การมีทุกวิธีเสมือนโดยค่าเริ่มต้นเป็นปัญหาด้านประสิทธิภาพเนื่องจากการเรียกใช้เมธอดทุกครั้งต้องใช้ตารางเสมือนของวัตถุ ยิ่งไปกว่านั้นสิ่งนี้จำกัดความสามารถของคอมไพเลอร์ Just-In-Time อย่างมากในการอินไลน์เมธอดและทำการเพิ่มประสิทธิภาพประเภทอื่น ๆ

3- ที่สำคัญที่สุดคือหากวิธีการไม่ใช่เสมือนโดยค่าเริ่มต้นคุณสามารถรับประกันพฤติกรรมของชั้นเรียนของคุณได้ เมื่อเป็นเสมือนโดยค่าเริ่มต้นเช่นใน Java คุณไม่สามารถรับประกันได้ว่าวิธี getter แบบธรรมดาจะทำตามที่ตั้งใจไว้เนื่องจากอาจถูกแทนที่เพื่อทำอะไรก็ได้ในคลาสที่ได้รับ (แน่นอนว่าคุณทำได้และควรทำ วิธีการและ / หรือคลาสสุดท้าย)

บางคนอาจสงสัยดังที่ Zifre กล่าวถึงเหตุใดภาษา C # จึงไม่ก้าวไปอีกขั้นและทำให้ชั้นเรียนถูกปิดผนึกโดยค่าเริ่มต้น นั่นเป็นส่วนหนึ่งของการถกเถียงทั้งหมดเกี่ยวกับปัญหาของการสืบทอดการนำไปใช้ซึ่งเป็นหัวข้อที่น่าสนใจมาก

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

ปัญหาด้านประสิทธิภาพไม่ใช่เรื่องง่ายที่จะพูดว่า "ใช่" หรือ "ไม่" กับ เหตุผลนี้คือการคอมไพล์ Just In Time (JIT) ซึ่งเป็นการเพิ่มประสิทธิภาพรันไทม์ใน C #

อีกคำถามที่คล้ายกันเกี่ยวกับ " ความเร็วของการโทรเสมือน .. "

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

ด้วยวิธีการที่ไม่ใช่เสมือนคุณสามารถควบคุมได้ทั้งหมด สิ่งใดผิดพลาดเป็นความผิดของผู้เขียนต้นฉบับ รหัสนั้นง่ายกว่ามากในการให้เหตุผล

หากวิธีการ C # ทั้งหมดเป็นเสมือน vtbl จะใหญ่กว่ามาก

อ็อบเจ็กต์ C # มีเมธอดเสมือนหากคลาสมีการกำหนดเมธอดเสมือน เป็นความจริงที่ว่าอ็อบเจ็กต์ทั้งหมดมีข้อมูลประเภทที่มีค่าเทียบเท่า vtbl แต่หากไม่มีการกำหนดเมธอดเสมือนจะมีเพียงเมธอดของอ็อบเจ็กต์พื้นฐานเท่านั้น

@ Tom Hawtin: น่าจะถูกต้องกว่าที่จะบอกว่า C ++, C # และ Java ล้วนมาจากภาษาตระกูล C :)

มาจากพื้นหลัง perl ฉันคิดว่า C # ปิดผนึกการลงโทษของนักพัฒนาทุกคนที่อาจต้องการขยายและปรับเปลี่ยนพฤติกรรมของคลาสพื้นฐานผ่านวิธีการที่ไม่ใช่เสมือนโดยไม่บังคับให้ผู้ใช้ทุกคนในคลาสใหม่ตระหนักถึงเบื้องหลังที่อาจเกิดขึ้น รายละเอียด.

พิจารณาวิธีการเพิ่มคลาส List จะเป็นอย่างไรหากนักพัฒนาต้องการอัปเดตฐานข้อมูลที่เป็นไปได้หลายฐานข้อมูลเมื่อใดก็ตามที่รายการใดรายการหนึ่งถูก 'เพิ่ม' หาก 'เพิ่ม' เป็นเสมือนโดยค่าเริ่มต้นนักพัฒนาสามารถพัฒนาคลาส 'BackedList' ที่ลบล้างเมธอด 'เพิ่ม' ได้โดยไม่ต้องบังคับให้รหัสไคลเอนต์ทั้งหมดรู้ว่าเป็น 'BackedList' แทนที่จะเป็น 'รายการ' ปกติ สำหรับวัตถุประสงค์ในทางปฏิบัติทั้งหมด 'BackedList' สามารถดูเป็นเพียง 'รายการ' อื่นจากรหัสไคลเอนต์

สิ่งนี้สมเหตุสมผลจากมุมมองของคลาสหลักขนาดใหญ่ซึ่งอาจให้การเข้าถึงคอมโพเนนต์รายการอย่างน้อยหนึ่งรายการซึ่งตัวเองได้รับการสนับสนุนโดยสคีมาอย่างน้อยหนึ่งรายการในฐานข้อมูล เนื่องจากวิธีการ C # ไม่ใช่เสมือนโดยค่าเริ่มต้นรายการที่จัดเตรียมโดยคลาสหลักจึงไม่สามารถเป็น IEnumerable หรือ ICollection หรือแม้แต่อินสแตนซ์ List ได้ แต่ต้องโฆษณาให้ไคลเอ็นต์เป็น 'BackedList' แทนเพื่อให้แน่ใจว่าเวอร์ชันใหม่ ของการดำเนินการ "เพิ่ม" ถูกเรียกให้อัปเดตสคีมาที่ถูกต้อง

ไม่ใช่ปัญหาด้านประสิทธิภาพอย่างแน่นอน ล่าม Java ของ Sun ใช้รหัสเดียวกันในการส่ง ( invokevirtualbytecode) และ HotSpot จะสร้างรหัสเดียวกันfinalทุกประการไม่ว่าจะเป็นหรือไม่ก็ตาม ฉันเชื่อว่าอ็อบเจ็กต์ C # ทั้งหมด (แต่ไม่ใช่โครงสร้าง) มีเมธอดเสมือนดังนั้นคุณจะต้องมีการvtblระบุคลาส / รันไทม์เสมอ C # เป็นภาษาถิ่นของ "ภาษาที่เหมือน Java" เพื่อแนะนำว่ามาจาก C ++ นั้นไม่ตรงไปตรงมาอย่างสิ้นเชิง

มีความคิดว่าคุณควร "ออกแบบเพื่อการสืบทอดหรือห้ามมิฉะนั้น" ซึ่งดูเหมือนจะเป็นความคิดที่ดีในขณะที่คุณมีกรณีทางธุรกิจที่รุนแรงที่จะต้องแก้ไขอย่างรวดเร็ว บางทีอาจสืบทอดมาจากรหัสที่คุณไม่ได้ควบคุม