उचित रूप से एक सूची का खुलासा <T>?

Question

मुझे पता है कि मुझे किसी संपत्ति में List<T> का खुलासा नहीं करना चाहिए, लेकिन मुझे आश्चर्य है कि ऐसा करने का उचित तरीका क्या है? उदाहरण के लिए, यह कर:

public static class Class1 
{ 
    private readonly static List<string> _list; 

    public static IEnumerable<string> List 
    { 
     get 
     { 
      return _list; 
      //return _list.AsEnumerable<string>(); behaves the same 
     } 
    } 

    static Class1() 
    { 
     _list = new List<string>(); 
     _list.Add("One"); 
     _list.Add("Two"); 
     _list.Add("Three"); 
    } 
} 

मेरे फोन करने वाले बस List<T> वापस करने के लिए कास्ट करने के लिए अनुमति होगी:

private void button1_Click(object sender, EventArgs e) 
    { 
     var test = Class1.List as List<string>; 
     test.Add("Four"); // This really modifies Class1._list, which is bad™ 
    } 

तो अगर मैं एक बहुत अपरिवर्तनीय List<T> चाहते मैं हमेशा एक नई सूची बनाने करना होगा? उदाहरण के लिए, यह काम करने लगता है (परीक्षण कलाकारों के बाद रिक्त है):

public static IEnumerable<string> List 
    { 
     get 
     { 
      return new ReadOnlyCollection<string>(_list); 
     } 
    } 

लेकिन मैं चिंतित हूँ अगर वहाँ एक प्रदर्शन भूमि के ऊपर के रूप में मेरी सूची में हर बार जब कोई इसे उपयोग करने की कोशिश करता है क्लोन है?

Answer 1

उपयोग AsReadOnly() - see MSDN for details

Answer 2

हां और नहीं हां, एक प्रदर्शन ओवरहेड है, क्योंकि एक नई वस्तु बनाई गई है। नहीं, आपकी सूची क्लोन नहीं की गई है, इसे ReadOnlyCollection द्वारा लपेटा गया है।

Answer 3

एक List<T> उजागर के रूप में एक संपत्ति वास्तव में सभी बुराई की जड़ नहीं है, खासकर यदि यह foo.Items.Add(...) जैसे अपेक्षित उपयोग की अनुमति देता है।

आप AsEnumerable() करने के लिए एक कच्चे सुरक्षित विकल्प लिख सकते हैं:

public static IEnumerable<T> AsSafeEnumerable<T>(this IEnumerable<T> data) { 
    foreach(T item in data) yield return item; 
} 

लेकिन इस समय अपने सबसे बड़ी समस्या यह धागा सुरक्षा है। एक स्थिर सदस्य के रूप में, आपको यहां बड़ी समस्याएं हो सकती हैं, खासकर यदि यह एएसपी.नेट जैसी चीज़ में है। यहां तक ​​कि ReadOnlyCollection किसी मौजूदा सूची से अधिक इस से ग्रस्त होगा:

 List<int> ints = new List<int> { 1, 2, 3 }; 
     var ro = ints.AsReadOnly(); 
     Console.WriteLine(ro.Count); // 3 
     ints.Add(4); 
     Console.WriteLine(ro.Count); // 4 

तो बस AsReadOnly साथ लपेटकर है नहीं अपने वस्तु धागा सुरक्षित बनाने के लिए पर्याप्त; यह केवल उपभोक्ता डेटा जोड़ने के खिलाफ सुरक्षा करता है (लेकिन जब भी आप सिंक्रनाइज़ या प्रतिलिपि बनाते हैं, तब भी वे डेटा को जोड़ते समय भी इसका अनुमान लगा सकते हैं)।

Answer 4

आपको क्लोनिंग के ऊपरी हिस्से के बारे में चिंता करने की आवश्यकता नहीं है: ReadOnlyCollection के साथ संग्रह को लपेटना क्लोन करें। यह सिर्फ एक रैपर बनाता है; यदि अंतर्निहित संग्रह बदलता है, तो पाठक संस्करण भी बदल जाता है।

यदि आप बार-बार ताजा रैपर बनाने की चिंता करते हैं, तो आप इसे एक अलग आवृत्ति चर में कैश कर सकते हैं।

Answer 5

यदि कक्षा का कोई अन्य उद्देश्य नहीं है तो आप सूची से प्राप्त कर सकते हैं और ऐड विधि को ओवरराइड कर सकते हैं और इसे अपवाद फेंक सकते हैं।

Answer 6

असीमित और ReadOnlyCollection में समस्या है जब आपकी गणना मिडवे पर है और संग्रह संशोधित हो जाता है। ये चीजें धागे सुरक्षित नहीं हैं। उन्हें एक सरणी के रूप में लौटाना और कॉलिंग के समय उन्हें कैशिंग करना बेहतर विकल्प हो सकता है।

उदाहरण के लिए,

public static String[] List{ 
    get{ 
     return _List.ToArray(); 
    } 
} 

//While using ... 

String[] values = Class1.List; 

foreach(string v in values){ 
    ... 
} 

// instead of calling foreach(string v in Class1.List) 
// again and again, values in this context will not be 
// duplicated, however values are cached instance so 
// immediate changes will not be available, but its 
// thread safe 
foreach(string v in values){ 
    ... 
} 

Answer 7

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

Answer 8

मैं एक ऐसी ही सवाल पहले से पूछा:

• Difference between List and Collection (CA1002, Do not expose generic lists)
• Why does DoNotExposeGenericLists recommend that I expose Collection instead of List?

उस आधार पर मैं सुझाव है कि आप List<T> आंतरिक रूप से उपयोग करते हैं, और एक Collection<T> या IList<T> के रूप में इसे वापस। या अगर यह केवल IEnumerable<T> की गणना करने या जोड़ने के लिए जरूरी है और नहीं।

अन्य चीजों में जो कुछ भी लौटता है उसे डालने में सक्षम होने के मामले में, मैं बस परेशान नहीं कहूंगा। यदि लोग आपके कोड का इस तरह से उपयोग करना चाहते हैं कि इसका इरादा नहीं था, तो वे किसी भी तरह से या किसी अन्य तरीके से सक्षम होंगे। मैंने पहले इसके बारे में एक सवाल भी पूछा था, और मैं कहूंगा कि केवल एकमात्र बुद्धिमान चीज है जो आप चाहते हैं उसका खुलासा करना है, और यदि लोग इसे अलग तरीके से उपयोग करते हैं, तो यह उनकी समस्या है: पी कुछ संबंधित प्रश्न:

• How should I use properties when dealing with List members (विशेष रूप से this answer)
• Encapsulation of for example collections