new, opérateur (Référence C#)

L’opérateur new crée une nouvelle instance d’un type.

Vous pouvez également utiliser le mot clé new comme new 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  :

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

À compter de C# 9,0, les expressions d’appel de constructeur sont de type cible. Autrement dit, si un type cible d’une expression est connu, vous pouvez omettre un nom de type, comme le montre 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 le montre l’exemple précédent, vous utilisez toujours des parenthèses dans une expression de type new cible.

Si le type cible d’une new expression est inconnu (par exemple, lorsque vous utilisez le var mot clé), 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 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 garbage collector à une heure non spécifiée après la suppression de la dernière référence.

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’ils contiennent sont libérées dès que possible. Pour plus d’informations, consultez la référence d’API System.IDisposable et l’article System.IDisposable.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur ne peut pas 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 de type new cible, consultez la newà la proposition de fonctionnalité.

Voir aussi