सी # में सरणी के उपयोग को कैसे और कब छोड़ना है?

Question

मैं हमेशा कहा गया है एक सरणी के लिए कोई तत्व जोड़ इस तरह होता है कि:

सरणी + 1element की एक खाली प्रतिलिपि बनाई गई है और उसके बाद मूल सरणी से डेटा तो यह में बनाई जाए नए तत्व के लिए नए डेटा तो भरी हुई है

अगर यह सही है, तो एक परिदृश्य है कि तत्व गतिविधि का एक बहुत आवश्यकता है स्मृति और CPU उपयोग, सही होने के कारण विपरीत इंगित किया जाता है के भीतर एक सरणी का उपयोग कर?

यदि ऐसा है, तो क्या आप जितना संभव हो उतना सरणी का उपयोग करने से बचने की कोशिश नहीं कर सकते जब आप बहुत सारे तत्व जोड़ रहे हों? क्या आप इसके बजाय iStringMap का उपयोग करना चाहिए? यदि हां, तो क्या होता है यदि आपको दो से अधिक आयामों की आवश्यकता है और बहुत सारे तत्व जोड़ों को जोड़ने की आवश्यकता है। क्या आप प्रदर्शन प्रदर्शन हिट करते हैं या क्या ऐसा कुछ और है जिसका उपयोग किया जाना चाहिए?

Answer 1

जेनेरिक List<T> को सरणी के प्रतिस्थापन के रूप में देखें। यदि आप चाहें तो प्रारंभिक स्टोरेज आकार आवंटित करने सहित, वे वही चीजों के सरणी का समर्थन करते हैं।

Answer 2

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

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

Answer 3

सबसे अच्छी बात यह है कि आप जितनी अच्छी मेमोरी आवंटित कर सकते हैं उतना ही आवंटित करना जितना संभव हो सके। यह ढेर पर स्मृति प्राप्त करने के लिए अतिरिक्त कॉल करने से .NET को रोक देगा। उस समय विफल होने पर यह पांच के हिस्सों में आवंटित करने या आपके आवेदन के लिए जो भी संख्या समझ में आता है, उसे समझ में आता है।

यह एक नियम है जिसे आप वास्तव में किसी भी चीज़ पर लागू कर सकते हैं।

Answer 4

एक मानक सरणी को लंबाई के साथ परिभाषित किया जाना चाहिए, जो एक जटिल ब्लॉक में आवश्यक सभी स्मृति को सुरक्षित रखता है। सरणी में कोई आइटम जोड़ना इसे पहले ही आरक्षित मेमोरी के ब्लॉक के अंदर रखेगा।

Answer 5

सामान्य रूप से, मैं सरणी उपयोग से बचना पसंद करता हूं। बस सूची < टी> का उपयोग करें। यह आंतरिक रूप से एक गतिशील आकार के सरणी का उपयोग करता है, और अधिकांश उपयोग के लिए पर्याप्त तेज़ है। यदि आप बहु-आयामी सरणी का उपयोग कर रहे हैं, तो सूची < सूची < सूची < टी >>> का उपयोग करें यदि आपको करना है। यह स्मृति के मामले में इतना बुरा नहीं है, और वस्तुओं को जोड़ने के लिए बहुत आसान है।

यदि आप 0.1% उपयोग में हैं जो अत्यधिक गति की आवश्यकता है, तो सुनिश्चित करें कि यह आपकी सूची है जो इसे अनुकूलित करने का प्रयास करने से पहले वास्तव में समस्या है।

Answer 6

अर्रेलिस्ट और सूची आवश्यक होने पर एक से अधिक द्वारा सरणी को बढ़ाएं (मुझे लगता है कि यह आकार को दोगुनी करके है, लेकिन मैंने स्रोत की जांच नहीं की है)। जब आप एक गतिशील आकार के सरणी बना रहे हों तो वे आमतौर पर सबसे अच्छा विकल्प होते हैं।

जब आपके मानक इंगित करते हैं कि सरणी का आकार आपके आवेदन को गंभीरता से धीमा कर रहा है (याद रखें - समयपूर्व अनुकूलन सभी बुराइयों की जड़ है), तो आप tweaked आकार बदलने वाले व्यवहार के साथ एक कस्टम सरणी वर्ग लिखने का मूल्यांकन कर सकते हैं।

Answer 7

Arrays कुछ लिखने के लिए बहुत अच्छे हैं और कई पढ़ते हैं, विशेष रूप से एक पुनरावृत्ति प्रकृति के - कुछ और के लिए, कई अन्य डेटा संरचनाओं में से एक का उपयोग करें।

Answer 8

यदि आप तत्वों को जोड़ने/निकालने जा रहे हैं, तो बस एक सूची का उपयोग करें। यदि यह बहुआयामी है, तो आप हमेशा एक सूची < सूची < int >> या कुछ का उपयोग कर सकते हैं।

दूसरी ओर, सूचियों सरणियों की तुलना में कम कुशल हैं, तो क्या आप कर रहे हैं ज्यादातर सूची traversing, क्योंकि सरणियों अपने CPU कैश, जहां एक सूची में वस्तुओं सब कुछ खत्म हो बिखरे हुए हैं में एक ही स्थान पर सभी कर रहे हैं स्थान।

आप कुशल पढ़ने के लिए एक सरणी का उपयोग करना चाहते हैं, लेकिन आप जा करने के लिए अक्सर तत्वों "जोड़ने" जा रहे हैं, तो आप दो मुख्य विकल्प हैं:

1) एक सूची के रूप में यह उत्पन्न (या सूचियाँ की सूची) और फिर इसे एक कुशल सरणी संरचना में बदलने के लिए ToArray() का उपयोग करें।

2) सरणी को आपकी आवश्यकता से बड़ा होने के लिए आवंटित करें, फिर वस्तुओं को पूर्व-आवंटित कक्षों में रखें। यदि आप पूर्व-आवंटित की तुलना में और भी तत्वों की आवश्यकता को समाप्त करते हैं, तो आप प्रत्येक बार आकार को दोगुना करते समय सरणी को फिर से आवंटित कर सकते हैं। यह O (n) के बजाय ओ (लॉग एन) आकार बदलने का प्रदर्शन देता है जैसे कि यह एक reallocate-once-per-add सरणी के साथ होगा। ध्यान दें कि यह बहुत अधिक है कि स्ट्रिंगबिल्डर कैसे काम करता है, जिससे आपको स्ट्रिंग में लगातार जुड़ने का एक तेज़ तरीका मिल जाता है।

Answer 9

आप सही हैं एक लुकअप के लिए एक सरणी महान है। हालांकि सरणी के आकार में संशोधन महंगा हैं।

आपको उस कंटेनर का उपयोग करना चाहिए जो परिदृश्य में वृद्धिशील आकार समायोजन का समर्थन करता है जहां आप सरणी के आकार को संशोधित कर रहे हैं। आप एक ऐरेलिस्ट का उपयोग कर सकते हैं जो आपको प्रारंभिक आकार सेट करने की अनुमति देता है, और आप क्षमता बनाम आकार को लगातार देख सकते हैं और फिर आकारों की संख्या को सीमित करने के लिए क्षमता को बड़े हिस्से से बढ़ा सकते हैं।

या आप सिर्फ एक लिंक्ड सूची का उपयोग कर सकते हैं। फिर हालांकि देखो अप धीमी हैं ...

Answer 10

यह वास्तव में "एड" द्वारा आपके मतलब पर निर्भर करता है।

यदि आप मतलब है:

T[] array; 
int i; 
T value; 
... 
if (i >= 0 && i <= array.Length) 
    array[i] = value; 

तो, नहीं, यह एक नई सरणी का निर्माण नहीं करता, और इन-तथ्य .NET में IList किसी भी तरह का परिवर्तन करने के लिए सबसे तेज़ तरीका है।

यदि, हालांकि, आप ऐरेलिस्ट, सूची, संग्रह इत्यादि जैसे कुछ उपयोग कर रहे हैं, तो "जोड़ें" विधि को कॉल कर सकते हैं एक नई सरणी बना सकते हैं - लेकिन वे इसके बारे में स्मार्ट हैं, वे सिर्फ 1 तत्व द्वारा आकार बदलें, वे ज्यामितीय रूप से बढ़ते हैं, इसलिए यदि आप थोड़ी देर में केवल एक बार मूल्यों को जोड़ रहे हैं तो इसे एक नई सरणी आवंटित करनी होगी। फिर भी, आप हाथ से पहले बढ़ने के लिए मजबूर करने के लिए "क्षमता" संपत्ति का उपयोग कर सकते हैं, यदि आप जानते हैं कि आप कितने तत्व जोड़ रहे हैं (list.Capacity += numberOfAddedElements)

Answer 11

यह फ़ोरम पोस्ट आपके बारे में कुछ उपयोग हो सकता है या नहीं विभिन्न सरणी प्रकारों की दक्षता: C# arrays - multidimensional vs lexicographic

Answer 12

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

एक बार जब मैं आम तौर पर एक सूची में एक सरणी का उपयोग करता हूं तो मुझे एक वस्तु की संपत्ति के रूप में संग्रह वापस करने की आवश्यकता होती है - मैं नहीं चाहता कि कॉलर्स सूची सूची जोड़ों के माध्यम से संग्रह को जोड़ना चाहें, लेकिन इसके बजाय उन्हें जोड़ना चाहते हैं मेरे ऑब्जेक्ट के इंटरफ़ेस के माध्यम से संग्रह में आइटम। उस स्थिति में, मैं आंतरिक सूची लेता हूं और ToArray को कॉल करता हूं और एक सरणी देता हूं।

Answer 13

आम तौर पर, यदि आपके पास सबसे अच्छा अनुक्रमित लुकअप प्रदर्शन होना चाहिए तो पहले सूची बनाना सबसे अच्छा है और फिर इसे एक सरणी में बदलना है, इस प्रकार पहले एक छोटा सा जुर्माना देना लेकिन बाद में किसी से बचाना। यदि समस्या यह है कि आप लगातार नए डेटा को जोड़ रहे हैं और पुराने डेटा को हटा रहे हैं तो आप सुविधा के लिए एक ऐरेलिस्ट या सूची का उपयोग करना चाहेंगे लेकिन ध्यान रखें कि वे केवल विशेष मामले Arrays हैं। जब वे "बढ़ते हैं" वे एक पूरी तरह से नई सरणी आवंटित करते हैं और इसमें सब कुछ कॉपी करते हैं जो बेहद धीमी है।

ArrayList केवल एक ऐरे है जो आवश्यक होने पर बढ़ता है। Add amortized O (1) जोड़ें, बस यह सुनिश्चित करने के लिए सावधान रहें कि आकार खराब समय पर नहीं होगा। डालें ओ (एन) दाईं ओर सभी वस्तुओं को स्थानांतरित किया जाना चाहिए। निकालें ओ (एन) दाईं ओर सभी वस्तुओं को स्थानांतरित किया जाना चाहिए।

यह भी ध्यान रखना महत्वपूर्ण है कि सूची एक लिंक्ड सूची नहीं है। यह सिर्फ एक टाइप की गई ArrayList है। सूची documentation ध्यान दें कि यह ज्यादातर मामलों में बेहतर प्रदर्शन करता है लेकिन क्यों नहीं कहता है।

सबसे अच्छी बात यह है कि आपकी समस्या के लिए उपयुक्त डेटा संरचना चुनना है। यह एक बहुत सी चीज़ों पर निर्भर करता है और इसलिए आप System.Collections.Generic नेमस्पेस ब्राउज़ करना चाह सकते हैं।

इस विशेष मामले में मैं कहूंगा कि यदि आप एक अच्छी कुंजी मान Dictionary के साथ आ सकते हैं तो आपकी सबसे अच्छी शर्त होगी। यह उस ओ (1) दृष्टिकोण को सम्मिलित और हटा देता है। हालांकि, यहां तक ​​कि एक शब्दकोश के साथ आपको सावधान रहना होगा कि इसे अपने आंतरिक सरणी (एक ओ (एन) ऑपरेशन का आकार बदलने न दें)। कन्स्ट्रक्टर में एक बड़ी-से-अपेक्षा-उपयोग-प्रारंभिक क्षमता को निर्दिष्ट करके उन्हें बहुत अधिक कमरा देना सर्वोत्तम होता है।

-रिक

Answer 14

आप जोड़ने, और आप रैंडम एक्सेस (जैसे myArray[i] के रूप में) कर नहीं किया जाएगा का एक बहुत कुछ कर रहा करने के लिए जा रहे हैं। आप एक लिंक्ड सूची (LinkedList<T>) का उपयोग करने पर विचार कर सकते हैं, क्योंकि इसे कभी भी List<T> कार्यान्वयन की तरह "बढ़ने" की आवश्यकता नहीं होगी। ध्यान रखें, हालांकि, आप केवल IEnumerable<T> इंटरफ़ेस का उपयोग करके LinkedList<T> कार्यान्वयन में आइटम तक पहुंच सकते हैं।

Answer 15

जब सरणियों

1. पहले के उपयोग का परित्याग करने और सबसे महत्वपूर्ण, सरणियों के शब्दों न जब आपके इरादे साथ मैच - एक गतिशील रूप से बढ़ संग्रह की आवश्यकता है? एक सेट जो डुप्लिकेट की अनुमति नहीं देता है? एक संग्रह जो अपरिवर्तनीय रहना है? उन सभी मामलों में सरणी से बचें। यह 99% मामलों में है। बस स्पष्ट मूल बिंदु बताते हुए।

2. दूसरे, आप कर रहे हैं जब नहीं पूर्ण प्रदर्शन criticalness के लिए कोडिंग - यही कारण है कि मामलों की लगभग 95% है। Arrays perform better marginally, especially in iteration। यह लगभग हमेशा कोई फर्क नहीं पड़ता।

3. जब आप params कीवर्ड के साथ एक बहस के लिए मजबूर नहीं हैं - मैं सिर्फ params किसी भी IEnumerable<T> या और भी बेहतर एक भाषा में ही निर्माण एक अनुक्रम (और नहीं एक रूपरेखा प्रकार) निरूपित करने के लिए स्वीकार किए जाते हैं की कामना की।

4. जब आप नहीं लेखन विरासत कोड, या इंटरॉप

संक्षेप में साथ काम कर, अपने बहुत ही दुर्लभ है कि आप एक सरणी वास्तव में की आवश्यकता होगी रहे हैं। मैं इस बात से जोड़ूंगा कि कोई इसे क्यों टाल सकता है?

1. सरणी आईएमओ से बचने का सबसे बड़ा कारण वैचारिक है। Arrays कार्यान्वयन के करीब हैं और अमूर्त से आगे। Arrays से से किया जाता है जो उच्च स्तर की भाषाओं की भावना के विरुद्ध किया जाता है। यह आश्चर्य की बात नहीं है कि, एरे धातु के करीब हैं, वे सीधे एक विशेष प्रकार से बाहर हैं (हालांकि आंतरिक रूप से सरणी एक वर्ग है)। शैक्षिक नहीं होना चाहिए, लेकिन सरणी वास्तव में बहुत ही कम से कम आवश्यक अर्थपूर्ण अर्थ में अनुवाद करते हैं। सबसे उपयोगी और लगातार अर्थशास्त्र किसी भी प्रविष्टि के साथ संग्रह, अलग-अलग वस्तुओं के साथ सेट, मुख्य मूल्य मानचित्र इत्यादि हैं जो addable, readonly, अपरिवर्तनीय, ऑर्डर-सम्मान वाले संस्करणों के किसी भी संयोजन के साथ हैं। इसके बारे में सोचें, आप एक अतिरिक्त संशोधन के साथ पूर्ववर्ती वस्तुओं के साथ एक जोड़ने योग्य संग्रह, या केवल संग्रह चाहते हैं, लेकिन आपका तर्क कितनी बार दिखता है "मैं गतिशील रूप से जोड़ने योग्य संग्रह चाहता हूं लेकिन उनमें से केवल एक निश्चित संख्या है और उन्हें भी संशोधित किया जाना चाहिए "? मैं बहुत दुर्लभ कहूंगा।

2. ऐरे को प्री-जेनरिक युग के दौरान डिज़ाइन किया गया था और यह कई रन टाइम हैक्स के साथ जेनेरिकता की नकल करता है और यह यहां और वहां अपनी विषमताएं दिखाएगा। कैच मैंने पाया में से कुछ:

   1. Broken covariance.

      string[] strings = ... 
      object[] objects = strings; 
      objects[0] = 1; //compiles, but gives a runtime exception. 
      

   2. Arrays can give you reference to a struct!। यह कहीं और के विपरीत नहीं है। एक नमूना:

      struct Value { public int mutable; } 
      
      var array = new[] { new Value() }; 
      array[0].mutable = 1; //<-- compiles ! 
      //a List<Value>[0].mutable = 1; doesnt compile since editing a copy makes no sense 
      print array[0].mutable // 1, expected or unexpected? confusing surely 
      

   3. Run time implemented methods like ICollection<T>.Contains can be different for structs and classes। यह एक बड़ा सौदा नहीं है, लेकिन यदि आप जेनेरिक Equals के लिए जेनेरिक संग्रह की अपेक्षा करने वाले संदर्भ प्रकारों के लिए गैर जेनेरिक Equals को ओवरराइड करना भूल जाते हैं, तो आपको गलत परिणाम मिलेंगे।

      public class Class : IEquatable<Class> 
      { 
          public bool Equals(Class other) 
          { 
           Console.WriteLine("generic"); 
           return true; 
          } 
          public override bool Equals(object obj) 
          { 
           Console.WriteLine("non generic"); 
           return true; 
          } 
      } 
      
      public struct Struct : IEquatable<Struct> 
      { 
          public bool Equals(Struct other) 
          { 
           Console.WriteLine("generic"); 
           return true; 
          } 
          public override bool Equals(object obj) 
          { 
           Console.WriteLine("non generic"); 
           return true; 
          } 
      } 
      
      class[].Contains(test); //prints "non generic" 
      struct[].Contains(test); //prints "generic" 
      

   4. Length संपत्ति और T[] पर [] इंडेक्सर नियमित गुण है कि आप प्रतिबिंब के माध्यम से उपयोग कर सकते हैं (जो कुछ जादू को शामिल करना चाहिए) होने लगते हैं, लेकिन जब यह अभिव्यक्ति के पेड़ की बात आती है तुम ठीक उसी थूक से बाहर करने के लिए है कोड संकलक करता है। अलग-अलग ऐसा करने के लिए ArrayLength और ArrayIndex विधियां हैं। ऐसा एक question here।एक और उदाहरण:

      Expression<Func<string>> e =() => new[] { "a" }[0]; 
      //e.Body.NodeType == ExpressionType.ArrayIndex 
      
      Expression<Func<string>> e =() => new List<string>() { "a" }[0]; 
      //e.Body.NodeType == ExpressionType.Call; 
      

सरणियों

सबसे अधिक इस्तेमाल किया विकल्प List<T> जिसमें अधिक स्पष्ट एपीआई है के उपयोग का परित्याग करने के लिए कैसे। लेकिन यह एक गतिशील रूप से बढ़ती संरचना है जिसका अर्थ है कि आप अंत में List<T> में जोड़ सकते हैं या किसी भी क्षमता में कहीं भी डालेंगे। किसी सरणी के सटीक व्यवहार के लिए कोई विकल्प नहीं है, लेकिन लोग ज्यादातर रीडोनली संग्रह के रूप में सरणी का उपयोग करते हैं जहां आप इसके अंत में कुछ भी नहीं जोड़ सकते हैं। एक विकल्प ReadOnlyCollection<T> है।

public ReadOnlyCollection<T> ToReadOnlyCollection<T>(IEnumerable<T> source) 
{ 
    return source.ToList().AsReadOnly(); 
}