Nouvel opérateur : l’opérateur new crée une nouvelle instance d’un type

  • Article

L’opérateur new crée une nouvelle instance d’un type. Vous pouvez également utiliser le mot clé new comme modificateur de déclaration de membre ou contrainte de type générique.

Appel du constructeur

Pour créer une nouvelle instance d’un type, vous appelez généralement l’un des constructeurs de ce type, à l’aide de l’opérateur new :

var dict = new Dictionary<string, int>();
dict["first"] = 10;
dict["second"] = 20;
dict["third"] = 30;

Console.WriteLine(string.Join("; ", dict.Select(entry => $"{entry.Key}: {entry.Value}")));
// Output:
// first: 10; second: 20; third: 30

Vous pouvez utiliser un initialiseur d’objet ou de collection avec l’opérateur new pour instancier et initialiser un objet dans une instruction, comme dans l’exemple suivant :

var dict = new Dictionary<string, int>
{
    ["first"] = 10,
    ["second"] = 20,
    ["third"] = 30
};

Console.WriteLine(string.Join("; ", dict.Select(entry => $"{entry.Key}: {entry.Value}")));
// Output:
// first: 10; second: 20; third: 30

Type cible new

Les expressions d’appel de constructeur sont typées par cible. Autrement dit, si un type cible d’une expression est connu, vous pouvez omettre un nom de type, comme l’illustre l’exemple suivant :

List<int> xs = new();
List<int> ys = new(capacity: 10_000);
List<int> zs = new() { Capacity = 20_000 };

Dictionary<int, List<int>> lookup = new()
{
    [1] = new() { 1, 2, 3 },
    [2] = new() { 5, 8, 3 },
    [5] = new() { 1, 0, 4 }
};

Comme l’illustre l’exemple précédent, vous utilisez toujours des parenthèses dans une expression new typée par cible.

Si le type cible d’une expression new est inconnu (par exemple, lorsque vous utilisez le mot clé var), vous devez spécifier un nom de type.

Création de tableau

Vous utilisez également l’opérateur new pour créer une instance de tableau, comme dans l’exemple suivant :

var numbers = new int[3];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
Console.WriteLine(string.Join(", ", numbers));
// Output:
// 10, 20, 30

Utilisez la syntaxe d’initialisation de tableau pour créer une instance de tableau et la remplir avec des éléments dans une instruction. L’exemple suivant montre différentes façons de procéder :

var a = new int[3] { 10, 20, 30 };
var b = new int[] { 10, 20, 30 };
var c = new[] { 10, 20, 30 };
Console.WriteLine(c.GetType());  // output: System.Int32[]

Pour plus d’informations sur les tableaux, consultez Tableaux.

Instanciation des types anonymes

Pour créer une instance d’un type anonyme, utilisez l’opérateur new et la syntaxe d’initialiseur d’objet :

var example = new { Greeting = "Hello", Name = "World" };
Console.WriteLine($"{example.Greeting}, {example.Name}!");
// Output:
// Hello, World!

Destruction des instances de type

Vous n’êtes pas obligé de détruire les instances de type précédemment créées. Les instances de types référence et valeur sont détruites automatiquement. Les instances de types valeur sont détruites dès que le contexte dans lequel elles se trouvent est détruit. Les instances de types référence sont détruites par le récupérateur de mémoire à un moment non spécifié, après la suppression de la dernière référence à celles-ci.

Pour les instances de type qui contiennent des ressources non managées, par exemple, un descripteur de fichier, il est recommandé d’utiliser le nettoyage déterministe pour s’assurer que les ressources qu’elles contiennent sont publiées dès que possible. Pour plus d’informations, consultez la référence d’API System.IDisposable et l’article using, instruction.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger l’opérateur new.

spécification du langage C#

Pour plus d’informations, consultez la section Opérateur new de la spécification du langage C#.

Pour plus d’informations sur une expression new typée par cible, consultez la note de proposition de fonctionnalité.

Voir aussi