Multidimensional Array in C#

Two-Dimensional Arrays

A two-dimensional array is the most basic form of C# multidimensional array. A two-dimensional array can be imagined as a list of one-dimensional arrays. Let us try to visualize it with the help of the following 4x3 2-D array.

The elements have been represented by a[i][j], where i is the row number, and j is the column number.

Creating a 2-D Array

To create a 2-D array in C#, add every 1-D array within a set of curly braces, and insert a comma (,) inside the square brackets.

For instance,

int[,] nums = {{3,4,5},{7,54,67},{9,45,23}};

Let’s visualize the array we just created.

Accessing the elements in a 2-D array

You must specify the indices to access the elements in a C# multidimensional array. So, in the case of 2-D arrays, you will have to specify two indices. One index is for the array, and the other is for the element inside the array. In simple words, we can also say that one index is for the row number, and the other represents the column number.

Taking the array we created above, let us try to access its elements.

Code:

using System;
class Example2D_array {
  static void Main() {
      
    int[,] nums = {{3,4,5},{7,54,67},{9,45,23}};
    Console.WriteLine(nums[0,1]);
    Console.WriteLine(nums[1,2]);
    Console.WriteLine(nums[2,1]);
    
  }
}

Output:

Changing the Elements 

In C# Multidimensional arrays, we can also change the value of an element. Let us continue with the previous example and change the element in Row 1 Column 2.

Code:

using System;
class Example2D_array {
  static void Main() {
      
    int[,] nums = {{3,4,5},{7,54,67},{9,45,23}};
    Console.WriteLine("The element before changing:");
    Console.WriteLine(nums[1,2]);
    nums[1,2] = 10;
    Console.WriteLine("The element after changing:");
    Console.WriteLine(nums[1,2]);
    
  }
}

 

Output:

Looping through a 2-D Array

We can easily loop through elements of a C# 2-D array. Let us try to understand this with the help of the following examples:

Example 1: foreach loop

using System;
class Example2D_array_foreach
{
  static void Main ()
  {


    int[,] nums = { {3, 4, 5}, {7, 54, 67}, {9, 45, 23} };
    Console.WriteLine("The elements in the 2-D array are:");
    foreach (int i in nums)
    {


        Console.WriteLine(i);
    }


  }
}

Output:

Example 2: for loop

using System;
class Example2D_array_forloop
{
  static void Main ()
  {


    int[,] nums = { {3, 4, 5}, {7, 54, 67}, {9, 45, 23} };
    Console.WriteLine("The elements in the 2-D array are:");
    for (int i = 0; i < nums.GetLength(0); i++) 
    { 
        for (int j = 0; j < nums.GetLength(1); j++) 
        { 
            Console.WriteLine(nums[i, j]); 
        } 
    }  
  }
}

 

Output:

Types of 2-D Arrays

The two-dimensional array, interchangeably called a C# multidimensional array, has two types-

1. Rectangular Array
2. Jagged Array

Let us see them in detail.

Rectangular Arrays in C#

Rectangle arrays are arrays where rows and columns are equal in number. The creation, accessing, changing, and looping of elements is similar to what has been explained above.

Syntax:

<type>[,] <name> = new <type> [row, column];
Or 
<type>[,] <name> = {list of values}

Jagged Arrays in C#

The data will be stored in these two-dimensional arrays in the form of rows and columns. However, the column size will vary from row to row in this ragged array. Accordingly, if the first row has five columns, the second row may have four, and the third row may have ten. The most important thing to remember is that a jagged array is one in which the column size fluctuates from row to row. It is a rectangular two-dimensional array if the column size is constant across all rows.

The array of arrays is another name for the jagged array in C#. This is because each row in the jagged array is a single-dimensional array. In C#, a jagged array is created by combining many single-dimensional arrays with various column sizes.

Syntax:

<type> [][] <name> = new <type> [row][];
Or
<type> [][] <name> = {list of values}

As you can see, during the declaration of a jagged array, we must specify the number of rows we want in the array.

Let us understand creating, initializing, accessing, and looping jagged array with the help of the following example:
 

Example:

using System;
namespace JaggedArray_example
{
    class example
    {
        static void Main(string[] args)
        {
            //Creating jagged array with 5 Rows
            int[][] arr = new int[5][];


            //Initializing each row with a different column size


            arr[0] = new int[5];
            arr[1] = new int[4];
            arr[2] = new int[3];
            arr[3] = new int[4];
            arr[4] = new int[6];


            //using nested for loop to print the values of Jagged array 
            
            //GetLength(0): This returns the Size of the Rows that is 5
            Console.WriteLine("The default values in Jagged Array:");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                //arr[i].Length: Returns the Length of Each Row
                for (int j = 0; j < arr[i].Length; j++)
                {
                    Console.Write(arr[i][j] + " ");
                }
            }
            
            //Assigning values to the Jagged array 
            //We use for loop to do this
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                int num = 20;
                for (int j = 0; j < arr[i].Length; j++)
                {
                    num++;
                    arr[i][j] = num;
                }
            }


            //Printing the values of Jagged array 
            //To do this we use foreach loop within the for loop
            
            Console.WriteLine("\n\nThe new values in Jagged Array are:");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                foreach (int a in arr[i])
                {
                    Console.Write(a + " ");
                }
            }
            
            //Accessing element in the 4th row 2nd column
            Console.WriteLine("\n\nThe element in the 4th row 2nd column is:");
            Console.WriteLine(arr[4][2]);


            
            Console.ReadKey();
        }
    }
} 

Output:

 

Frequently Asked Questions

What are the uses of multidimensional arrays?

Data is widely stored in multi-dimensional arrays, an expanded variant of one-dimensional arrays, for use in mathematical computations, image processing, and record management.

How to create a Multidimensional array in C#?

The commas must be placed inside the square brackets to form a C# multidimensional array depending upon the dimensions required.

How many dimensions can we add in C# Multidimensional Arrays?

C# language supports multidimensional arrays up to 32 dimensions.

What are the types of 2-D arrays in C#?

There are two types of 2-D arrays in C#: Rectangular and Jagged.

Conclusion

In this article, we saw the C# Multidimensional arrays in detail. We started with a basic understanding of multidimensional arrays and then proceeded with 2-D arrays and their types. We also saw how to create, initialize, access and loop through arrays. 

You can also check out multidimensional arrays in java and multidimensional arrays in C++.

To explore more interesting coding-related articles, refer to the following links:

• Singleton Design Pattern C#
• C# interview questions for 5 years Experience
• C++ String concatenation
• Byte array to string
• Enqueue and dequeue in C
• Balanced Binary Search Trees 
• c# interview questions

 

Recommended problems -

• Maximum sum subarray of size k
• Max circular subarray sum
• Subarray sums divisible by k
• Shortest subarray with sum at least k
• Search In Rotated Sorted Array

 

Please refer to our guided paths on Coding Ninjas Studio to learn more about DSA, Competitive Programming, JavaScript, System Design, etc. And also, enroll in our courses and refer to the mock test and problems available. Have a look at the interview experiences and interview bundle for placement preparations.

Keep learning, and Keep Growing!

Happy Coding!