C# Academy · Lezione

Costanti e campi readonly

Distingua const da static readonly.

Costanti e campi readonly è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Due modi per rendere i valori immutabili

C# offre const e readonly per i valori che non dovrebbero cambiare. Sembrano simili, ma si comportano in modo molto diverso. Questa lezione li mette a confronto.

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);
    }
}

const: costante in fase di compilazione

Un const deve ricevere un valore letterale alla dichiarazione e viene incorporato in fase di compilazione. È implicitamente statico.

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"));
    }
}

const deve essere un valore letterale

Poiché viene risolto in fase di compilazione, un const può contenere solo un'espressione costante: numeri, stringhe, valori booleani o altri const.

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: costante a runtime

Un campo readonly viene impostato una sola volta, alla dichiarazione o in un costruttore, e poi non può cambiare. Il suo valore può essere calcolato a runtime.

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 può usare valori a runtime

A differenza di const, un campo readonly può contenere un valore noto solo durante l'esecuzione del programma, come un id generato o l'ora corrente.

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));
    }
}

static readonly

Combini static readonly per ottenere un valore valido per l'intera classe e calcolato una sola volta a runtime. Questa è la sostituzione abituale di un const quando il valore non è letterale.

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;
}

Perché const può essere rischioso tra assembly

Poiché i valori const vengono inseriti nel codice chiamante in fase di compilazione, modificare un const pubblico in una libreria richiede di ricompilare tutti i chiamanti. static readonly evita questo problema.

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);
    }
}

Nessuno dei due può essere riassegnato

Dopo l'inizializzazione, né un campo const né un campo readonly può essere modificato. Tentare di farlo genera un errore di compilazione.

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);
    }
}

Come scegliere tra i due

Usi const per valori letterali autentici che non cambiano mai, come Pi e MaxInt. Usi readonly quando il valore viene calcolato in fase di esecuzione o può variare da un'istanza all'altra.

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());
    }
}

Attenzione ai riferimenti readonly

readonly blocca il campo, non l'oggetto a cui punta. Un riferimento readonly a una lista non può essere riassegnato, ma il contenuto della lista può comunque cambiare.

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);
    }
}

In sintesi

Una classe tipica usa const per i valori letterali fissi e readonly per i valori fissati per ogni istanza al momento della costruzione.

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);
    }
}

Verifica rapida

Verifichi la Sua comprensione della differenza tra const e readonly.

Riepilogo

const è un valore letterale determinato in fase di compilazione, implicitamente statico e inserito direttamente nei chiamanti. readonly viene impostato una sola volta nella dichiarazione o in un costruttore e può usare valori determinati in fase di esecuzione. Usi const per i valori letterali autentici e static readonly per i valori condivisi calcolati in fase di esecuzione; ricordi che readonly blocca il riferimento, non l'oggetto.

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);
    }
}

Domande Frequenti

La lezione «Costanti e campi readonly» è gratuita?

Sì — il testo completo di «Costanti e campi readonly» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Costanti e campi readonly»?

Distingua const da static readonly. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Costanti e campi readonly»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy