जेनरिक की सूची बनाएं

Question

मैं अपने संस्थाओं के लिए आधार वर्ग है

public class Entity<T> where T : Entity<T>, new() 
{ 
    public XElement ToXElement() 
    { 
    } 
    public static T FromXElement(XElement x) 
    { 
    } 
} 

क्योंकि मैं स्थिर विधि FromXElement भी दृढ़ता से टाइप किए जाने की चाहते मैं, यह अजीब निर्माण Entity<T> where T : Entity<T> उपयोग करने के लिए है, मैं, कुछ संस्थाओं है की तरह कि

public class Category : Entity<Category> 
{ 
} 
public class Collection : Entity<Collection> 
{ 
} 

मैं बेस क्लास का उपयोग करके अपनी संस्थाओं की सामान्य सूची कैसे बना सकता हूं?

var list = new List<Entity<?>>(); 
list.Add(new Category()); 
list.Add(new Collection()); 

Answer 1

आप उस परिभाषा के साथ नहीं कर सकते हैं। Category और Collection (object के अलावा) के बीच कोई "सामान्य आधार वर्ग" नहीं है।

अगर वहाँ थे, कहते हैं अगर Entity<T> रूप में परिभाषित किया गया:

public class Entity 
{ 
} 

public class Entity<T> : Entity where T : Entity<T>, new() 
{ 
    public XElement ToXElement() 
    { 
    } 
    public static T FromXElement(XElement x) 
    { 
    } 
} 

तो आप

var list = new List<Entity>(); 
list.Add(new Category()); 
list.Add(new Collection()); 

कर सकता है लेकिन क्या है कि आप खरीदना चाहेंगे?

Answer 2

आप सभी इकाई वर्गों

public class Entity 
{ 
} 

और इकाई के वारिस इकाई

public class Entity<T> : Entity where T : Entity<T>, new() 
{ 
} 

अब आप के रूप में संस्थाओं की सूची बना सकते हैं बनाने के आधार वर्ग होने के लिए एक गैर सामान्य वर्ग को परिभाषित कर सकते हैं :

var list = new List<Entity>(); 

Answer 3

आप इस पी को हल कर सकते हैं तब

var list = new List<Entity>() 
list.Add(new Cathegory()); 

,, यदि आप एक "सामान्य विशिष्ट" आपरेशन कॉल करना चाहते हैं: वर्ग के एक गैर जेनेरिक वर्जन जोड़कर roblem

class Entity 
{ 
    // methods 

    public T As<T>() 
    { 
    if (this is T) return (T)this; 
    throw new InvalidCastException(); 
    } 
} 

class Entity<T> : Entity where T : Entity<T>, new() 

class Cathegory : Entity<T> {} 

और फिर आधार वर्ग की सूची बनाने के "As" फ़ंक्शन को कॉल करने या ऑब्जेक्ट को डालने की आवश्यकता है।

Answer 4

एक मार्कर इंटरफ़ेस बनाएँ:

public interface IAmAGenericEntity { } 

public class Entity<T> where T : IAmAGenericEntity, new() 
// ... 

public class Category : Entity<T>, IAmAGenericEntity 
// .... 

var list = new List<IAmAGenericEntity>(); 
// ... 

Answer 5

Entity पर एक abstract मार्कर की कमी से, मुझे लगता है कि To/FromXElement उपयोग प्रतिबिंब और Entity के किसी भी उप-प्रकार के लिए काम करना चाहिए। मेरा सुझाव है कि आप अपनी कक्षाओं के रूप में इस संरचना:

public class Entity 
{ 
    public XElement ToXElement() { ... } 

    protected static T FromXElement<T>(XElement x) 
     where T : Entity 
    { 
     ... 
    } 
} 

public class Category : Entity 
{ 
    public static Category : FromXElement(XElement x) 
    { 
     return FromXElement<Category>(x); 
    } 
} 

"बॉयलरप्लेट" कम से कम है, और यह की आवश्यकता नहीं है कि आप रचनात्मक प्रकार प्रणाली से बचने के। आपको किसी सामान्य आधार की कमी, या मैन्युअल रूपांतरणों के बारे में चिंता करने की ज़रूरत नहीं है।आप चाहें, तो आप बॉयलरप्लेट पूरी तरह से समाप्त कर सकते हैं और सिर्फ Entity से सीधे अपने वस्तुओं का निर्माण:

public class Entity 
{ 
    public XElement ToXElement() { ... } 

    public static T FromXElement<T>(XElement x) 
     where T : Entity 
    { 
     ... 
    } 
} 

संक्षेप में, क्या आप कर रहे हैं एक प्रकार वर्ग है, जो सी # सीधे समर्थन नहीं करता लागू कर रहा है। इस कमी के आसपास काम करने के कई तरीके हैं, लेकिन मुझे आमतौर पर उन्हें मूल्यवान होने की तुलना में अधिक परेशानी होती है, खासकर जब यह स्थिर तरीकों की बात आती है। यदि सी # स्थिर स्थिर विधियों का समर्थन करता है, तो यह आसान होगा, लेकिन हां यह नहीं है।