आप एक बहुआयामी सरणी के माध्यम से कैसे लूप करते हैं?

Question

foreach (String s in arrayOfMessages) 
{ 
    System.Console.WriteLine(s); 
} 

string[,] arrayOfMessages पैरामीटर के रूप में पारित किया जा रहा है।

मैं यह निर्धारित करने में सक्षम होना चाहता हूं कि कौन से तार arrayOfMessages[0,i] और arrayOfMessages[n,i] से हैं, जहां n सरणी का अंतिम सूचकांक है।

Answer 1

, बस दो नेस्टेड for छोरों का उपयोग करें। आयामों के आकार पाने के लिए आपको GetLength() उपयोग कर सकते हैं:

for (int i = 0; i < arrayOfMessages.GetLength(0); i++) 
{ 
    for (int j = 0; j < arrayOfMessages.GetLength(1); j++) 
    { 
     string s = arrayOfMessages[i, j]; 
     Console.WriteLine(s); 
    } 
} 

इसका मतलब यह है कि आप वास्तव में string[,] है। .Net में भी बहुआयामी सरणी होना संभव है जो 0 से अनुक्रमित नहीं हैं। उस स्थिति में, उन्हें Array के रूप में प्रतिनिधित्व किया जाना चाहिए और आपको प्रत्येक आयाम के लिए सीमाएं प्राप्त करने के लिए GetLowerBound() और GetUpperBound() का उपयोग करना होगा।

Answer 2

foreach का उपयोग न करें - नेस्टेड के प्रत्येक आयाम के लिए नेस्टेड for लूप का उपयोग करें।

आप प्रत्येक आयाम में GetLength विधि के साथ तत्वों की संख्या प्राप्त कर सकते हैं।

एमएसडीएन पर Multidimensional Arrays (C# Programming Guide) देखें।

Answer 3

पाश के लिए एक नेस्टेड साथ

:

for (int row = 0; row < arrayOfMessages.GetLength(0); row++) 
{ 
    for (int col = 0; col < arrayOfMessages.GetLength(1); col++) 
    { 
     string message = arrayOfMessages[row,col]; 
     // use the message 
    }  
} 

Answer 4

कुछ इस तरह काम करेंगे:

int length0 = arrayOfMessages.GetUpperBound(0) + 1; 
int length1 = arrayOfMessages.GetUpperBound(1) + 1; 

for(int i=0; i<length1; i++) { string msg = arrayOfMessages[0, i]; ... } 
for(int i=0; i<length1; i++) { string msg = arrayOfMessages[length0-1, i]; ... } 

Answer 5

आप बहुआयामी सरणियों को चलाने के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं।

foreach (String s in arrayOfMessages) 
{ 
    System.Console.WriteLine("{0}",s); 
} 

Answer 6

ऐसा लगता है कि आप अपनी समस्या के लिए उपयुक्त एक जवाब मिला, लेकिन जब से शीर्षक एक बहुआयामी सरणी के लिए पूछता है (जो मैं 2 या अधिक के रूप में पढ़ा), और इस पहले खोज परिणाम मैं जब मिल गया है

public static class MultidimensionalArrayExtensions 
{ 
    /// <summary> 
    /// Projects each element of a sequence into a new form by incorporating the element's index. 
    /// </summary> 
    /// <typeparam name="T">The type of the elements of the array.</typeparam> 
    /// <param name="array">A sequence of values to invoke the action on.</param> 
    /// <param name="action">An action to apply to each source element; the second parameter of the function represents the index of the source element.</param> 
    public static void ForEach<T>(this Array array, Action<T, int[]> action) 
    { 
     var dimensionSizes = Enumerable.Range(0, array.Rank).Select(i => array.GetLength(i)).ToArray(); 
     ArrayForEach(dimensionSizes, action, new int[] { }, array); 
    } 
    private static void ArrayForEach<T>(int[] dimensionSizes, Action<T, int[]> action, int[] externalCoordinates, Array masterArray) 
    { 
     if (dimensionSizes.Length == 1) 
      for (int i = 0; i < dimensionSizes[0]; i++) 
      { 
       var globalCoordinates = externalCoordinates.Concat(new[] { i }).ToArray(); 
       var value = (T)masterArray.GetValue(globalCoordinates); 
       action(value, globalCoordinates); 
      } 
     else 
      for (int i = 0; i < dimensionSizes[0]; i++) 
       ArrayForEach(dimensionSizes.Skip(1).ToArray(), action, externalCoordinates.Concat(new[] { i }).ToArray(), masterArray); 
    } 

    public static void PopulateArray<T>(this Array array, Func<int[], T> calculateElement) 
    { 
     array.ForEach<T>((element, indexArray) => array.SetValue(calculateElement(indexArray), indexArray)); 
    } 
} 

प्रयोग उदाहरण:

var foo = new string[,] { { "a", "b" }, { "c", "d" } }; 
foo.ForEach<string>((value, coords) => Console.WriteLine("(" + String.Join(", ", coords) + $")={value}")); 
// outputs: 
// (0, 0)=a 
// (0, 1)=b 
// (1, 0)=c 
// (1, 1)=d 

// Gives a 10d array where each element equals the sum of its coordinates: 
var bar = new int[4, 4, 4, 5, 6, 5, 4, 4, 4, 5]; 
bar.PopulateArray(coords => coords.Sum()); 

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