Costruttori e inizializzazione dell'oggetto

1. Costruttori semplici

Costruttore — è un metodo speciale della classe che viene chiamato automaticamente quando crei un oggetto. Inizializza (configura) l'oggetto: imposta i valori iniziali, fa controlli, può anche tirarti su il morale se ci scrivi una battuta dentro.

Il costruttore ti permette di creare subito un oggetto in uno stato preciso, invece di assegnare tutti i suoi dati a mano tramite campi e proprietà. È comodo e sicuro, perché indichi subito tutti i parametri importanti — e non ti dimentichi nulla di fondamentale.

Senza costruttore il codice può diventare ingombrante e soggetto a errori:

Person p = new Person();
p.Name = "Yulya";
p.Age = 25; // E se ci dimentichiamo di indicare l'età?

Con il costruttore:

Person p = new Person("Yulya", 25); // Tutto passato subito e l'oggetto è pronto a vivere!

Sintassi del costruttore

Il costruttore è un "metodo" speciale, il cui nome coincide esattamente con il nome della classe e che non ha valore di ritorno (nemmeno void). Ecco come appare un costruttore di default:

public class Person
{
    // Costruttore di default (senza parametri)
    public Person()
    {
        // Qui puoi scrivere codice di inizializzazione
    }
}

Il costruttore di default è come un "aiutante" invisibile che non prende parametri e inizializza tutti i campi e le proprietà della tua classe con i valori di default:

• Per i tipi numerici (int, double, float ecc.) sarà 0.
• Per il tipo booleano (bool) è false.
• Per i tipi reference (string, altre classi) è null (cioè "niente", "assenza di riferimento all'oggetto").
• Per DateTime sarà 01.01.0001 00:00:00.

Come chiamare il costruttore?

In pratica, quando scrivi l'operatore new per creare un oggetto, stai chiamando il costruttore!

Person p = new Person();

Se non definisci esplicitamente nessun costruttore, il compilatore C# creerà per te il costruttore di default (senza parametri). Ma se ne dichiari almeno uno tuo — il costruttore di default sparisce, e il compilatore ti chiederà di aggiungerlo a mano se ti serve.

Esempio

Aggiungiamo un costruttore alla nostra classe dell'app. Ecco una versione semplice della classe Studente:

public class Student
{
    public string Name;
    public int Age;

    // Costruttore con due parametri (nome e età)
    public Student(string name, int age)
    {
        Name = name; // Assegniamo il valore al campo
        Age = age;
    }
}

Ora puoi creare uno studente così:

Student s = new Student("Ivan", 21);
Console.WriteLine($"{s.Name}: {s.Age} anni"); // Ivan: 21 anni

• Abbiamo dichiarato il costruttore con la stessa visibilità (public) della classe.
• Nel costruttore assegniamo i valori ai campi usando i parametri passati.
• Questo approccio ti protegge dalla dimenticanza: il compilatore ti chiederà di indicare nome e età quando crei l'oggetto.

2. Parametri del costruttore

In C# puoi dichiarare più costruttori con diversi set di parametri. Questo si chiama overload del costruttore (parleremo di overload dei metodi più avanti).

Per esempio, aggiungiamo un costruttore senza parametri:

public class Student
{
    public string Name;
    public int Age;

    // Costruttore di default
    public Student()
    {
        Name = "SenzaNome";
        Age = 0;
    }

    // Costruttore con parametri
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Ora sono possibili entrambe le varianti:

Student s1 = new Student();          // Nome: SenzaNome, età: 0
Student s2 = new Student("Olya", 22); // Nome: Olya, età: 22

Usare il costruttore per la validazione

Il costruttore è un ottimo posto per controllare la "qualità" dei dati in ingresso. Per esempio, uno studente non può avere età negativa!

public Student(string name, int age)
{
    if (age < 0)
        throw new ArgumentException("L'età non può essere negativa!");
    Name = name;
    Age = age;
}

Ora se qualcuno prova a creare uno studente Student("Malysh", -2), l'app lancerà un'eccezione (ArgumentException). Questo approccio si usa spesso per avere dati "a prova di bomba".

3. Inizializzazione di oggetti complessi

Spesso nelle app reali un oggetto può essere "assemblato" non solo da primitivi, ma anche contenere altri oggetti:

public class Group
{
    public string GroupName;
    public Student[] Students;

    public Group(string groupName, Student[] students)
    {
        GroupName = groupName;
        Students = students;
    }
}

Ora puoi facilmente creare un gruppo con un set di studenti:

var students = new Student[]
{
    new Student("Ivan", 20),
    new Student("Maria", 19)
};
Group g = new Group("Gruppo-101", students);

Inizializzazione dei campi di default

A volte vuoi impostare valori di default per alcuni campi, se non tutti i parametri arrivano nel costruttore. Per esempio, se l'e-mail non è obbligatoria:

public Student(string name, int age)
{
    Name = name;
    Age = age;
    Email = "unknown@noemail.com"; // Valore di default
}

4. Inizializzazione tramite Object Initializer

Con i costruttori puoi combinare un'altra sintassi comoda — object initializer. Puoi chiamare il costruttore e poi tra parentesi graffe elencare i valori delle proprietà del nuovo oggetto:

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Email { get; set; }

    // Il costruttore è comunque consigliato
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
        Email = "";
    }
}

Student s = new Student("Anton", 18) { Email = "anton@domain.com" }; // costruttore + proprietà

Questa sintassi va alla grande insieme al costruttore, quando alcuni parametri hanno valori di default o non sono sempre noti al momento della creazione.

5. Errori tipici e particolarità

Lavorando con i costruttori, i principianti incontrano alcuni errori comuni. Vediamoli in modo semplice:

Errore n°1: Nomi che non coincidono
A volte si confondono i nomi dei parametri e dei campi, soprattutto se differiscono solo per maiuscole/minuscole.

public Student(string Name, int Age) // Con la maiuscola!
{
    Name = Name; // Ops! Entrambi Name si riferiscono al parametro. Il campo resta non inizializzato.
}

Come si fa giusto: Usa this per riferirti al campo dell'oggetto:

public Student(string name, int age)
{
    this.Name = name;
    this.Age = age;
}

Oppure scegli semplicemente nomi diversi (tipo nameParam, ageParam), ma la pratica con this. è considerata di buon stile, soprattutto nei progetti grandi.

Errore n°2: Nessun costruttore di default

Se hai dichiarato almeno un costruttore, poi provi a creare un oggetto senza parametri — ottieni un errore di compilazione:

public class Student
{
    public Student(string name) { /*...*/ }
}

// da qualche parte nel codice
Student s = new Student(); // Errore! Nessun costruttore senza parametri.

Soluzione: Aggiungi esplicitamente un costruttore senza parametri:

public Student() { /*...*/ }

Errore n°3: Ricorsione infinita — se il costruttore chiama se stesso

public Student()
{
    // Errore! Chiama se stesso — ricorsione infinita.
    new Student();
}