C# - Loop Over Arrays

Loop Over Arrays in C# 

Introduction to C# Arrays and Looping

In modern software development, understanding how to loop over arrays in C# is one of the most essential programming skills. Arrays are foundational data structures in C# programming, and looping allows developers to access, manipulate, and process array elements efficiently. Whether you are building enterprise applications using .NET, creating games with Unity, or developing web APIs using ASP.NET Core, mastering array iteration in C# is critical.

This comprehensive guide explains how to loop through arrays in C#, covering different loop types such as for loop, foreach loop, while loop, do-while loop, and advanced iteration techniques using LINQ. By the end of this tutorial, you will clearly understand C# array iteration, performance considerations, best practices, and real-world examples.

Understanding Arrays in C#

An array in C# is a fixed-size collection of elements of the same data type. Arrays are zero-indexed, meaning the first element starts at index 0. Arrays are stored in contiguous memory locations, making them efficient for direct access.

Declaring and Initializing Arrays

using System;

class Program
{
    static void Main()
    {
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
    }
}

Shortcut Initialization

int[] numbers = { 10, 20, 30, 40, 50 };

Now that we understand arrays, let’s explore how to loop through array in C# effectively.

Using the for Loop to Iterate Arrays in C#

The for loop is one of the most commonly used methods for C# array iteration. It provides full control over the index.

Syntax of for Loop

for (initialization; condition; increment)
{
    // Code block
}

C# for Loop Example

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };

        for (int i = 0; i < numbers.Length; i++)
        {
            Console.WriteLine(numbers[i]);
        }
    }
}

Explanation:

• numbers.Length returns total elements in array.
• Index starts from 0.
• Loop runs until index is less than array length.

The for loop is ideal when you need the index for operations such as modifying array values.

Using foreach Loop in C#

The C# foreach loop is designed specifically for iterating over collections like arrays. It simplifies syntax and improves readability.

Syntax of foreach Loop

foreach (dataType variable in arrayName)
{
    // Code block
}

Example: C# foreach Loop

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };

        foreach (int number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

Advantages of foreach:

• Cleaner syntax
• No risk of index out of range error
• Improved readability

However, foreach does not allow direct modification of array elements.

Using while Loop to Loop Over Arrays

The while loop checks condition before execution. It is less commonly used for array iteration but still important.

Example: while Loop

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };
        int i = 0;

        while (i < numbers.Length)
        {
            Console.WriteLine(numbers[i]);
            i++;
        }
    }
}

Using do-while Loop in C#

The do-while loop executes at least once before checking the condition.

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };
        int i = 0;

        do
        {
            Console.WriteLine(numbers[i]);
            i++;
        }
        while (i < numbers.Length);
    }
}

Multidimensional Array Iteration in C#

C# supports multidimensional arrays. Looping requires nested loops.

using System;

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

        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            for (int j = 0; j < matrix.GetLength(1); j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

Using LINQ for Array Iteration

Language Integrated Query (LINQ) provides modern and expressive ways to iterate arrays.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };

        var doubled = numbers.Select(n => n * 2);

        foreach (var num in doubled)
        {
            Console.WriteLine(num);
        }
    }
}

Performance Comparison of Loops in C#

When learning C# loop over arrays, understanding performance is important:

• for loop – Slightly faster in some scenarios
• foreach loop – Cleaner and safer
• while loop – Flexible but less common for arrays
• LINQ – More readable but slightly slower due to abstraction

For high-performance applications, especially in game development or real-time systems, traditional for loops are preferred.

Modifying Array Elements During Iteration

To modify elements, use for loop instead of foreach.

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };

        for (int i = 0; i < numbers.Length; i++)
        {
            numbers[i] = numbers[i] * 10;
        }

        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

Common Errors When Looping Through Arrays in C#

1. Index Out of Range Exception

for (int i = 0; i <= numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

The condition should be i < numbers.Length, not less than or equal.

2. Null Reference Exception

int[] numbers = null;
Console.WriteLine(numbers.Length);

Always check if array is null before iteration.

Real-World Example: Calculating Average

using System;

class Program
{
    static void Main()
    {
        int[] marks = { 80, 75, 90, 85, 70 };
        int sum = 0;

        foreach (int mark in marks)
        {
            sum += mark;
        }

        double average = (double)sum / marks.Length;
        Console.WriteLine("Average: " + average);
    }
}

When to Use Arrays vs List in C#

Arrays are fixed in size, while List provides dynamic resizing. If size is known and fixed, arrays are more memory-efficient. For dynamic collections, List is better.

Mastering C# array iteration is essential for any C# developer. Understanding how to loop through array in C# using for loop, foreach loop, while loop, and LINQ helps build efficient and clean programs. Each looping method has its use case, advantages, and performance implications.

Whether you are a beginner learning C# programming tutorial concepts or an experienced developer optimizing .NET applications, knowing how to properly iterate arrays in C# is fundamental to writing clean, efficient, and maintainable code.