Utilizzo di costruttori (Guida per programmatori C#)

  • Articolo

Quando viene creata un'istanza di una classe o uno struct , viene chiamato il relativo costruttore. I costruttori hanno lo stesso nome della classe o dello struct e in genere inizializzano i membri dati del nuovo oggetto.

Nell'esempio seguente viene definita una classe denominata Taxi usando un costruttore semplice. Viene quindi creata un'istanza per la classe con l'operatore new. Il costruttore Taxi viene richiamato dall'operatore new immediatamente dopo l'allocazione della memoria per il nuovo oggetto.

public class Taxi
{
    public bool IsInitialized;

    public Taxi()
    {
        IsInitialized = true;
    }
}

class TestTaxi
{
    static void Main()
    {
        Taxi t = new Taxi();
        Console.WriteLine(t.IsInitialized);
    }
}

Un costruttore che non accetta parametri è detto costruttore senza parametri. I costruttori senza parametri vengono richiamati ogni volta che si crea un'istanza per un oggetto usando l'operatore new e non vengono specificati argomenti per new. C# 12 introduce costruttori primari. Un costruttore primario specifica i parametri che devono essere forniti per inizializzare un nuovo oggetto. Per altre informazioni, vedere Costruttori di istanze.

A meno che la classe non sia statica, le classi senza costruttori ricevono un costruttore senza parametri pubblico dal compilatore C# perché possano creare istanze di classi. Per altre informazioni, vedere Classi statiche e membri di classi statiche.

È possibile impedire che venga creata un'istanza per una classe rendendo il costruttore privato, come indicato di seguito:

class NLog
{
    // Private Constructor:
    private NLog() { }

    public static double e = Math.E;  //2.71828...
}

Per altre informazioni, vedere Costruttori privati.

I costruttori per i tipi di struct sono simili ai costruttori di classi. Quando viene creata un'istanza di un tipo struct con new, viene richiamato un costruttore. Quando un struct oggetto è impostato sul relativo default valore, il runtime inizializza tutta la memoria nello struct su 0. Prima di C# 10, structs non può contenere un costruttore esplicito senza parametri perché ne viene fornito automaticamente dal compilatore. Per altre informazioni, vedere la sezione Inizializzazione Struct e valori predefiniti dell'articolo Tipi di struttura.

Il codice seguente usa il costruttore senza parametri per Int32, in modo da assicurarsi che l'intero venga inizializzato:

int i = new int();
Console.WriteLine(i);

Il codice seguente, tuttavia, causa un errore del compilatore perché non usa newe perché tenta di usare un oggetto che non è stato inizializzato:

int i;
Console.WriteLine(i);

In alternativa, gli oggetti basati su structs, inclusi tutti i tipi numerici incorporati, possono essere inizializzati o assegnati e quindi usati come nell'esempio seguente:

int a = 44;  // Initialize the value type...
int b;
b = 33;      // Or assign it before using it.
Console.WriteLine("{0}, {1}", a, b);

Entrambe le classi e gli struct possono definire costruttori che accettano parametri, inclusi i costruttori primari. I costruttori che accettano parametri devono essere chiamati con un'istruzione new o un'istruzione di base. Le classi e gli struct possono anche definire più costruttori e nessuno dei due è necessario per definire un costruttore senza parametri. Ad esempio:

public class Employee
{
    public int Salary;

    public Employee() { }

    public Employee(int annualSalary)
    {
        Salary = annualSalary;
    }

    public Employee(int weeklySalary, int numberOfWeeks)
    {
        Salary = weeklySalary * numberOfWeeks;
    }
}

Questa classe può essere creata usando una delle istruzioni seguenti:

Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);

Un costruttore può usare la parola chiave base per chiamare il costruttore di una classe di base. Ad esempio:

public class Manager : Employee
{
    public Manager(int annualSalary)
        : base(annualSalary)
    {
        //Add further instructions here.
    }
}

In questo esempio il costruttore per la classe di base viene chiamato prima che venga eseguito il blocco per il costruttore. La parola chiave base può essere usata con o senza parametri. Tutti i parametri per il costruttore possono essere usati come parametri per base o come parte di un'espressione. Per altre informazioni, vedere base.

In una classe derivata, se un costruttore della classe base non viene chiamato in modo esplicito usando la base parola chiave , il costruttore senza parametri, se presente, viene chiamato in modo implicito. Le dichiarazioni di costruttore seguenti sono effettivamente le stesse:

public Manager(int initialData)
{
    //Add further instructions here.
}

public Manager(int initialData)
    : base()
{
    //Add further instructions here.
}

Se una classe base non offre un costruttore senza parametri, la classe derivata deve effettuare una chiamata esplicita a un costruttore di base usando base.

Un costruttore può richiamare un altro costruttore nello stesso oggetto usando la parola chiave this. Come base, this può essere utilizzata con o senza parametri e gli eventuali parametri nel costruttore sono disponibili come parametri per this o come parte di un'espressione. Ad esempio, il secondo costruttore nell'esempio precedente può essere riscritto usando this:

public Employee(int weeklySalary, int numberOfWeeks)
    : this(weeklySalary * numberOfWeeks)
{
}

L'uso della parola chiave this nell'esempio precedente causa la chiamata di questo costruttore:

public Employee(int annualSalary)
{
    Salary = annualSalary;
}

I costruttori possono essere contrassegnati come public, private, protected, internal, protected internal o private protected. Questi modificatori di accesso definiscono il modo in cui gli utenti della classe possono costruire la classe. Per altre informazioni, vedere Modificatori di accesso.

Un costruttore può essere dichiarato statico usando la parola chiave static. I costruttori statici vengono chiamati automaticamente, immediatamente prima dell'accesso a tutti i campi statici e vengono usati per inizializzare i membri della classe statica. Per altre informazioni, vedere Costruttori statici.

Specifiche del linguaggio C#

Per altre informazioni, vedere Costruttori di istanze e Costruttori statici in Specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedi anche