सी # इंटरफ़ेस <T> {टी समारोह <T> (टी टी);}: जेनेरिक वापसी प्रकार

Question

मैंने सोचा कि मैं कुछ का उपयोग करेंगे के साथ Parameterized तरीके से जेनेरिक इंटरफ़ेस (मैं क्या सोचा था) सरल जेनरिक कुछ व्यापार वर्ग पर CRUD लागू करने के लिए। उदाहरण के लिए।

public interface IReadable <T> 
{ 
    T Read<T>(string ID); 
} 

और फिर शायद, मैं नोट वर्ग जैसे के साथ सी आर यूडी करने के लिए एक NoteAdapter हो सकता था।

public class NoteAdapter : IReadable<Note> 
{ 
    public Note Read<Note>(string ID) { 
     return new Note(); 
    } 
} 

लेकिन किसी कारण से, अगर मैं दोनों एक सामान्य वापसी प्रकार और एक समारोह में एक ही सामान्य प्रकार के साथ पैरामिट्रीकृत है ते संकलक भ्रमित हो रही है। यही है, अगर मैं करता हूं:

public interface IReadable <T> 
{ 
    void Read<T>(string ID); 
} 
public class NoteAdapter : IReadable<Note> 
{ 
    public void Read<Note>(string ID) { 
     return new Note(); 
    } 
} 

यह ठीक संकलित करता है, हालांकि यह ऐसा नहीं करता है जो मैं चाहता हूं! इसके अलावा, इस:

public interface IReadable <T> 
{ 
    T Read (string ID); 
} 
public class NoteAdapter : IReadable<Note> 
{ 
    public Note Read(string ID) { 
     return new Note(); 
    } 
} 

रूप में अच्छी तरह ठीक काम करता है, हालांकि यह भी आवश्यकताओं संतुष्ट नहीं करता! -- क्यूं कर ? क्योंकि तब मेरे पास एक कक्षा नहीं हो सकती है जो इन इंटरफेस का एक गुच्छा लागू करे ..eg।

public interface IReadable <T>{ 
    T Read (string ID); 
} 
public class UniversalAdapter : IReadable<Note>, IReadable<Customer> ... 
{ 
    public Note Read(string ID) { 
     return new Note(); 
    } 
    public Customer Read(string ID) { 
     return new Customer(); 
    } 
} 

कोज़ यह संकलित नहीं होगा क्योंकि रिटर्न प्रकार विधियों के हस्ताक्षर का हिस्सा नहीं हैं!

मैं यह धारणा थी, सी # में 3,5 +

T Foo(T t); 
T Foo<T> (T t); 
T Foo(<SomeType> someInstance); 

सभी अलग हस्ताक्षर है! मुझे यहां क्या समझ नहीं आ रहा है ?

Answer 1

आपने इंटरफ़ेस को ओवरस्फीस्ड किया है। आप इंटरफ़ेस परिभाषा T घोषित है, लेकिन फिर आप redeclare यह विधि की परिभाषा में:

public interface IReadable <T> /* T is declared here */ 
{ 
    T Read<T>(string ID); /* here, you've declare a NEW generic type parameter */ 
          /* that makes this T not the same as the T in IReadable */ 
} 

इस भ्रम के कारण, आप ऊपर एक त्रुटि के साथ समाप्त जब आप इंटरफ़ेस को लागू करने का प्रयास करें।

public class NoteAdapter : IReadable<Note> /* IReadable defines T to be Note */ 
{ 
    public Note Read<Note>(string ID) { /* Here, you're declaring a generic parameter */ 
             /* named Note. This name then conflicts with */ 
             /* the existing type name Note */ 
     return new Note(); 
    } 
} 

इसे ठीक करने के लिए, आप बस Read समारोह से सामान्य पैरामीटर दूर करने के लिए, दोनों इंटरफ़ेस में की जरूरत है, और NoteAdapter कक्षा में:

public interface IReadable <T> 
{ 
    T Read(string ID); 
} 
public class NoteAdapter : IReadable<Note> 
{ 
    public Note Read(string ID) { 
     return new Note(); 
    } 
} 

संपादित करें:

ठीक है, मैंने आपकी बाकी पोस्ट पढ़ी है, और ऐसा लगता है कि आप पहले ही खोज चुके हैं कि यह "काम करता है", लेकिन आपको लगता है कि यह गलत है। क्यूं कर? यह क्या आवश्यकताओं को पूरा नहीं करता है?

Answer 2

public interface IReadable <T> { T Read<T>(string ID); }

यहाँ वास्तव में दो अलग-अलग टी: IReadable <T> and T Read<T>(string ID)

शायद सिर्फ

public interface IReadable <T> { T Read(string ID); }?

क्योंकि अन्यथा करने के लिए

public interface IReadable <T> { X Read<X>(string ID); }

Good Generics tutorial

संपादित बराबर है:

हो सकता है आप public interface IReadable <T> { T Read(T ID); } की ज़रूरत है?

Answer 3

सीआईएल does not support वापसी प्रकार द्वारा विधि अधिभार।