Costruttori statici (Guida per programmatori C#)Static Constructors (C# Programming Guide)

Un costruttore statico consente di inizializzare gli eventuali dati static oppure di eseguire un'operazione specifica che deve essere effettuata una sola volta.A static constructor is used to initialize any static data, or to perform a particular action that needs to be performed once only. Viene chiamato automaticamente prima che ne venga creata la prima istanza o venga fatto riferimento a qualsiasi membro statico.It is called automatically before the first instance is created or any static members are referenced.

class SimpleClass
{
    // Static variable that must be initialized at run time.
    static readonly long baseline;

    // Static constructor is called at most one time, before any
    // instance constructor is invoked or member is accessed.
    static SimpleClass()
    {
        baseline = DateTime.Now.Ticks;
    }
}

OsservazioniRemarks

I costruttori statici hanno le proprietà seguenti:Static constructors have the following properties:

  • Un costruttore statico non accetta modificatori di accesso e non ha parametri.A static constructor does not take access modifiers or have parameters.

  • Una classe o struct può avere solo un costruttore statico.A class or struct can only have one static constructor.

  • I costruttori statici non possono essere ereditati e non è possibile eseguirne l'overload.Static constructors cannot be inherited or overloaded.

  • Un costruttore statico non può essere chiamato direttamente ed è progettato esclusivamente per essere chiamato da Common Language Runtime (CLR).A static constructor cannot be called directly and is only meant to be called by the common language runtime (CLR). Viene richiamato automaticamente.It is invoked automatically.

  • L'utente non può controllare in alcun modo il momento in cui il costruttore statico viene eseguito nel programma.The user has no control on when the static constructor is executed in the program.

  • Un costruttore statico viene chiamato automaticamente per inizializzare la classe prima che ne venga creata la prima istanza o venga fatto riferimento a qualsiasi membro statico.A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced. Un costruttore statico verrà eseguito prima di un costruttore di istanza.A static constructor will run before an instance constructor. Si noti che il costruttore statico di un tipo viene chiamato quando un metodo statico assegnato a un evento o un delegato viene chiamato, e non quando tale metodo viene assegnato.Note that a type's static constructor is called when a static method assigned to an event or a delegate is invoked and not when it is assigned. Gli eventuali inizializzatori variabili di campo statico presenti nella classe del costruttore statico verranno eseguiti nell'ordine testuale in cui appaiono nella dichiarazione della classe subito prima dell'esecuzione del costruttore statico.If static field variable initializers are present in the class of the static constructor, they will be executed in the textual order in which they appear in the class declaration immediately prior to the execution of the static constructor.

  • Se non si specifica un costruttore statico per inizializzare campi statici, tutti i campi statici vengono inizializzati sul relativo valore predefinito come indicato nella tabella dei valori predefiniti.If you don't provide a static constructor to initialize static fields, all static fields are initialized to their default value as listed in the Default Values Table.

  • Se un costruttore statico genera un'eccezione, il runtime non lo chiamerà una seconda volta e il tipo rimarrà non inizializzato per la durata del dominio dell'applicazione in cui il programma è in esecuzione.If a static constructor throws an exception, the runtime will not invoke it a second time, and the type will remain uninitialized for the lifetime of the application domain in which your program is running. Viene più comunemente generata un'eccezione TypeInitializationException quando un costruttore statico non è in grado di creare un'istanza di un tipo o per un'eccezione non gestita che si verifica all'interno di un costruttore statico.Most commonly, a TypeInitializationException exception is thrown when a static constructor is unable to instantiate a type or for an unhandled exception occurring within a static constructor. Per i costruttori statici impliciti che non sono definiti in modo esplicito nel codice sorgente, la risoluzione dei problemi può richiedere l'ispezione del codice IL (Intermediate Language).For implicit static constructors that are not explicitly defined in source code, troubleshooting may require inspection of the intermediate language (IL) code.

  • La presenza di un costruttore statico impedisce l'aggiunta dell'attributo di tipo BeforeFieldInit.The presence of a static constructor prevents the addition of the BeforeFieldInit type attribute. Ciò limita l'ottimizzazione in fase di esecuzione.This limits runtime optimization.

  • Un campo dichiarato come static readonly può essere assegnato solo come parte della relativa dichiarazione o in un costruttore statico.A field declared as static readonly may only be assigned as part of its declaration or in a static constructor. Quando non è richiesto un costruttore statico esplicito, inizializzare i campi statici in fase di dichiarazione, anziché tramite un costruttore statico per una migliore ottimizzazione in fase di esecuzione.When an explicit static constructor is not required, initialize static fields at declaration, rather than through a static constructor for better runtime optimization.

Nota

Anche se non è direttamente accessibile, la presenza di un costruttore statico esplicito deve essere documentata per facilitare la risoluzione dei problemi relativi alle eccezioni di inizializzazione.Though not directly accessible, the presence of an explicit static constructor should be documented to assist with troubleshooting initialization exceptions.

UtilizzoUsage

  • In genere, i costruttori statici sono usati per scrivere voci nel file di log, quando alla classe è associato un file di log.A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.

  • I costruttori statici risultano utili anche durante la creazione di classi wrapper per il codice non gestito, quando il costruttore può chiamare il metodo LoadLibrary.Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.

  • I costruttori statici sono anche un modo pratico per applicare controlli di runtime al parametro di tipo che non può essere controllato in fase di compilazione tramite i vincoli (vincoli del parametro di tipo).Static constructors are also a convenient place to enforce run-time checks on the type parameter that cannot be checked at compile-time via constraints (Type parameter constraints).

EsempioExample

In questo esempio la classe Bus ha un costruttore statico.In this example, class Bus has a static constructor. Quando viene creata la prima istanza di Bus (bus1), il costruttore statico viene chiamato per inizializzare la classe.When the first instance of Bus is created (bus1), the static constructor is invoked to initialize the class. L'output dell'esempio verifica che il costruttore statico venga eseguito una sola volta, anche se vengono create due istanze di Bus, e che venga eseguito prima del costruttore di istanze.The sample output verifies that the static constructor runs only one time, even though two instances of Bus are created, and that it runs before the instance constructor runs.

 public class Bus
 {
     // Static variable used by all Bus instances.
     // Represents the time the first bus of the day starts its route.
     protected static readonly DateTime globalStartTime;

     // Property for the number of each bus.
     protected int RouteNumber { get; set; }

     // Static constructor to initialize the static variable.
     // It is invoked before the first instance constructor is run.
     static Bus()
     {
         globalStartTime = DateTime.Now;

         // The following statement produces the first line of output, 
         // and the line occurs only once.
         Console.WriteLine("Static constructor sets global start time to {0}",
             globalStartTime.ToLongTimeString());
     }

     // Instance constructor.
     public Bus(int routeNum)
     {
         RouteNumber = routeNum;
         Console.WriteLine("Bus #{0} is created.", RouteNumber);
     }

     // Instance method.
     public void Drive()
     {
         TimeSpan elapsedTime = DateTime.Now - globalStartTime;

         // For demonstration purposes we treat milliseconds as minutes to simulate
         // actual bus times. Do not do this in your actual bus schedule program!
         Console.WriteLine("{0} is starting its route {1:N2} minutes after global start time {2}.",
                                 this.RouteNumber,
                                 elapsedTime.Milliseconds,
                                 globalStartTime.ToShortTimeString());
     }
 }

 class TestBus
 {
     static void Main()
     {
         // The creation of this instance activates the static constructor.
         Bus bus1 = new Bus(71);

         // Create a second bus.
         Bus bus2 = new Bus(72);

         // Send bus1 on its way.
         bus1.Drive();

         // Wait for bus2 to warm up.
         System.Threading.Thread.Sleep(25);

         // Send bus2 on its way.
         bus2.Drive();

         // Keep the console window open in debug mode.
         System.Console.WriteLine("Press any key to exit.");
         System.Console.ReadKey();
     }
 }
 /* Sample output:
     Static constructor sets global start time to 3:57:08 PM.
     Bus #71 is created.
     Bus #72 is created.
     71 is starting its route 6.00 minutes after global start time 3:57 PM.
     72 is starting its route 31.00 minutes after global start time 3:57 PM.      
*/

Specifiche del linguaggio C#C# language specification

Per altre informazioni, vedere la sezione Costruttori statici della specifica del linguaggio C#.For more information, see the Static constructors section of the C# language specification.

Vedere ancheSee also