Condividi tramite

Utilizzo di costruttori (Guida per programmatori C#)

  • Articolo

Quando si crea un’istanza di una classe o una 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 i costruttori primari. Un costruttore primario indica 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 a quelli di classi. Quando viene creata un'istanza di un tipo struct con new, viene richiamato un costruttore. Quando un struct è impostato sul relativo valore default, il runtime inizializza su 0 tutta la memoria nella struct. Prima di C# 10, structs non può contenere un costruttore esplicito senza parametri perché questo viene fornito automaticamente dal compilatore. Per altre informazioni, vedere la sezione Inizializzazione Struct e valori predefiniti dell'articolo Tipi di struttura.

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

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

Il codice seguente, tuttavia, provoca un errore del compilatore perché non usa new e 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 le 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 le struct possono anche definire più costruttori. Né le une né gli altri devono necessariamente 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 di base non viene chiamato in modo esplicito usando la parola chiave base, il costruttore senza parametri, se ne esiste uno, viene chiamato in modo implicito. Le seguenti dichiarazioni del costruttore si equivalgono:

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

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

Se una classe di 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 subito prima dell'accesso ai campi statici e vengono usati per inizializzare i membri delle classi statiche. 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