0Pricing
C# Academy · Leçon

Constructeurs primaires dans les classes

Déclarez les paramètres du constructeur dans l’en-tête du type.

Constructeurs primaires dans les classes est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu’est-ce qu’un constructeur principal ?

Un constructeur principal vous permet de déclarer les paramètres du constructeur directement dans l’en-tête de la classe, comme dans class Point(int x, int y). Les paramètres sont accessibles dans tout le corps de la classe.

using System;

class Point(int x, int y) {
    public int X => x;
    public int Y => y;
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

Fini le code répétitif

Avant les constructeurs principaux, vous écriviez un corps de constructeur uniquement pour copier les paramètres dans des champs. Désormais, l’en-tête déclare les paramètres et vous pouvez les référencer directement.

using System;

class Greeter(string name) {
    public string Greet() => "Hello, " + name + "!";
}

Console.WriteLine(new Greeter("Ada").Greet()); // Hello, Ada!

Les paramètres sont accessibles partout

Les paramètres d’un constructeur principal peuvent être utilisés dans les initialiseurs de propriétés, les corps de méthodes et les initialiseurs de champs, où qu’ils se trouvent dans la classe.

using System;

class Circle(double radius) {
    public double Area => Math.PI * radius * radius;
    public double Circumference => 2 * Math.PI * radius;
}

var c = new Circle(2);
Console.WriteLine(Math.Round(c.Area, 2)); // 12.57

Initialiser des champs et des propriétés

Vous pouvez utiliser un paramètre de constructeur principal pour initialiser un champ ou une propriété au moment de sa déclaration.

using System;

class Account(decimal initial) {
    public decimal Balance { get; private set; } = initial;
    public void Deposit(decimal amount) => Balance += amount;
}

var a = new Account(100m);
a.Deposit(50m);
Console.WriteLine(a.Balance); // 150

Validation dans l’en-tête

Vous pouvez valider les paramètres du constructeur principal directement dans l’en-tête à l’aide d’expressions throw lors de l’affectation à un champ.

using System;

class Person(string name) {
    public string Name { get; } =
        string.IsNullOrWhiteSpace(name)
            ? throw new ArgumentException("name required")
            : name;
}

Console.WriteLine(new Person("Lin").Name); // Lin

Ajouter d’autres constructeurs

Une classe dotée d’un constructeur principal peut toujours déclarer d’autres constructeurs, mais ceux-ci doivent appeler le constructeur principal au moyen de : this(...).

using System;

class Box(int width, int height) {
    public int Width => width;
    public int Height => height;
    public Box(int size) : this(size, size) { }
}

var sq = new Box(5);
Console.WriteLine(sq.Width + "x" + sq.Height); // 5x5

Corps des constructeurs principaux

Les constructeurs principaux n’ont pas de corps qui leur soit propre. La logique qui doit s’exécuter lors de la construction doit être placée dans des initialiseurs de champs ou dans un constructeur ordinaire appelé en chaîne.

using System;

class Logger(string prefix) {
    private readonly string tag = "[" + prefix + "]";
    public void Log(string msg) => Console.WriteLine(tag + " " + msg);
}

new Logger("INFO").Log("started"); // [INFO] started

Les propriétés publiques ne sont pas automatiques

Contrairement aux enregistrements, un constructeur principal dans une classe ordinaire ne crée pas de propriétés publiques. Les paramètres restent privés à la classe, sauf si vous les exposez vous-même.

using System;

class Temp(double celsius) {
    // celsius is NOT a public property here
    public double Fahrenheit => celsius * 9 / 5 + 32;
}

Console.WriteLine(new Temp(100).Fahrenheit); // 212

Les paramètres capturés deviennent des champs

Lorsqu’un paramètre de constructeur principal est utilisé dans une méthode (et pas seulement dans un initialiseur), le compilateur le capture dans un champ masqué afin qu’il subsiste après la construction.

using System;

class Counter(int start) {
    private int value = start;
    public int Next() => value++;
}

var c = new Counter(10);
Console.WriteLine(c.Next()); // 10
Console.WriteLine(c.Next()); // 11

Une injection de dépendances plus claire

Les constructeurs principaux sont très utilisés pour l’injection de dépendances : déclarez les services dans l’en-tête et utilisez-les dans les méthodes, sans affectation manuelle à un champ.

using System;

interface IClock { string Now(); }
class FakeClock : IClock { public string Now() => "12:00"; }

class Service(IClock clock) {
    public string Report() => "Time is " + clock.Now();
}

Console.WriteLine(new Service(new FakeClock()).Report()); // Time is 12:00

Tout assembler

Cette classe utilise un constructeur principal pour ses dépendances et expose une propriété calculée, sans corps de constructeur explicite.

using System;

class Rectangle(double w, double h) {
    public double Area => w * h;
    public double Perimeter => 2 * (w + h);
}

var r = new Rectangle(3, 4);
Console.WriteLine(r.Area + " " + r.Perimeter); // 12 14

Vérification rapide

Vérifiez votre compréhension des constructeurs principaux dans les classes.

Récapitulatif

Vous avez appris à utiliser les constructeurs principaux dans les classes.

  • class C(int x) déclare les paramètres du constructeur dans l’en-tête.
  • Les paramètres sont accessibles dans tout le corps de la classe.
  • Les constructeurs supplémentaires sont appelés en chaîne avec : this(...).
  • Dans une classe ordinaire, ils ne deviennent pas automatiquement des propriétés publiques.

Questions Fréquemment Posées

La leçon « Constructeurs primaires dans les classes » est-elle gratuite ?

Oui — le texte complet de « Constructeurs primaires dans les classes » 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 « Constructeurs primaires dans les classes » ?

Déclarez les paramètres du constructeur dans l’en-tête du type. 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 1 sur 4.

Combien de temps prend la leçon « Constructeurs primaires dans les classes » ?

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. Constructeurs primaires dans les classes
  2. Capturer des paramètres dans les membres
  3. Constructeurs primaires avec les structures
  4. Combiner avec des propriétés et des types de base
← Retour à C# Academy