विधि अधिभार संकल्प

Question

मैं दूसरे दिन यह देखा, कहते हैं कि तुम दो अतिभारित तरीकों:

public void Print<T>(IEnumerable<T> items) { 
    Console.WriteLine("IEnumerable T"); 
} 
public void Print<T>(T item) { 
    Console.WriteLine("Single T"); 
} 

इस कोड:

public void TestMethod() { 
    var persons = new[] { 
     new Person { Name = "Yan", Age = 28 }, 
     new Person { Name = "Yinan", Age = 28 } 
    }; 
    Print(persons); 
    Print(persons.ToList()); 
} 

प्रिंट:

Single T 
Single T 

Person[] और List<Person>T से बेहतर मिलान क्यों हैं इन मामलों में IEnumerable<T> से वे हैं?

धन्यवाद,

अद्यतन: इसके अलावा, अगर आप एक और अधिभार है

public void Print<T>(List<T> items) { 
    Console.WriteLine("List T"); 
} 

Print(persons.ToList()); वास्तव में List T बजाय Single T प्रिंट होगा।

Answer 1

आपके प्रश्न का पहला भाग (सूची-विशिष्ट अधिभार के बिना) आसान है। आइए ऐरे कॉल पर विचार करें, क्योंकि यह दोनों कॉलों के लिए समान काम करता है:

सबसे पहले, टाइप करें कॉल कॉल के दो संभावित जेनेरिक कार्यान्वयन का उत्पादन करता है: Print<Person[]>(Person[] items) और Print<Person>(IEnumerable<Person> items)।

फिर ओवरलोड रिज़ॉल्यूशन में शामिल होता है और पहला जीतता है, क्योंकि दूसरे को एक अंतर्निहित रूपांतरण की आवश्यकता होती है, जहां पहला व्यक्ति नहीं करता है (सी # spec के §7.4.2.3 देखें)। सूची तंत्र के लिए एक ही तंत्र काम करता है।

अतिरिक्त अधिभार के साथ, सूची कॉल के साथ तीसरा संभव अधिभार उत्पन्न होता है: Print<Person>(List<Person> items)। तर्क Print<List<Person>>(List<Person> items) लेकिन फिर से साथ के रूप में एक ही है, खंड 7.4.3.2 भाषा

रिकर्सिवली साथ संकल्प, एक का निर्माण प्रकार एक और निर्माण प्रकार की तुलना में अधिक विशिष्ट है (प्रकार तर्कों की एक ही नंबर के साथ) अगर प्रदान करता है कम से कम एक प्रकार का तर्क अधिक विशिष्ट होता है और किसी प्रकार का तर्क दूसरे में संबंधित प्रकार तर्क के मुकाबले कम विशिष्ट नहीं होता है।

तो Print<Person> अधिभार Print<List<Person>> अधिभार की तुलना में अधिक विशिष्ट है और सूची संस्करण IEnumerable से अधिक जीतता है, क्योंकि इसमें कोई अंतर्निहित रूपांतरण की आवश्यकता है।

Answer 2

जेनरिक Print(Person[] item) और Print(List<Person> item) से उत्पन्न विधियां IEnumerable<T> से बेहतर मिलान हैं।

संकलक, अपने प्रकार तर्क के आधार पर उन तरीकों पैदा तो सामान्य टेम्प्लेट Print<T>(T item)Print(Person[] item) और Print(List<Person> item) (संकलन पर एक List<Person> अच्छी तरह से, जो कुछ भी प्रकार का प्रतिनिधित्व करता है) के रूप में संकलित किया जाएगा है। इसके कारण, विधि कॉल को संकलक द्वारा विशिष्ट विधि के रूप में हल किया जाएगा जो प्रत्यक्ष प्रकार को स्वीकार करता है, Print(IEnumerable<Peson>) के कार्यान्वयन पर नहीं।