Instructions de saut (référence C#)

Les instructions suivantes transfèrent le contrôle de manière inconditionnelle :

Pour plus d’informations sur l' throw instruction qui lève une exception et qui transfère également le contrôle de manière non conditionnelle, consultez throw.

Instruction break

L' break instruction met fin à l’instruction d' itération englobante la plus proche (c’est-à-dire,,, for foreach while ou do Loop) ou à l' switch instruction. L' break instruction transfère le contrôle à l’instruction qui suit l’instruction terminée, le cas échéant.

int[] numbers = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
foreach (int number in numbers)
{
    if (number == 3)
    {
        break;
    }

    Console.Write($"{number} ");
}
Console.WriteLine();
Console.WriteLine("End of the example.");
// Output:
// 0 1 2 
// End of the example.

Dans les boucles imbriquées, l' break instruction met fin uniquement à la boucle la plus profonde qui la contient, comme le montre l’exemple suivant :

for (int outer = 0; outer < 5; outer++)
{
    for (int inner = 0; inner < 5; inner++)
    {
        if (inner > outer)
        {
            break;
        }

        Console.Write($"{inner} ");
    }
    Console.WriteLine();
}
// Output:
// 0
// 0 1
// 0 1 2
// 0 1 2 3
// 0 1 2 3 4

Lorsque vous utilisez l' switch instruction à l’intérieur d’une boucle, une break instruction à la fin d’une section switch transfère le contrôle uniquement en dehors de l' switch instruction. La boucle qui contient l' switch instruction n’est pas affectée, comme le montre l’exemple suivant :

double[] measurements = { -4, 5, 30, double.NaN };
foreach (double measurement in measurements)
{
    switch (measurement)
    {
        case < 0.0:
            Console.WriteLine($"Measured value is {measurement}; too low.");
            break;

        case > 15.0:
            Console.WriteLine($"Measured value is {measurement}; too high.");
            break;

        case double.NaN:
            Console.WriteLine("Failed measurement.");
            break;

        default:
            Console.WriteLine($"Measured value is {measurement}.");
            break;
    }
}
// Output:
// Measured value is -4; too low.
// Measured value is 5.
// Measured value is 30; too high.
// Failed measurement.

Instruction continue

L' continue instruction démarre une nouvelle itération de l' instruction d’itération englobante la plus proche (c’est-à-dire,,, for foreach while ou do Loop), comme le montre l’exemple suivant :

for (int i = 0; i < 5; i++)
{
    Console.Write($"Iteration {i}: ");
    
    if (i < 3)
    {
        Console.WriteLine("skip");
        continue;
    }
    
    Console.WriteLine("done");
}
// Output:
// Iteration 0: skip
// Iteration 1: skip
// Iteration 2: skip
// Iteration 3: done
// Iteration 4: done

Instruction return

L' return instruction termine l’exécution de la fonction dans laquelle elle apparaît et retourne le contrôle et le résultat de la fonction, le cas échéant, à l’appelant.

Si un membre de fonction ne calcule pas de valeur, vous utilisez l' return instruction sans expression, comme le montre l’exemple suivant :

Console.WriteLine("First call:");
DisplayIfNecessary(6);

Console.WriteLine("Second call:");
DisplayIfNecessary(5);

void DisplayIfNecessary(int number)
{
    if (number % 2 == 0)
    {
        return;
    }

    Console.WriteLine(number);
}
// Output:
// First call:
// Second call:
// 5

Comme le montre l’exemple précédent, vous utilisez généralement l' return instruction sans expression pour mettre fin à une fonction membre tôt. Si un membre de fonction ne contient pas l' return instruction, il se termine après l’exécution de sa dernière instruction.

Si un membre de fonction calcule une valeur, vous utilisez l' return instruction avec une expression, comme le montre l’exemple suivant :

double surfaceArea = CalculateCylinderSurfaceArea(1, 1);
Console.WriteLine($"{surfaceArea:F2}"); // output: 12.57

double CalculateCylinderSurfaceArea(double baseRadius, double height)
{
    double baseArea = Math.PI * baseRadius * baseRadius;
    double sideArea = 2 * Math.PI * baseRadius * height;
    return 2 * baseArea + sideArea;
}

Lorsque l' return instruction a une expression, cette expression doit être implicitement convertible en type de retour d’une fonction membre, sauf si elle est asynchrone. Dans le cas d’une async fonction, l’expression doit être implicitement convertible en l’argument de type Task<TResult> de ou ValueTask<TResult> , selon le type de retour de la fonction. Si le type de retour d’une async fonction est Task ou ValueTask , vous utilisez l' return instruction sans expression.

Par défaut, l' return instruction retourne la valeur d’une expression. À compter de C# 7,0, vous pouvez retourner une référence à une variable. Pour ce faire, utilisez l' return instruction avec le ref mot clé, comme le montre l’exemple suivant :

var xs = new int[] { 10, 20, 30, 40 };
ref int found = ref FindFirst(xs, s => s == 30);
found = 0;
Console.WriteLine(string.Join(" ", xs));  // output: 10 20 0 40

ref int FindFirst(int[] numbers, Func<int, bool> predicate)
{
    for (int i = 0; i < numbers.Length; i++)
    {
        if (predicate(numbers[i]))
        {
            return ref numbers[i];
        }
    }
    throw new InvalidOperationException("No element satisfies the given condition.");
}

Pour plus d’informations sur les retours REF, consultez ref Returns et ref variables locales.

Instruction goto

L' goto instruction transfère le contrôle à une instruction marquée par une étiquette, comme le montre l’exemple suivant :

var matrices = new Dictionary<string, int[][]>
{
    ["A"] = new[]
    {
        new[] { 1, 2, 3, 4 },
        new[] { 4, 3, 2, 1 }
    },
    ["B"] = new[]
    {
        new[] { 5, 6, 7, 8 },
        new[] { 8, 7, 6, 5 }
    },
};

CheckMatrices(matrices, 4);

void CheckMatrices(Dictionary<string, int[][]> matrixLookup, int target)
{
    foreach (var (key, matrix) in matrixLookup)
    {
        for (int row = 0; row < matrix.Length; row++)
        {
            for (int col = 0; col < matrix[row].Length; col++)
            {
                if (matrix[row][col] == target)
                {
                    goto Found;
                }
            }
        }
        Console.WriteLine($"Not found {target} in matrix {key}.");
        continue;

    Found:
        Console.WriteLine($"Found {target} in matrix {key}.");
    }
}
// Output:
// Found 4 in matrix A.
// Not found 4 in matrix B.

Comme le montre l’exemple précédent, vous pouvez utiliser l' goto instruction pour sortir d’une boucle imbriquée.

Conseil

Lorsque vous travaillez avec des boucles imbriquées, envisagez de refactoriser des boucles distinctes en différentes méthodes. Cela peut entraîner un code plus simple et plus lisible sans l' goto instruction.

Vous pouvez également utiliser l' goto instruction dans l' switch instruction pour transférer le contrôle à une section switch avec une étiquette case constante, comme le montre l’exemple suivant :

using System;

public enum CoffeChoice
{
    Plain,
    WithMilk,
    WithIceCream,
}

public class GotoInSwitchExample
{
    public static void Main()
    {
        Console.WriteLine(CalculatePrice(CoffeChoice.Plain));  // output: 10.0
        Console.WriteLine(CalculatePrice(CoffeChoice.WithMilk));  // output: 15.0
        Console.WriteLine(CalculatePrice(CoffeChoice.WithIceCream));  // output: 17.0
    }

    private static decimal CalculatePrice(CoffeChoice choice)
    {
        decimal price = 0;
        switch (choice)
        {
            case CoffeChoice.Plain:
                price += 10.0m;
                break;

            case CoffeChoice.WithMilk:
                price += 5.0m;
                goto case CoffeChoice.Plain;

            case CoffeChoice.WithIceCream:
                price += 7.0m;
                goto case CoffeChoice.Plain;
        }
        return price;
    }
}

Dans l' switch instruction, vous pouvez également utiliser l’instruction goto default; pour transférer le contrôle à la section switch avec l' default étiquette.

Si une étiquette portant le nom spécifié n’existe pas dans le membre de fonction actuel, ou si l' goto instruction n’est pas dans la portée de l’étiquette, une erreur de compilation se produit. Autrement dit, vous ne pouvez pas utiliser l' goto instruction pour transférer le contrôle hors du membre de la fonction en cours ou dans une portée imbriquée, par exemple un try bloc.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

Voir aussi