किस क्रम में प्रत्येक लूप के लिए एक C # सूची <T> से अधिक होता है?

Question 1

मैं इस आदेश के बारे में सोच रहा था कि एक System.Collections.Generic.List<T>वस्तु के माध्यम से सी # लूप में एक फॉरेक्स लूप ।

मुझे उसी विषय के बारे में एक और सवाल मिला , लेकिन मुझे नहीं लगता कि यह मेरे संतोष के सवाल का जवाब देता है।

कोई कहता है कि कोई आदेश परिभाषित नहीं है। लेकिन जैसा कि कोई और बताता है, यह जिस क्रम का पता लगाता है वह निश्चित है (0 से लंबाई -1 तक)। 8.8.4 फॉर्च्यूमेंट स्टेटमेंट

यह भी कहा गया कि एक आदेश के साथ किसी भी मानक वर्गों के लिए समान है (जैसे List<T>)। मुझे लगता है कि वापस करने के लिए कोई दस्तावेज नहीं मिल सकता है। तो सभी के लिए मुझे पता है कि यह अब की तरह काम कर सकता है, लेकिन शायद अगले .NET संस्करण में यह अलग होगा (भले ही यह संभावना नहीं हो सकता है)।

मैंने List(t).Enumeratorबिना भाग्य के प्रलेखन को भी देखा है ।

एक अन्य संबंधित प्रश्न में कहा गया है कि जावा के लिए, यह विशेष रूप से प्रलेखन में उल्लिखित है:

List.iterator()इस सूची में तत्वों पर उचित क्रम में एक पुनरावृत्ति देता है। "

मैं सी # प्रलेखन में ऐसा कुछ खोज रहा हूं।

अग्रिम में धन्यवाद।

संपादित करें: आप सभी के जवाबों के लिए आप सभी के लिए धन्यवाद (कमाल है कि मुझे कितने उत्तर मिले)। सभी उत्तरों से मुझे जो समझ में आता है वह List<T>यह है कि हमेशा इसके अनुक्रमण के क्रम में पुनरावृति होती है। लेकिन मैं अभी भी यह बताते हुए दस्तावेज़ीकरण की एक स्पष्ट शांति देखना चाहूंगा, जावा प्रलेखन केList समान ।

Question 2

पर माइक्रोसॉफ्ट संदर्भ स्रोत पेज के लिए List<T>गणनाकार यह स्पष्ट रूप से कहा गया है कि यात्रा 0 से लंबाई -1 करने के लिए किया जाता है:

internal Enumerator(List<T> list) {
    this.list = list;
    index = 0;
    version = list._version;
    current = default(T);
}

public bool MoveNext() {

    List<T> localList = list;

    if (version == localList._version && ((uint)index < (uint)localList._size)) 
    {                                                     
        current = localList._items[index];                    
        index++;
        return true;
    }
    return MoveNextRare();
}

आशा है कि यह अभी भी किसी के लिए प्रासंगिक है

Question 3

मूल रूप से यह पर निर्भर है IEnumeratorकार्यान्वयन - लेकिन एक के लिए List<T>यह हमेशा सूची के प्राकृतिक व्यवस्था, यानी इंडेक्सर के रूप में एक ही क्रम में जाना होगा: list[0], list[1], list[2]आदि

मेरा मानना है कि यह स्पष्ट रूप से प्रलेखित है - कम से कम, मुझे ऐसा कोई दस्तावेज नहीं मिला है - लेकिन मुझे लगता है कि आप इसे गारंटी के रूप में मान सकते हैं। उस आदेश में कोई भी परिवर्तन सभी प्रकार के कोड को अनावश्यक रूप से तोड़ देगा। वास्तव में, मुझे यह देखकर कोई आश्चर्य IList<T>नहीं होगा कि इसका किसने क्रियान्वयन किया । यह विशेष रूप से प्रलेखित देखकर अच्छा लगेगा ...

Question 4

आपके लिंक में, सी # भाषा विशिष्टता संस्करण 3.0, पृष्ठ 240 में स्वीकृत उत्तर बताता है :

वह क्रम जिसमें फॉरेक्स आरेख के तत्वों का पता लगाता है, इस प्रकार है: एकल-आयामी सरणियों के लिए तत्वों को अनुक्रमणिका क्रम में बढ़ते हुए, सूचकांक 0 से शुरू किया जाता है और सूचकांक की लंबाई के साथ समाप्त किया जाता है - 1. बहुआयामी सरणियों के लिए, तत्वों का पता लगाया जाता है। ऐसा है कि सबसे दाएं आयाम के सूचकांकों को पहले बढ़ाया जाता है, फिर अगले बाएं आयाम, और इसी तरह बाईं ओर। निम्नलिखित उदाहरण तत्व मूल्य में दो-आयामी सरणी में प्रत्येक मूल्य को प्रिंट करता है:
using System;
class Test
{
  static void Main() {
      double[,] values = {
          {1.2, 2.3, 3.4, 4.5},
          {5.6, 6.7, 7.8, 8.9}
      };
      foreach (double elementValue in values)
          Console.Write("{0} ", elementValue);
      Console.WriteLine();
  }
}
उत्पादित उत्पादन निम्नानुसार है: 1.2 2.3 3.4 4.5 4.5 6.7 6.7 7.8 8.9 उदाहरण में
int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);
the type of n is inferred to be int, the element type of numbers.

Question 5

ऑर्डर को फ़ोरम लूप का उपयोग करके डेटा के संग्रह को पार करने के लिए उपयोग किए जा रहे पुनरावृत्त द्वारा परिभाषित किया गया है।

यदि आप एक मानक संग्रह का उपयोग कर रहे हैं जो कि इंडेक्सेबल (जैसे कि एक सूची) है, तो यह इंडेक्स 0 से शुरू होने वाले संग्रह को आगे बढ़ाएगा और आगे बढ़ेगा।

यदि आपको आदेश को नियंत्रित करने की आवश्यकता है तो आप या तो नियंत्रित कर सकते हैं कि संग्रह का पुनरावृत्ति कैसे अपने स्वयं के IEnumerable को लागू करके नियंत्रित किया जाता है , या आप उस सूची को सॉर्ट कर सकते हैं जिस तरह से आप चाहते हैं कि फ़ॉरच लूप को निष्पादित करने से पहले।

यह बताता है कि Enumerator जेनेरिक सूची के लिए कैसे काम करता है। सबसे पहले वर्तमान तत्व अपरिभाषित है और अगले आइटम पर जाने के लिए MoveNext का उपयोग करता है।

यदि आप MoveNext पढ़ते हैं तो यह इंगित करता है कि यह संग्रह के पहले तत्व के साथ शुरू होगा और वहाँ से अगले एक तक चलेगा जब तक कि यह संग्रह के अंत तक न पहुँच जाए।

Question 6

सूचियाँ आइटमों को एक क्रम में वापस करने के लिए लगती हैं जो वे बैकिंग स्टोर में हैं - इसलिए यदि उन्हें उस सूची में जोड़ा जाता है जिस तरह से उन्हें उस तरह से लौटाया जाएगा।

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

यह रैखिक खोजों के लिए कुछ हद तक मूर्खतापूर्ण है - लेकिन अगर आपको आदेश की आवश्यकता है तो एक निश्चित तरीका है कि आपकी सबसे अच्छी शर्त उस क्रम में आइटम बनाती है।

Question 7

मुझे कोड के त्वरित हैक के समान कुछ करना है, हालांकि यह मेरे लिए सूची को फिर से करने के लिए जो मैं करने की कोशिश कर रहा था उसके लिए काम नहीं किया।

ऑर्डर बदलने के लिए LINQ का उपयोग करना

         DataGridViewColumn[] gridColumns = new DataGridViewColumn[dataGridView1.Columns.Count];
         dataGridView1.Columns.CopyTo(gridColumns, 0); //This created a list of columns

         gridColumns = (from n in gridColumns
                        orderby n.DisplayIndex descending
                        select n).ToArray(); //This then changed the order based on the displayindex