जेनिक्स या जेनरिक नहीं

Question

असल में मेरे पास एक कस्टम लिस्ट क्लास है जिसमें विभिन्न फलों हैं। मान लें कि प्रत्येक फल में एक आईडी नंबर होता है जो सूची में संग्रहीत होता है।

बेहतर है करने के लिए है:

new AppleList(); 
new OrangeList(); 
new LemonList(); 

या

new FruitList<Fruit.Apple>(); 
new FruitList<Fruit.Orange>(); 
new FruitList<Fruit.Lemon>(); 

विचारणीय बातें:

• सभी आईडी प्रकार int के हैं।
• फल का प्रकार सूची के कार्यान्वयन को प्रभावित नहीं करेगा। इसका उपयोग केवल सूची के ग्राहक द्वारा किया जाएगा, जैसे बाहरी विधि, आदि

मैं स्पष्ट, बेहतर, डिजाइन में बेहतर, अधिक कुशल, आदि का उपयोग करना चाहता हूं। इसके अतिरिक्त यदि ये उपर्युक्त 2 तकनीकें सर्वश्रेष्ठ नहीं हैं, कृपया अपने विचारों का सुझाव दें।

संपादित करें: बीटीडब्ल्यू फल एक enum है अगर यह स्पष्ट नहीं था।

Answer 1

• सभी आईडी प्रकार int हैं।

• फल का प्रकार सूची के कार्यान्वयन को प्रभावित नहीं करेगा। इसका उपयोग केवल सूची के ग्राहक द्वारा किया जाएगा, जैसे बाहरी विधि, आदि

इन दो तथ्यों को देखते हुए, मैं जेनरिक से परेशान नहीं होता। मैं फूटलिस्ट पर एक सामान्य संपत्ति डालूंगा यह इंगित करने के लिए कि यह किस प्रकार का फल है।

Answer 2

3 गैर-जेनेरिक संस्करणों की तुलना में 1 जेनेरिक सूची को बनाए रखना बहुत आसान है। क्या तुम सच में AppleList नाम की तरह आप हमेशा चाल का उपयोग कर एक सामान्य सूची नाम के लिए

using AppleList=Fruit.FruitList<Fruit.Apple> 

Answer 3

उपयोग कर सकते हैं, तो आप जेनरिक का उपयोग करते हैं, वहाँ FruitList प्रकार बनाने के लिए एक उद्देश्य है? क्या आप सिर्फ सूची का उपयोग कर सकते हैं?

प्रदर्शन में बहुत अंतर नहीं होगा, इसलिए मैं कहता हूं कि तीन अलग-अलग वर्ग क्यों बनाते हैं जब कोई वही काम करता है? जेनेरिक समाधान का प्रयोग करें।

Answer 4

उपयोग एक कॉम्बो:

public class AppleList : FruitList<Apple> { ... } 
public class OrangeList : FruitList<Orange> { ... } 
public class LemonList : FruitList<Lemon> { ... } 

आधार सूची कक्षा में आम तर्क रखो:

public class FruitList<T> : List<T> 
    where T : IFruit 
{ ... } 

Answer 5

पुन: उपयोग सामान्य संग्रह वर्गों और उन्हें उपवर्ग आप अतिरिक्त कार्यक्षमता जोड़ रहे हैं केवल यदि। यदि आप कर सकते हैं तो अपने सबक्लास कार्यान्वयन सामान्य रखें। यह कम से कम जटिल कार्यान्वयन है।

Answer 6

जेनेरिक सूची का उपयोग करें, क्रेटिंग 3 सूचियों में कोई बिंदु नहीं है और यह हमेशा के लिए अमूर्तता का स्तर रखने के लिए अच्छा है। (IFruit एक अच्छा इंटरफ़ेस होगा)।

Answer 7

आपको YAGNI मानना ​​चाहिए जब तक कि आपको इसकी आवश्यकता न हो। इसलिए, यदि आपको सूची में आने से अधिक चीज की आवश्यकता नहीं है, तो बस List<T>।आप सूची को ओवरराइड करने के लिए है किसी कारण से, तो

FruitList<T> : List<T> where T : Fruit 

बनाते हैं अपनी सूची वितरित हो जाते हैं और अब बहुरूपी हैं, तो आपके कस्टम सूचियों लागू करने पर विचार:

• AppleList
• OrangeList
• LemonList

सर्वोत्तम यो के रूप में प्रयास करें हालांकि, आप अपने उत्तराधिकारी को अपने समाधान को कम करने से बचने के लिए यथासंभव सपाट पदानुक्रम रखने के लिए कर सकते हैं।

Answer 8

मैं स्वीकार किए जाते हैं जवाब की सिफारिश नहीं होगा और मुझे लगता है कि आप इस के बजाय की तरह कुछ का मतलब:

public enum Fruit 
{ 
    Apple, 
    Orange, 
    Lemon 
} 

public interface IFruitList : IList<int> 
{ 
    Fruit Type { get; } 
}; 

public class FruitList : List<int>, IFruitList 
{ 
    private readonly type; 

    FruitList(Fruit type) 
    : base() 
    { 
     this.type = type; 
    } 

    FruitList(Fruit type, IEnumerable<int> collection) 
    : base(collection) 
    { 
     this.type = type; 
    } 

    Fruit Type { return type; } 
}