Salir de un bucle Foreach en C#

Para detener un bucle foreach de C# cuando se cumple una condición, usa break. Esta instrucción termina el bucle envolvente más cercano y continúa con la primera instrucción que aparece después de él. Usa return cuando también deba finalizar el método que contiene el bucle. En bucles anidados, guarda la condición en una variable de estado al salir del bucle interno y luego usa break para salir del bucle externo.

Usa break para salir del bucle

Este ejemplo busca el valor 4 en una lista. La comprobación se realiza antes de imprimir, por lo que el bucle no procesa el valor coincidente ni los elementos posteriores. El ejemplo imprime cada valor anterior a 4 y luego continúa con la instrucción que sigue al bucle.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

        foreach (int number in numbers)
        {
            if (number == 4)
            {
                break;
            }

            Console.WriteLine(number);
        }

        Console.WriteLine("Loop finished");
    }
}

1
2
3
Loop finished

break solo sale del bucle envolvente más cercano. A continuación, la ejecución llega a Console.WriteLine("Loop finished"), que está después del bucle. En un foreach, la iteración recorre una secuencia enumerable; el ejemplo usa una List<int>. Coloca la condición antes del trabajo que quieras omitir para el elemento coincidente. Si la colocas después, ese elemento se procesará antes de que termine el bucle.

return sale del método que contiene el bucle

Elige return cuando alcanzar la condición signifique que el método debe dejar de realizar todo el trabajo restante. El ejemplo imprime cada valor anterior a 4 y luego vuelve a Main.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        PrintBeforeFour(new List<int> { 1, 2, 3, 4, 5, 6 });
        Console.WriteLine("Back in Main");
    }

    static void PrintBeforeFour(List<int> numbers)
    {
        foreach (int number in numbers)
        {
            if (number == 4)
            {
                return;
            }

            Console.WriteLine(number);
        }

        Console.WriteLine("Method finished after the loop");
    }
}

1
2
3
Back in Main

Cuando se ejecuta return dentro de PrintBeforeFour, el control vuelve al método que hizo la llamada, por lo que se omite la instrucción posterior de PrintBeforeFour. Después, Main continúa con la instrucción que sigue a la llamada. Esto es distinto de break, que sale del bucle, pero continúa dentro del mismo método. Si un método devuelve un valor, cada ruta de ejecución también debe proporcionar un valor del tipo de retorno declarado; un método void puede usar return sin un valor.

Usa una variable de estado para salir de bucles anidados

Un break dentro de un bucle interno solo sale de ese bucle. Si encontrar una coincidencia allí también debe detener un foreach externo, guarda ese resultado en una variable de estado y comprueba su valor después del bucle interno. El ejemplo imprime valores hasta 4 y luego detiene ambos bucles.

using System;

class Program
{
    static void Main()
    {
        int[][] rows =
        {
            new[] { 1, 2 },
            new[] { 3, 4 },
            new[] { 5, 6 }
        };
        bool found = false;

        foreach (int[] row in rows)
        {
            foreach (int value in row)
            {
                Console.WriteLine(value);
                if (value == 4)
                {
                    found = true;
                    break;
                }
            }

            if (found)
            {
                break;
            }
        }

        Console.WriteLine("Search finished");
    }
}

1
2
3
4
Search finished

El break interno deja de recorrer la fila actual. La variable de estado conserva el valor true después de ese bucle, lo que permite que el bucle externo se detenga cuando llegue a su siguiente comprobación. El valor 4 se imprime porque el ejemplo imprime cada valor antes de comprobarlo; mueve la comprobación al principio si no quieres imprimir el valor coincidente. Una variable de estado resulta útil cuando la decisión surge en una lógica anidada y el bucle externo debe responder. Si la condición se comprueba directamente en el bucle externo, un break simple es más claro.

Elige la instrucción de salida adecuada

Usa break para terminar el bucle actual y continuar con el método. Usa return para terminar también el método que contiene el bucle. Usa una variable de estado cuando un bucle interno determine que debe detenerse el bucle externo. Si solo necesitas omitir el resto de la iteración actual y pasar al siguiente elemento, usa continue; esta instrucción no termina el bucle. Estas son instrucciones de control de flujo de C#, no llamadas a métodos. Elige la instrucción cuyo alcance corresponda al trabajo que quieras detener y coloca la condición antes o después del procesamiento según si debe procesarse el elemento coincidente.