0Pricing
C# Academy · Leçon

Capturer des paramètres dans les membres

Utilisez les paramètres du constructeur primaire dans tout le type.

Capturer des paramètres dans les membres est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Utiliser les paramètres dans les membres

La puissance des constructeurs principaux vient de l’utilisation des paramètres dans les membres : méthodes, propriétés et initialiseurs de champs. Le compilateur organise le stockage nécessaire.

using System;

class Multiplier(int factor) {
    public int Apply(int n) => n * factor;
}

Console.WriteLine(new Multiplier(3).Apply(5)); // 15

Capture ou initialisation uniquement

Si un paramètre est utilisé uniquement dans un initialiseur de champ ou de propriété, aucun stockage supplémentaire n’est nécessaire. S’il est utilisé dans une méthode, le compilateur le capture dans un champ masqué.

using System;

class A(int x) {
    public int Stored = x;     // initializer only
}
class B(int x) {
    public int Get() => x;     // captured into a field
}

Console.WriteLine(new A(7).Stored); // 7
Console.WriteLine(new B(9).Get());  // 9

Les paramètres sont modifiables

Les paramètres d’un constructeur principal se comportent comme des paramètres ordinaires : ils sont modifiables dans l’instance, sauf si vous les traitez comme étant en lecture seule. Modifier un paramètre modifie le champ capturé.

using System;

class Toggle(bool on) {
    public void Flip() => on = !on;
    public bool State => on;
}

var t = new Toggle(false);
t.Flip();
Console.WriteLine(t.State); // True

Exposer des propriétés en lecture seule

Un schéma courant consiste à exposer un paramètre au moyen d’une propriété accessible uniquement en lecture, ce qui offre une interface publique claire tout en gardant le paramètre interne.

using System;

class User(string email) {
    public string Email { get; } = email;
}

Console.WriteLine(new User("a@b.com").Email); // a@b.com

Propriétés calculées à partir des paramètres

Les paramètres s’intègrent naturellement aux propriétés calculées avec un corps d’expression.

using System;

class Money(decimal amount, string currency) {
    public string Display => amount.ToString("0.00") + " " + currency;
}

Console.WriteLine(new Money(9.5m, "USD").Display); // 9.50 USD

Paramètres dans plusieurs méthodes

Le même paramètre capturé peut être partagé par plusieurs méthodes, comme un champ privé initialisé lors de la construction.

using System;

class Range2(int lo, int hi) {
    public bool Contains(int n) => n >= lo && n <= hi;
    public int Clamp(int n) => Math.Max(lo, Math.Min(hi, n));
}

var r = new Range2(0, 10);
Console.WriteLine(r.Contains(5)); // True
Console.WriteLine(r.Clamp(15));   // 10

Capture de types référence

Les paramètres de type référence capturés vous permettent de stocker les dépendances injectées et de les appeler depuis n’importe quelle méthode.

using System;
using System.Collections.Generic;

class Repo(List<string> store) {
    public void Add(string item) => store.Add(item);
    public int Count => store.Count;
}

var list = new List<string>();
var repo = new Repo(list);
repo.Add("x");
Console.WriteLine(repo.Count); // 1

Éviter le double stockage accidentel

Si vous affectez un paramètre à un champ et utilisez ce paramètre dans des méthodes, vous risquez de stocker la valeur deux fois. Préférez une seule approche pour plus de clarté.

using System;

class Clean(int x) {
    // expose once via property, reference property in methods
    public int Value { get; } = x;
    public int Doubled() => Value * 2;
}

Console.WriteLine(new Clean(4).Doubled()); // 8

Paramètres dans les lambdas

Les paramètres peuvent être capturés par des lambdas définies à l’intérieur de la classe, tout comme les champs.

using System;
using System.Collections.Generic;
using System.Linq;

class Filter(int threshold) {
    public IEnumerable<int> KeepAbove(IEnumerable<int> xs) =>
        xs.Where(n => n > threshold);
}

var f = new Filter(3);
Console.WriteLine(string.Join(",", f.KeepAbove(new[]{1,2,3,4,5}))); // 4,5

Durée de vie de la portée

Un paramètre capturé vit aussi longtemps que l’objet. Il constitue effectivement un état d’instance : ne supposez donc pas qu’il est réinitialisé entre les appels de méthodes.

using System;

class Accumulator(int seed) {
    private int total = seed;
    public int Add(int n) { total += n; return total; }
}

var a = new Accumulator(100);
Console.WriteLine(a.Add(1)); // 101
Console.WriteLine(a.Add(1)); // 102

Mise en pratique

Ce service capture deux dépendances et les utilise dans plusieurs méthodes, illustrant la structure typique d’un cas réel.

using System;

class PriceService(decimal taxRate, string currency) {
    public decimal WithTax(decimal net) => net * (1 + taxRate);
    public string Format(decimal v) => v.ToString("0.00") + " " + currency;
}

var s = new PriceService(0.2m, "EUR");
Console.WriteLine(s.Format(s.WithTax(100m))); // 120.00 EUR

Vérification rapide

Vérifiez comment les paramètres d’un constructeur principal sont stockés.

Récapitulatif

Vous avez appris comment les paramètres d’un constructeur principal sont utilisés dans les membres.

  • Utilisés dans des méthodes, les paramètres sont capturés dans des champs cachés.
  • Utilisés uniquement dans des initialiseurs, ils ne nécessitent aucun stockage supplémentaire.
  • Exposez-les via des propriétés accessibles uniquement en lecture pour obtenir une interface claire.
  • Ils se comportent comme un état d’instance pendant toute la durée de vie de l’objet.

Questions Fréquemment Posées

La leçon « Capturer des paramètres dans les membres » est-elle gratuite ?

Oui — le texte complet de « Capturer des paramètres dans les membres » 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 « Capturer des paramètres dans les membres » ?

Utilisez les paramètres du constructeur primaire dans tout le 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 2 sur 4.

Combien de temps prend la leçon « Capturer des paramètres dans les membres » ?

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