C# - Loop Over Arrays

Loop Over Arrays in C#

Arrays are one of the fundamental data structures in C#, allowing storage of multiple elements of the same type in a contiguous memory block. Looping over arrays is essential to access or manipulate each element efficiently. C# provides various looping constructs to iterate through arrays, each with unique advantages and typical use cases.

Table of Contents

• Introduction to Arrays and Looping
• Array Basics in C#
• The For Loop
• The Foreach Loop
• While and Do-While Loops
• Nested Loops for Multidimensional Arrays
• Common Looping Patterns
• Performance Considerations
• Advanced Looping Techniques
• Real World Examples

Introduction to Arrays and Looping

An array in C# is a fixed-size, zero-based indexed collection of elements of the same type. Once declared, the size of an array cannot change. Accessing each element individually requires iterating or "looping" over it.

Looping constructs help automate repetitive access and modification of array elements. Understanding different loop types and their applicability improves code clarity, efficiency, and maintainability.

Why Loop Over Arrays?

• Read or process each element.
• Search for specific elements.
• Modify array values based on logic.
• Aggregate data like sums or averages.
• Print or display array contents.

Array Basics in C#

Before diving into looping, let's review some basics about arrays.

Declaring and Initializing Arrays

// Declare an integer array with 5 elements
int[] numbers = new int[5];

// Initialize with values
int[] primes = { 2, 3, 5, 7, 11 };

// Declare and initialize with new keyword
string[] fruits = new string[] { "apple", "banana", "cherry" };

Accessing Array Elements

Array elements are accessed via zero-based indices:

int firstPrime = primes[0]; // 2
string firstFruit = fruits[0]; // "apple"

Properties of Arrays

• Length: Gets the total number of elements.
• Rank: Gets the number of dimensions (useful for multidimensional arrays).

int length = primes.Length; // 5

The For Loop

The for loop is the most common loop used to iterate arrays because it provides direct control over the index.

Basic Syntax

for (int i = 0; i < array.Length; i++)
{
    // Access element at index i
    var element = array[i];
    // Process element
}

Example: Loop Over Integer Array

int[] numbers = { 1, 2, 3, 4, 5 };

for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine($"Element at index {i} is {numbers[i]}");
}

Advantages of For Loop

• Full control over the index variable.
• Ability to manipulate index (increment, decrement, jump steps).
• Ideal for arrays where index position matters.

Modifying Array Elements Using For Loop

for (int i = 0; i < numbers.Length; i++)
{
    numbers[i] *= 2;  // Double each element
}

Common Variations

• Iterating backwards:

for (int i = numbers.Length - 1; i >= 0; i--)
{
    Console.WriteLine(numbers[i]);
}

• Skipping elements:

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

The Foreach Loop

The foreach loop is specifically designed for iterating over collections like arrays, lists, and other enumerable types.

Basic Syntax

foreach (var element in array)
{
    // Use element directly
}

Example: Foreach Loop Over String Array

string[] fruits = { "apple", "banana", "cherry" };

foreach (var fruit in fruits)
{
    Console.WriteLine(fruit);
}

Advantages of Foreach

• More readable and less error-prone since no index management.
• Automatically iterates over all elements.
• Works with any IEnumerable, not just arrays.

Limitations of Foreach

• Cannot modify the elements of the array directly (read-only access to elements).
• No access to element index unless you maintain a separate counter.

Using Foreach with Index Tracking

int index = 0;
foreach (var fruit in fruits)
{
    Console.WriteLine($"Element {index}: {fruit}");
    index++;
}

While and Do-While Loops

While loops are less commonly used for array iteration but can be useful in certain scenarios.

While Loop Syntax

int i = 0;
while (i < array.Length)
{
    var element = array[i];
    i++;
}

Example: While Loop Over Array

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

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

Do-While Loop Syntax

int i = 0;
do
{
    var element = array[i];
    i++;
} while (i < array.Length);

Use Cases for While and Do-While

• When looping depends on an external condition.
• Do-While guarantees at least one iteration.
• Less frequently used for simple array iteration compared to for or foreach.

Nested Loops for Multidimensional Arrays

C# supports multidimensional arrays (rectangular arrays) and jagged arrays (arrays of arrays). Looping over these requires nested loops.

Rectangular (Multidimensional) Arrays

int[,] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

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

Jagged Arrays (Array of Arrays)

int[][] jagged = new int[][]
{
    new int[] {1, 2, 3},
    new int[] {4, 5},
    new int[] {6, 7, 8, 9}
};

for (int i = 0; i < jagged.Length; i++)
{
    for (int j = 0; j < jagged[i].Length; j++)
    {
        Console.Write(jagged[i][j] + " ");
    }
    Console.WriteLine();
}

Common Looping Patterns

Searching in Arrays

int[] numbers = { 10, 20, 30, 40 };
int target = 30;
int index = -1;

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == target)
    {
        index = i;
        break; // Stop after finding first occurrence
    }
}
Console.WriteLine(index); // Output: 2

Summing Array Elements

int[] numbers = { 1, 2, 3, 4, 5 };
int sum = 0;

foreach (var num in numbers)
{
    sum += num;
}
Console.WriteLine($"Sum: {sum}"); // 15

Filtering Elements

int[] numbers = { 1, 2, 3, 4, 5, 6 };
List evens = new List();

foreach (var num in numbers)
{
    if (num % 2 == 0)
    {
        evens.Add(num);
    }
}
Console.WriteLine(string.Join(", ", evens)); // 2, 4, 6

Transforming Arrays

int[] numbers = { 1, 2, 3 };
int[] doubled = new int[numbers.Length];

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

Console.WriteLine(string.Join(", ", doubled)); // 2, 4, 6

Example: Caching Length in For Loop

int[] array = { 1, 2, 3, 4, 5 };
int len = array.Length;

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

Advanced Looping Techniques

Using LINQ to Loop Over Arrays

While LINQ is more declarative, it internally loops over arrays.

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var n in evenNumbers)
{
    Console.WriteLine(n);
}

Parallel Looping with Parallel.For

For CPU-intensive operations on large arrays, parallel loops can improve performance by utilizing multiple threads.

int[] numbers = new int[1000];

// Initialize array
for (int i = 0; i < numbers.Length; i++)
{
    numbers[i] = i;
}

// Parallel processing
System.Threading.Tasks.Parallel.For(0, numbers.Length, i =>
{
    numbers[i] = numbers[i] * numbers[i];  // square each element
});

Span<T> and Memory<T> for Array Slicing

C# 7.2+ introduced Span<T>, a memory-safe and efficient way to create slices (sub-arrays) without copying data. You can loop over spans like arrays.

int[] numbers = { 1, 2, 3, 4, 5 };
Span<int> slice = numbers.AsSpan(1, 3);  // Slice from index 1, length 3

foreach (var n in slice)
{
    Console.WriteLine(n); // Outputs 2, 3, 4
}

Real World Examples

Example 1: Printing User Scores

int[] scores = { 85, 92, 78, 90, 100 };

for (int i = 0; i < scores.Length; i++)
{
    Console.WriteLine($"User {i + 1}: Score = {scores[i]}");
}

Example 2: Finding Max Value in Array

int[] values = { 5, 12, 9, 21, 7 };
int max = values[0];

foreach (var val in values)
{
    if (val > max)
        max = val;
}
Console.WriteLine($"Maximum value: {max}");

Example 3: Counting Occurrences

string[] words = { "apple", "banana", "apple", "orange", "banana", "apple" };
Dictionary<string, int> counts = new Dictionary<string, int>();

foreach (var word in words)
{
    if (counts.ContainsKey(word))
        counts[word]++;
    else
        counts[word] = 1;
}

foreach (var pair in counts)
{
    Console.WriteLine($"{pair.Key}: {pair.Value}");
}

Looping over arrays in C# is a foundational skill for any developer. Understanding the available looping constructs and their best use cases helps you write efficient, clear, and maintainable code.

Key points covered:

• Arrays store multiple elements; loops help access and modify them efficiently.
• The for loop provides index control and is suited for modifying arrays.
• The foreach loop offers readability and ease of use but is read-only for arrays.
• While and do-while loops can also iterate but are less common for arrays.
• Nested loops are essential for multidimensional and jagged arrays.
• Looping patterns include searching, summing, filtering, and transforming arrays.
• Performance can be improved by caching array lengths and considering parallel loops for large data.
• Advanced techniques use LINQ, parallel loops, and Span<T> for efficient slicing.

Mastering these techniques allows you to work confidently with arrays in any C# application, from simple scripts to complex, high-performance systems.