PricingLoginStart free
C# Academy · Leçon

Expressions new dont le type est déduit du contexte

Simplifiez la création d’objets grâce à la déduction du type cible.

Leçon 4 sur 413 étapes

Expressions new dont le type est déduit du contexte est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

new typé selon la cible

Depuis C# 9, vous pouvez écrire Type x = new(); et omettre le type après new lorsque le type cible est connu.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<int> numbers = new();
        numbers.Add(1);
        Console.WriteLine(numbers.Count);
    }
}

Supprimer les redondances

Lorsque la variable indique déjà le type, le répéter après new est superflu. Le new() vide permet de l’éviter.

using System;
using System.Text;

class Program {
    static void Main() {
        StringBuilder sb = new();
        sb.Append("Hi");
        Console.WriteLine(sb.ToString());
    }
}

Transmettre des arguments au constructeur

Le new() typé selon la cible accepte toujours les arguments du constructeur entre les parenthèses.

using System;

class Point {
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
}
class Program {
    static void Main() {
        Point p = new(3, 4);
        Console.WriteLine(p.X + ", " + p.Y);
    }
}

Avec des initialiseurs d’objet

Vous pouvez combiner new typé selon la cible avec un bloc d’initialisation d’objet.

using System;

class User {
    public string Name;
    public int Age;
}
class Program {
    static void Main() {
        User u = new() { Name = "Ann", Age = 30 };
        Console.WriteLine(u.Name + " " + u.Age);
    }
}

Dans les champs

new typé selon la cible fonctionne également pour les initialiseurs de champs, ce qui permet de conserver des déclarations concises.

using System;
using System.Collections.Generic;

class Program {
    static List<string> items = new();
    static void Main() {
        items.Add("a");
        Console.WriteLine(items.Count);
    }
}

Dans les arguments de méthode

Lorsqu’un paramètre possède un type connu, vous pouvez transmettre directement new() comme argument.

using System;
using System.Collections.Generic;

class Program {
    static void Print(List<int> list) {
        Console.WriteLine(list.Count);
    }
    static void Main() {
        Print(new());
    }
}

Renvoyer new()

Lorsque le type de retour d’une méthode est connu, vous pouvez renvoyer new() sans répéter le nom du type.

using System;
using System.Collections.Generic;

class Program {
    static List<int> Make() {
        return new() { 1, 2, 3 };
    }
    static void Main() {
        Console.WriteLine(Make().Count);
    }
}

Comparaison avec var

var x = new List<int>() indique le type à droite ; List<int> x = new() l’indique à gauche. Choisissez la forme la plus lisible.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var a = new List<int>();
        List<int> b = new();
        Console.WriteLine(a.Count + b.Count);
    }
}

L’ambiguïté est une erreur

Si le compilateur ne peut pas déterminer le type cible, new() échoue. La cible doit être claire d’après le contexte.

using System;

class Program {
    static void Main() {
        object o = new object();
        Console.WriteLine(o.GetType().Name);
    }
}

Lisibilité avec les types longs

new typé selon la cible est particulièrement pratique pour les types génériques verbeux, car il évite d’écrire le type deux fois.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Dictionary<string, List<int>> map = new();
        map["a"] = new() { 1, 2 };
        Console.WriteLine(map["a"].Count);
    }
}

Un style moderne

new typé selon la cible permet de garder des déclarations propres tout en conservant un typage statique complet et les vérifications du compilateur.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Queue<string> q = new();
        q.Enqueue("first");
        Console.WriteLine(q.Dequeue());
    }
}

Vérification rapide

Testez votre compréhension des expressions new typées selon la cible.

Réponds-y dans la leçon interactive

Récapitulatif

new() typé selon la cible permet d’omettre le type après new lorsque le type cible est déjà connu, ce qui réduit les répétitions dans les déclarations, les champs, les arguments et les valeurs de retour.

Il accepte toujours les arguments du constructeur et les initialiseurs, échoue lorsque le type est ambigu et complète var dans un style moderne offrant une sûreté totale du typage.

Gratuit pour commencer

Apprends C# avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
93
Leçons
346
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Expressions new dont le type est déduit du contexte » est-elle gratuite ?

Oui — le texte complet de « Expressions new dont le type est déduit du contexte » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions new dont le type est déduit du contexte » ?

Simplifiez la création d’objets grâce à la déduction du type cible. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Expressions new dont le type est déduit du contexte » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Inférence du type des variables locales avec var
  2. Quand éviter var
  3. Le type dynamic
  4. Expressions new dont le type est déduit du contexte
← Retour à C# Academy