expressions de valeur par défaut (référence C#)default value expressions (C# reference)

Une expression de valeur par défaut produit la valeur par défaut d’un type.A default value expression produces the default value of a type. Il existe deux types d’expressions de valeur par défaut : l’appel d' opérateur par défaut et un littéral par défaut.There are two kinds of default value expressions: the default operator call and a default literal.

Vous utilisez également le default mot clé comme étiquette de cas par défaut dans une switch instruction.You also use the default keyword as the default case label within a switch statement.

Opérateur defaultdefault operator

L’argument de l’opérateur default doit avoir le nom d’un type ou d’un paramètre de type, comme le montre l’exemple suivant :The argument to the default operator must be the name of a type or a type parameter, as the following example shows:

Console.WriteLine(default(int));  // output: 0
Console.WriteLine(default(object) is null);  // output: True

void DisplayDefaultOf<T>()
{
    var val = default(T);
    Console.WriteLine($"Default value of {typeof(T)} is {(val == null ? "null" : val.ToString())}.");
}

DisplayDefaultOf<int?>();
DisplayDefaultOf<System.Numerics.Complex>();
DisplayDefaultOf<System.Collections.Generic.List<int>>();
// Output:
// Default value of System.Nullable`1[System.Int32] is null.
// Default value of System.Numerics.Complex is (0, 0).
// Default value of System.Collections.Generic.List`1[System.Int32] is null.

littéral par défautdefault literal

À partir de C# 7.1, vous pouvez utiliser le littéral default pour produire la valeur par défaut d'un type lorsque le compilateur peut déduire le type d'expression.Beginning with C# 7.1, you can use the default literal to produce the default value of a type when the compiler can infer the expression type. L’expression littérale default génère la même valeur que l’expression default(T), où T est le type déduit.The default literal expression produces the same value as the default(T) expression where T is the inferred type. Vous pouvez utiliser le littéral default dans les cas suivants :You can use the default literal in any of the following cases:

L’exemple suivant illustre l’utilisation du littéral default :The following example shows the usage of the default literal:

T[] InitializeArray<T>(int length, T initialValue = default)
{
    if (length < 0)
    {
        throw new ArgumentOutOfRangeException(nameof(length), "Array length must be nonnegative.");
    }

    var array = new T[length];
    for (var i = 0; i < length; i++)
    {
        array[i] = initialValue;
    }
    return array;
}

void Display<T>(T[] values) => Console.WriteLine($"[ {string.Join(", ", values)} ]");

Display(InitializeArray<int>(3));  // output: [ 0, 0, 0 ]
Display(InitializeArray<bool>(4, default));  // output: [ False, False, False, False ]

System.Numerics.Complex fillValue = default;
Display(InitializeArray(3, fillValue));  // output: [ (0, 0), (0, 0), (0, 0) ]

spécification du langage C#C# language specification

Pour plus d’informations, voir la section Expressions de valeur par défaut de la spécification du langage C#.For more information, see the Default value expressions section of the C# language specification.

Pour plus d’informations sur le littéral default, voir la proposition de fonctionnalité.For more information about the default literal, see the feature proposal note.

Voir aussiSee also