What is and how to use the FOREACH loop in C#

The foreach loop is a control structure in C# that facilitates iterating over elements of a collection or data sequence (such as arrays, lists, or sets).

Unlike for, while, and do-while loops, the foreach loop is specifically used to iterate over each element of a collection without the need to manipulate an index or control variable.

The foreach loop offers several advantages over other traditional loops. The syntax of the foreach loop is clearer and more concise (which makes it easier to understand and maintain the code).

Additionally, by not depending on indices, it reduces the possibility of making errors when accessing elements of the collection.

The basic syntax of a foreach loop in C# is as follows:

foreach (type variable in collection)
{
    // Code to execute for each element of the collection
}

• Type: It is the data type of the elements in the collection.
• Variable: It is the name of the variable that represents each element in the iteration.
• Collection: It is the collection from which the elements will be iterated.
• Instructions to execute: Here, you specify the instructions that are executed in each iteration. These instructions can be any valid code in C#, such as assignments, calculations, method calls, etc.

Basic Example

Let’s consider a simple example where a foreach loop is used to iterate over an array of numbers:

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

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

This foreach loop will print each number in the numbers array on a separate line.

FOREACH Loop Considerations

Immutability of the Collection

One limitation of the foreach loop is that it does not allow modifying the collection being iterated.

Attempting to add or remove elements from the collection within the foreach loop will result in an InvalidOperationException.

When it is necessary to modify the collection during iteration, a for or while loop may be more suitable.

Use in Custom Collections

It is possible to use foreach with collections created by us. To do so, it is necessary for our collection to implement the IEnumerable or IEnumerable<T> interface.

This means providing an implementation of the GetEnumerator method that returns an iterator over the elements of the collection.

Performance Considerations

Although foreach is extremely useful, it may be slightly slower than the equivalent for or while loop. This is because foreach must obtain the Enumerator and call its methods to traverse the collection.

However, the foreach loop also allows for certain optimizations performed by the compiler that are not available in other collections.

Practical Examples of the FOREACH Loop

Iterating Over a List of Numbers

Suppose we have a list of integers and want to print each of them to the console. Using the foreach loop, the code would be as follows:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

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

Iterating Over an Array of Strings

If we have an array of strings and want to perform some operation on each of them, the foreach loop is the ideal option. For example, if we want to convert all strings to uppercase, we can do it as follows:

string[] names = { "Luis", "María", "Pedro" };

foreach (string name in names)
{
    Console.WriteLine(name.ToUpper());
}

Sum of Elements in a List

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int sum = 0;

foreach (int number in numbers)
{
    sum += number;
}

Console.WriteLine($"The sum of the numbers is: {sum}");

This foreach loop sums all the elements in the numbers list.

Searching for an Element in an Array

int[] numbers = { 10, 20, 30, 40, 50 };
int search = 30;
bool found = false;

foreach (int number in numbers)
{
    if (number == search)
    {
        found = true;
        break;
    }
}

if (found)
{
    Console.WriteLine($"The number {search} is in the array.");
}
else
{
    Console.WriteLine($"The number {search} is not in the array.");
}

This foreach loop searches for a specific number in the numbers array and determines if it is present.

Iterating Over Arrays

The foreach loop is especially useful for iterating over elements in an array:

string[] names = { "Luis", "María", "Carlos", "Ana" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

This foreach loop will print each name in the names array.

Iterating Over Lists

The foreach loop can also be used to iterate over elements in a list:

List<int> numbers = new List<int> { 10, 20, 30, 40, 50 };

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

This foreach loop will print each number in the numbers list.

Iterating Over Custom Collections

The foreach loop can also be used with custom collections that implement the IEnumerable interface. This includes classes like Dictionary, HashSet, and Queue.

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Luis", 30 },
    { "María", 25 },
    { "Carlos", 40 }
};

foreach (KeyValuePair<string, int> entry in ages)
{
    Console.WriteLine($"Name: {entry.Key}, Age: {entry.Value}");
}

This foreach loop will print each key-value pair in the ages dictionary.