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

The foreach loop is a control structure in C# that makes it easier to iterate over elements of a collection or sequence of data, such as arrays, lists, or sets.

Unlike the 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 foreach loop syntax is clearer and more concise, making it easier to understand and maintain the code.

Also, by not depending on indexes, the possibility of making mistakes when accessing elements of the collection is reduced.

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 of 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 are the instructions that are executed in each iteration. These instructions can be any type of valid C# code, such as assignments, calculations, method calls, etc.

Basic Example

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

Collection immutability

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

Trying to add or remove elements from the collection inside the foreach loop will result in an InvalidOperationException exception.

When you need to modify the collection while iterating, a for or while loop may be more suitable.

Use on custom collections

It is possible to use foreach with collections created by us. For this, it is necessary that our collection implements 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.

That is the only requirement for the foreach loop to work.

Performance considerations

Although foreach is extremely useful, it might 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 gives rise to certain optimizations performed by the compiler, which are not available in other collections.

In any case, the difference is almost negligible. In most cases, readability is preferred over efficiency. Only in cases where a computation is repeated many (millions and millions) of times, it could justify choosing one over the other for performance criteria. And, in this case, you would have to check both methods.

Practical Examples of FOREACH Loop

Traverse a list of numbers

Suppose we have a list of integers and we want to print each of them in 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);
}

Iterate 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 = { "John", "Mary", "Peter" };

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 adds up 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.

Iteration over Arrays

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

string[] names = { "John", "Mary", "Carlos", "Ana" };

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

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

Iteration 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.

Iteration over Custom Collections

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

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "John", 30 },
    { "Mary", 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.