0Pricing
C# Academy · Leçon

Constructeurs primaires avec les structures

Appliquez les constructeurs primaires aux types valeur.

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

Constructeurs principaux dans les structures

Les structures prennent également en charge les constructeurs principaux : struct Point(int x, int y). Ils fonctionnent à peu près comme dans les classes, en déclarant les paramètres dans l’en-tête.

using System;

struct 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

Un constructeur sans paramètre existe toujours

Les structures possèdent toujours un constructeur implicite sans paramètre qui produit la valeur par défaut. Un constructeur principal en ajoute un autre avec des paramètres.

using System;

struct Vec(int x, int y) {
    public int X => x;
    public int Y => y;
}

var zero = new Vec(); // default: x=0, y=0
Console.WriteLine(zero.X + "," + zero.Y); // 0,0

Exposer les paramètres via des propriétés

Comme pour les classes, les paramètres du constructeur principal d’une structure ne deviennent pas automatiquement des propriétés publiques ; exposez-les explicitement.

using System;

struct Size(int w, int h) {
    public int Width { get; } = w;
    public int Height { get; } = h;
}

var s = new Size(10, 20);
Console.WriteLine(s.Width * s.Height); // 200

Membres calculés

Les constructeurs principaux de structures s’associent parfaitement aux membres calculés dont le corps est une expression.

using System;

struct Complex(double re, double im) {
    public double Magnitude => Math.Sqrt(re * re + im * im);
}

Console.WriteLine(new Complex(3, 4).Magnitude); // 5

Structures readonly

Une readonly struct dotée d’un constructeur principal garantit l’immuabilité. Aucun membre ne doit modifier l’état, ce qui convient parfaitement aux propriétés accessibles uniquement en lecture.

using System;

readonly struct Money(decimal amount, string currency) {
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;
    public string Display => Amount.ToString("0.00") + " " + Currency;
}

Console.WriteLine(new Money(5m, "USD").Display); // 5.00 USD

Chaînage vers le constructeur principal

Les constructeurs supplémentaires d’une structure doivent appeler le constructeur principal avec : this(...), comme dans les classes.

using System;

struct Square(int side) {
    public int Side => side;
    public int Area => side * side;
    public Square() : this(1) { } // explicit default side
}

Console.WriteLine(new Square(4).Area); // 16

Constructeur par défaut ou constructeur principal

Notez que new Square() peut utiliser soit l’initialisation implicite à zéro, soit votre constructeur sans paramètre déclaré. Si vous en définissez un qui effectue un chaînage, votre logique est exécutée.

using System;

struct Pct(double value) {
    public double Value { get; } = value;
    public Pct() : this(100) { }
}

Console.WriteLine(new Pct().Value); // 100

La sémantique des valeurs demeure

Les structures sont toujours copiées par valeur. Un constructeur principal ne change rien à cela : l’affectation d’une structure copie tous ses champs.

using System;

struct Counter(int n) {
    public int N { get; set; } = n;
}

var a = new Counter(1);
var b = a;       // copy
b.N = 99;
Console.WriteLine(a.N + " " + b.N); // 1 99

Initialiser des champs modifiables

Vous pouvez initialiser des propriétés ou des champs accessibles en écriture à partir de paramètres, même si les structures immuables sont généralement préférables.

using System;

struct Bag(int capacity) {
    public int Capacity { get; set; } = capacity;
    public int Used { get; set; } = 0;
}

var bag = new Bag(10);
bag.Used = 3;
Console.WriteLine(bag.Capacity - bag.Used); // 7

Déconstruction

Associez un constructeur principal à une méthode Deconstruct pour obtenir un déballage similaire à celui des tuples.

using System;

struct Point(int x, int y) {
    public int X => x;
    public int Y => y;
    public void Deconstruct(out int a, out int b) { a = x; b = y; }
}

var (px, py) = new Point(7, 8);
Console.WriteLine(px + "," + py); // 7,8

Mise en pratique

Un petit type valeur immuable créé avec une structure readonly et un constructeur principal.

using System;

readonly struct Temperature(double celsius) {
    public double Celsius { get; } = celsius;
    public double Fahrenheit => Celsius * 9 / 5 + 32;
}

var t = new Temperature(25);
Console.WriteLine(t.Fahrenheit); // 77

Vérification rapide

Testez votre compréhension des constructeurs principaux avec les structures.

Récapitulatif

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

  • struct P(int x, int y) déclare les paramètres dans l’en-tête.
  • Le constructeur implicite sans paramètre existe toujours.
  • Associez-les à readonly struct pour créer des types valeur immuables.
  • Les constructeurs supplémentaires effectuent un chaînage avec : this(...).

Questions Fréquemment Posées

La leçon « Constructeurs primaires avec les structures » est-elle gratuite ?

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

Appliquez les constructeurs primaires aux types valeur. 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 3 sur 4.

Combien de temps prend la leçon « Constructeurs primaires avec les structures » ?

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