C# Academy · Lezione

Costruttori statici

Inizializzi lo stato statico una sola volta.

Costruttori statici è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Che cos'è un costruttore statico?

Un costruttore statico inizializza i dati statici di una classe. Viene eseguito automaticamente una sola volta, prima del primo utilizzo della classe, e non viene mai chiamato direttamente.

using System;

class App
{
    public static string Version;

    static App()
    {
        Version = "1.0.0";
        Console.WriteLine("Static constructor ran");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(App.Version);
    }
}

Regole di sintassi

Un costruttore statico usa la parola chiave static, ha il nome della classe, non accetta parametri e non ha alcun modificatore di accesso.

using System;

class Config
{
    public static int MaxUsers;

    static Config()
    {
        MaxUsers = 100;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Max: " + Config.MaxUsers);
    }
}

Viene eseguito esattamente una volta

Indipendentemente dal numero di volte in cui si usa la classe, il costruttore statico viene eseguito una sola volta, la prima volta che è necessario.

using System;

class Counter
{
    public static int Instances;

    static Counter()
    {
        Console.WriteLine("Initializing static state");
        Instances = 0;
    }

    public Counter() { Instances++; }
}

class Program
{
    static void Main()
    {
        new Counter();
        new Counter();
        Console.WriteLine("Instances: " + Counter.Instances);
    }
}

Quando viene attivato?

Il runtime lo chiama subito prima del primo accesso a un membro statico oppure della prima creazione di un'istanza, a seconda di quale evento si verifica per primo.

using System;

class Lazy
{
    public static string Data;

    static Lazy()
    {
        Console.WriteLine("Triggered now");
        Data = "ready";
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before access");
        Console.WriteLine(Lazy.Data);
    }
}

Inizializzare dati statici complessi

Usi un costruttore statico quando i campi statici richiedono una logica reale di configurazione, non solo semplici valori letterali.

using System;
using System.Collections.Generic;

class Lookup
{
    public static Dictionary<int, string> Table;

    static Lookup()
    {
        Table = new Dictionary<int, string>();
        for (int i = 1; i <= 3; i++)
            Table[i] = "Item" + i;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lookup.Table[2]);
    }
}

Costruttore statico e inizializzatore di campo

Per i valori semplici è possibile usare inizializzatori inline. Un costruttore statico è adatto alla configurazione che richiede istruzioni, cicli o gestione degli errori.

using System;

class Settings
{
    public static int Simple = 10;        // inline initializer
    public static int Computed;            // needs logic

    static Settings()
    {
        Computed = Simple * Simple;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Settings.Simple + ", " + Settings.Computed);
    }
}

Nessun parametro consentito

Poiché viene chiamato dal runtime, un costruttore statico non può accettare argomenti. Tutti i suoi input devono essere altri dati statici o costanti.

using System;

class Clock
{
    public static int StartHour;

    static Clock()
    {
        StartHour = 9;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Start: " + Clock.StartHour);
    }
}

Combinare costruttori statici e di istanza

Una classe può contenere entrambi i tipi. Quello statico viene eseguito una volta per il tipo; quello di istanza viene eseguito per ogni oggetto.

using System;

class Game
{
    public static string Title;
    public int Score;

    static Game()
    {
        Title = "Coddy Quest";
    }

    public Game(int score)
    {
        Score = score;
    }
}

class Program
{
    static void Main()
    {
        var g = new Game(50);
        Console.WriteLine(Game.Title + " score " + g.Score);
    }
}

Garanzia sull'ordine

È garantito che il costruttore statico termini prima dell'esecuzione del corpo di qualsiasi costruttore di istanza che lo attivi, quindi lo stato statico è sempre pronto.

using System;

class Service
{
    public static string Endpoint;

    static Service()
    {
        Endpoint = "https://api.example.com";
    }

    public Service()
    {
        Console.WriteLine("Using " + Endpoint);
    }
}

class Program
{
    static void Main()
    {
        new Service();
    }
}

Usare con moderazione

I costruttori statici aggiungono un controllo una tantum prima dell'uso della classe e possono compromettere le prestazioni se usati eccessivamente o se generano eccezioni. Li mantenga brevi e affidabili.

using System;

class Cache
{
    public static int[] Data;

    static Cache()
    {
        Data = new int[] { 2, 4, 6, 8 };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Cache.Data[3]);
    }
}

Mettere tutto insieme

I costruttori statici sono ideali per la configurazione una tantum di dati condivisi e di sola lettura, come tabelle di ricerca o configurazioni caricate da costanti.

using System;
using System.Collections.Generic;

class Currency
{
    public static Dictionary<string, string> Symbols;

    static Currency()
    {
        Symbols = new Dictionary<string, string>
        {
            ["USD"] = "$",
            ["EUR"] = "E",
            ["JPY"] = "Y"
        };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("USD symbol: " + Currency.Symbols["USD"]);
    }
}

Verifica rapida

Metta alla prova la Sua comprensione dei costruttori statici.

Riepilogo

Un costruttore statico usa static ClassName(), non accetta parametri e non ha alcun modificatore di accesso. Viene eseguito una sola volta, automaticamente, prima del primo utilizzo della classe, per inizializzare lo stato statico che richiede una logica reale. Lo usi con moderazione per la configurazione una tantum di dati condivisi.

using System;

class Demo
{
    public static int Value;
    static Demo() { Value = 42; }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.Value);
    }
}

Domande Frequenti

La lezione «Costruttori statici» è gratuita?

Sì — il testo completo di «Costruttori statici» è 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 «Costruttori statici»?

Inizializzi lo stato statico una sola volta. 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 4 di 4.

Quanto tempo richiede la lezione «Costruttori statici»?

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