C# Academy · Leçon

Constantes et champs readonly

Faites la distinction entre const et static readonly.

Constantes et champs readonly 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.

Deux façons de rendre les valeurs immuables

C# propose const et readonly pour les valeurs qui ne doivent pas changer. Ils se ressemblent, mais leur comportement est très différent. Cette leçon les compare.

using System;

class Config
{
    public const double Pi = 3.14159;
    public static readonly DateTime StartedAt = DateTime.Now;
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Pi = " + Config.Pi);
    }
}

Constante définie à la compilation

Une const doit recevoir une valeur littérale lors de sa déclaration et est intégrée au moment de la compilation. Elle est implicitement statique.

using System;

class Circle
{
    public const double Pi = 3.14159;

    public static double Area(double r) => Pi * r * r;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Circle.Area(2).ToString("0.00"));
    }
}

Une constante doit être littérale

Comme sa valeur est déterminée au moment de la compilation, une const peut uniquement contenir une expression constante : des nombres, des chaînes, des valeurs booléennes ou d’autres constantes.

using System;

class Limits
{
    public const int MaxRetries = 3;
    public const int Timeout = MaxRetries * 1000;   // const expression OK
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Limits.MaxRetries + ", " + Limits.Timeout);
    }
}

readonly : constante à l’exécution

Un champ readonly est défini une seule fois, soit lors de sa déclaration, soit dans un constructeur, puis ne peut plus changer. Sa valeur peut être calculée au moment de l’exécution.

using System;

class Session
{
    public readonly string Id;

    public Session(string id)
    {
        Id = id;   // allowed: inside constructor
    }
}

class Program
{
    static void Main()
    {
        var s = new Session("abc-123");
        Console.WriteLine("Session: " + s.Id);
    }
}

readonly peut utiliser des valeurs d’exécution

Contrairement à const, un champ readonly peut contenir une valeur connue uniquement pendant l’exécution du programme, comme un identifiant généré ou l’heure actuelle.

using System;

class Order
{
    public readonly Guid OrderId;

    public Order()
    {
        OrderId = Guid.NewGuid();
    }
}

class Program
{
    static void Main()
    {
        var o = new Order();
        Console.WriteLine("Has id: " + (o.OrderId != Guid.Empty));
    }
}

Valeur statique en lecture seule

Combinez static readonly pour obtenir une valeur commune à la classe, calculée une seule fois lors de l’exécution. C’est généralement ce qui remplace const lorsque la valeur n’est pas littérale.

using System;

class AppInfo
{
    public static readonly string[] Roles = { "admin", "user", "guest" };
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Roles: " + Roles());
    }

    static int Roles() => AppInfo.Roles.Length;
}

Pourquoi les constantes peuvent être risquées entre les assemblys

Comme les valeurs const sont intégrées au code appelant lors de la compilation, modifier une constante publique dans une bibliothèque exige de recompiler tous les appelants. static readonly évite ce problème.

using System;

class Lib
{
    public const int Version = 2;              // inlined into callers
    public static readonly int Build = 100;     // read at runtime
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lib.Version + "." + Lib.Build);
    }
}

Impossible de réaffecter l'une ou l'autre

Après l'initialisation, ni un champ const ni un champ readonly ne peuvent être modifiés. Toute tentative en ce sens provoque une erreur de compilation.

using System;

class Demo
{
    public const int A = 10;
    public readonly int B;

    public Demo() { B = 20; }
    // A = 11;  // would not compile
    // B = 21;  // would not compile outside constructor
}

class Program
{
    static void Main()
    {
        var d = new Demo();
        Console.WriteLine(Demo.A + ", " + d.B);
    }
}

Choisir entre les deux

Utilisez const pour les vrais littéraux qui ne changent jamais (π, MaxInt). Utilisez readonly lorsque la valeur est calculée à l'exécution ou peut différer selon l'instance.

using System;

class Physics
{
    public const double Gravity = 9.81;          // universal literal
    public readonly double Mass;                  // per object

    public Physics(double mass) { Mass = mass; }
    public double Weight() => Mass * Gravity;
}

class Program
{
    static void Main()
    {
        var p = new Physics(10);
        Console.WriteLine("Weight: " + p.Weight());
    }
}

readonly : attention aux références

readonly verrouille le champ, pas l'objet vers lequel il pointe. Une référence vers une liste readonly ne peut pas être réaffectée, mais son contenu peut toujours changer.

using System;
using System.Collections.Generic;

class Cart
{
    public readonly List<string> Items = new List<string>();
}

class Program
{
    static void Main()
    {
        var c = new Cart();
        c.Items.Add("Pen");   // allowed: mutating the object
        c.Items.Add("Book");
        Console.WriteLine("Items: " + c.Items.Count);
    }
}

Mise en pratique

Une classe typique utilise const pour les littéraux fixes et readonly pour les valeurs fixées pour chaque instance lors de sa construction.

using System;

class Account
{
    public const decimal MinBalance = 0m;
    public readonly string Owner;

    public Account(string owner)
    {
        Owner = owner;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("Rin");
        Console.WriteLine(a.Owner + " min=" + Account.MinBalance);
    }
}

Vérification rapide

Vérifiez votre compréhension de const et readonly.

Récapitulatif

const est un littéral connu à la compilation, implicitement statique, et intégré au code appelant. readonly est défini une seule fois lors de la déclaration ou dans un constructeur et peut utiliser des valeurs calculées à l'exécution. Utilisez const pour les vrais littéraux, static readonly pour les valeurs partagées calculées à l'exécution, et souvenez-vous que readonly verrouille la référence, pas l'objet.

using System;

class Demo
{
    public const int Max = 100;
    public readonly int Created;
    public Demo(int c) { Created = c; }
}

class Program
{
    static void Main()
    {
        var d = new Demo(7);
        Console.WriteLine(Demo.Max + ", " + d.Created);
    }
}

Questions Fréquemment Posées

La leçon « Constantes et champs readonly » est-elle gratuite ?

Oui — le texte complet de « Constantes et champs readonly » 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 « Constantes et champs readonly » ?

Faites la distinction entre const et static readonly. 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 « Constantes et champs readonly » ?

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

← Retour à C# Academy