Costanti e parola chiave var

1. Costanti

Una costante è una variabile "magica" il cui valore non si può (e non si deve!) cambiare dopo la dichiarazione. Immagina un adesivo super appiccicoso sulla tua tazza con scritto "Solo tè". Una volta attaccato, non puoi più cambiare il tè con il caffè (almeno, in C#).

const int DaysInWeek = 7;
const string HelloMessage = "Benvenuto!";

In questi esempi DaysInWeek sarà sempre 7, e HelloMessage — sempre di benvenuto. Una volta che il valore di una costante è fissato, non si può più cambiare.

Perché servono le costanti?

• Chiarezza del codice: quando vedi const double Pi = 3.14159;, è chiaro che è una costante, non una variabile che qualcuno può cambiare a metà programma.
• Sicurezza: nessuno (nemmeno tu tra qualche mese) potrà sovrascrivere per sbaglio il valore della costante.
• Performance: il compilatore C# inserisce il valore della costante direttamente dove serve, quindi il programma gira un po' più veloce.

Sintassi di dichiarazione

const tipo nome = valore;

• Tipo — qualsiasi tipo primitivo (int, double, string, char, anche enum e letterali).
• Nome — di solito si usa lo stile CamelCase o PascalCase. Per le "costanti magiche" a volte si usano tutte maiuscole e underscore (DAYS_IN_WEEK), ma in C# non è obbligatorio.

Esempi:

const double GRAVITY = 9.81; // accelerazione di gravità, m/s^2
const char DELIMITER = ',';
const string DEVELOPER_NAME = "Ivan Petrov";

Caratteristiche e limiti delle costanti

• Il valore deve essere noto a compile-time. Significa che non puoi dichiarare una costante il cui valore viene calcolato a runtime.

const int NowYear = DateTime.Now.Year; // ERRORE DI COMPILAZIONE!

• Puoi usare solo tipi semplici, string o enum.
• Non puoi rendere costante un array, un oggetto, il risultato di una funzione ecc.
• Anche espressioni che sembrano "semplici" matematicamente devono essere calcolate dal compilatore, non a runtime.

Ecco, così NON si può fare:

const string FullGreeting = "Ciao, " + userName; // userName è una variabile, non si può!

Così invece — si può (e si deve):

const string DefaultGreeting = "Ciao, utente!";

Dove si dichiarano di solito le costanti?

• All'inizio della classe (o del file), sopra i metodi.
• In classi apposta per le costanti (tipo public static class Constants).
• A livello di classe, se la costante riguarda solo quella classe.

Esempio per la nostra app console:

class Program
{
    const string Welcome = "Benvenuto nella nostra applicazione!";
    static void Main(string[] args)
    {
        Console.WriteLine(Welcome);
    }
}

Costanti e scope

Le costanti seguono le stesse regole di visibilità delle variabili normali: sono visibili solo dove sono dichiarate.

2. Parola chiave var

La parola chiave var — non è un nuovo tipo di variabile, ma un modo comodo per lasciare che il compilatore capisca da solo il tipo della variabile dal contesto.

È solo syntactic sugar — nessuna magia, dopo la compilazione la variabile diventa di tipo normale.

var age = 23;      // il compilatore capisce: age è int
var name = "Anna"; // il compilatore capisce: string
var price = 99.99; // il compilatore capisce: double

Perché è arrivato var?

• Leggibilità: non devi scrivere tipi lunghi (tipo Dictionary<string, List<int>>) a mano.
• Flessibilità: è più facile cambiare tipo in futuro: cambi a destra — a sinistra var si adatta.
• Stile moderno: praticamente tutti i progetti C# moderni usano var dove il tipo si capisce subito dall'inizializzazione.

Quando si può (e si deve) usare var

• Quando a destra è chiaro che tipo ha la variabile.
• Quando il tipo è ovvio (var price = 100; — chiaro che è int).
• Quando il tipo è troppo lungo o complicato (tipo il risultato di una query LINQ).

var numbers = new int[] { 1, 2, 3, 4 };
var input = Console.ReadLine(); // input è string (il metodo ritorna string)

Quando è meglio NON usare var

Se il tipo non è chiaro dalla parte destra, il codice può diventare poco leggibile. E se tra un mese nemmeno con l'aiuto dei colleghi capisci che tipo era, meglio scriverlo esplicitamente.

var mystery = DoSomethingVeryComplicated(); // CHI SEI, mystery???

Qui meglio scrivere il tipo esplicitamente:

string result = DoSomethingVeryComplicated();

Regola d'oro: usa var solo dove non peggiora la leggibilità!

var — solo per variabili locali

La parola chiave var funziona solo per variabili locali — dentro i metodi. Non puoi usare var per:

• parametri di metodo;
• proprietà di classe;
• costanti.

Come funziona var "sotto il cofano"

• Il compilatore C# durante la compilazione mette il tipo giusto.
• Dopo la compilazione non resta nessun var.
• Nessuna perdita di performance: è solo una comodità per il programmatore.

var year = 2025; // in compilazione diventa: int year = 2025;

Errori tipici con var

• Variabile non inizializzata:

var a; // ERRORE: Il compilatore non può dedurre il tipo!

• Inizializzazione ambigua:

var list = null; // ERRORE: Il tipo null non è definito!

• Riutilizzo della variabile con tipi diversi:

var value = 5; // value è int
value = "Cinque"; // ERRORE: value è già int!

Confronto: tipi espliciti e var

int age = 42;

var age = 42;

Dictionary<int, string> dict = SomeFunc();

var dict = SomeFunc();

string[] names = ...

var names = ...

3. Trappole e consigli

In C# spesso si scrivono numeri magici direttamente nel codice ("7", "3.14159", "0.15" e altri numeri misteriosi). Male: se il valore cambia, devi cercare tutte le occorrenze in tutto il progetto. Usa le costanti! Sarà più facile anche per te, e i colleghi non ti malediranno...

Con var c'è l'estremo opposto: se tutto il codice è solo var e non si capisce mai che tipo usi — il codice diventa subito incomprensibile. Quindi usa var dove è logico e chiaro dal contesto, e negli altri casi non aver paura di scrivere il tipo esplicitamente.

2

Compito

C# SELF, livello 10, lezione 1

Bloccato

Dichiarazione e utilizzo delle costanti

Dichiarazione e utilizzo delle costanti

Apri

2

Compito

C# SELF, livello 10, lezione 1

Bloccato

Lavorare con la parola chiave var

Lavorare con la parola chiave var

Apri