How to add items/elements to an existing jagged array in C#?

Adding items to an existing jagged array in C# can be accomplished through several methods. You can modify individual elements directly, replace entire sub-arrays, or dynamically resize arrays using collections. The approach depends on whether you want to change existing elements or expand the array structure.

Understanding Jagged Arrays

A jagged array is an array of arrays where each sub-array can have different lengths. Unlike multidimensional arrays, jagged arrays provide flexibility in storing data with varying row sizes.

Syntax

To modify an existing element in a jagged array −

arrayName[rowIndex][columnIndex] = newValue;

To replace an entire sub-array −

arrayName[rowIndex] = new int[] { value1, value2, value3 };

Modifying Individual Elements

The most straightforward way to add or change an item is to assign a new value to a specific position −

using System;

class Program {
   static void Main(string[] args) {
      int[][] jaggedArray = new int[][] {
         new int[] {10, 20},
         new int[] {30, 40, 50},
         new int[] {60},
         new int[] {70, 80}
      };

      Console.WriteLine("Original Array:");
      DisplayArray(jaggedArray);

      // Modify existing element
      jaggedArray[2][0] = 500;
      jaggedArray[1][2] = 999;

      Console.WriteLine("\nAfter modifying elements:");
      DisplayArray(jaggedArray);
   }

   static void DisplayArray(int[][] arr) {
      for (int i = 0; i < arr.Length; i++) {
         for (int j = 0; j < arr[i].Length; j++) {
            Console.WriteLine("arr[{0}][{1}] = {2}", i, j, arr[i][j]);
         }
      }
   }
}

The output of the above code is −

Original Array:
arr[0][0] = 10
arr[0][1] = 20
arr[1][0] = 30
arr[1][1] = 40
arr[1][2] = 50
arr[2][0] = 60
arr[3][0] = 70
arr[3][1] = 80

After modifying elements:
arr[0][0] = 10
arr[0][1] = 20
arr[1][0] = 30
arr[1][1] = 40
arr[1][2] = 999
arr[2][0] = 500
arr[3][0] = 70
arr[3][1] = 80

Replacing Entire Sub-Arrays

You can replace an entire row by assigning a new array to that position −

using System;

class Program {
   static void Main(string[] args) {
      int[][] jaggedArray = new int[][] {
         new int[] {1, 2},
         new int[] {3, 4, 5},
         new int[] {6}
      };

      Console.WriteLine("Before replacement:");
      for (int i = 0; i < jaggedArray.Length; i++) {
         Console.Write("Row " + i + ": ");
         for (int j = 0; j < jaggedArray[i].Length; j++) {
            Console.Write(jaggedArray[i][j] + " ");
         }
         Console.WriteLine();
      }

      // Replace entire sub-array
      jaggedArray[1] = new int[] {100, 200, 300, 400, 500};

      Console.WriteLine("\nAfter replacement:");
      for (int i = 0; i < jaggedArray.Length; i++) {
         Console.Write("Row " + i + ": ");
         for (int j = 0; j < jaggedArray[i].Length; j++) {
            Console.Write(jaggedArray[i][j] + " ");
         }
         Console.WriteLine();
      }
   }
}

The output of the above code is −

Before replacement:
Row 0: 1 2 
Row 1: 3 4 5 
Row 2: 6 

After replacement:
Row 0: 1 2 
Row 1: 100 200 300 400 500 
Row 2: 6 

Using Collections for Dynamic Expansion

For truly dynamic arrays that can grow in size, consider using List<List<int>> instead of jagged arrays −

using System;
using System.Collections.Generic;

class Program {
   static void Main(string[] args) {
      List<List<int>> dynamicArray = new List<List<int>> {
         new List<int> {1, 2, 3},
         new List<int> {4, 5}
      };

      Console.WriteLine("Original dynamic array:");
      DisplayDynamicArray(dynamicArray);

      // Add element to existing row
      dynamicArray[0].Add(99);

      // Add new row
      dynamicArray.Add(new List<int> {10, 20, 30, 40});

      Console.WriteLine("\nAfter additions:");
      DisplayDynamicArray(dynamicArray);
   }

   static void DisplayDynamicArray(List<List<int>> arr) {
      for (int i = 0; i < arr.Count; i++) {
         Console.Write("Row " + i + ": ");
         for (int j = 0; j < arr[i].Count; j++) {
            Console.Write(arr[i][j] + " ");
         }
         Console.WriteLine();
      }
   }
}

The output of the above code is −

Original dynamic array:
Row 0: 1 2 3 
Row 1: 4 5 

After additions:
Row 0: 1 2 3 99 
Row 1: 4 5 
Row 2: 10 20 30 40 

Conclusion

Adding items to jagged arrays in C# involves either modifying existing elements directly or replacing entire sub-arrays with new ones. For scenarios requiring dynamic growth, consider using List<List<T>> collections which provide greater flexibility than fixed-size jagged arrays.