Classi statiche e membri di classi statiche (Guida per programmatori C#)Static Classes and Static Class Members (C# Programming Guide)

Una classe statica corrisponde fondamentalmente a una classe non statica, ma c'è una differenza: di una classe statica non è possibile creare un'istanza.A static class is basically the same as a non-static class, but there is one difference: a static class cannot be instantiated. In altre parole, non è possibile usare l'operatore new per creare una variabile del tipo di classe.In other words, you cannot use the new operator to create a variable of the class type. Poiché non esiste una variabile dell'istanza, si accede ai membri di una classe statica tramite il nome stesso della classe.Because there is no instance variable, you access the members of a static class by using the class name itself. Se ad esempio si dispone di una classe statica denominata UtilityClass che ha un metodo statico pubblico denominato MethodA, si chiama il metodo come illustrato nell'esempio seguente:For example, if you have a static class that is named UtilityClass that has a public static method named MethodA, you call the method as shown in the following example:

UtilityClass.MethodA();  

Una classe statica può essere usata come un contenitore adatto per insiemi di metodi che funzionano solo sui parametri di input e non devono ottenere o impostare campi di istanza interni.A static class can be used as a convenient container for sets of methods that just operate on input parameters and do not have to get or set any internal instance fields. Ad esempio, nella libreria di classi .NET Framework, la classe statica System.Math contiene diversi metodi che eseguono operazioni matematiche, senza alcun requisito per archiviare o recuperare dati univoci per una particolare istanza della classe Math.For example, in the .NET Framework Class Library, the static System.Math class contains methods that perform mathematical operations, without any requirement to store or retrieve data that is unique to a particular instance of the Math class. In altre parole, si applicano i membri della classe specificando il nome della classe e il nome del metodo, come illustrato nell'esempio seguente.That is, you apply the members of the class by specifying the class name and the method name, as shown in the following example.

double dub = -3.14;  
Console.WriteLine(Math.Abs(dub));  
Console.WriteLine(Math.Floor(dub));  
Console.WriteLine(Math.Round(Math.Abs(dub)));  
  
// Output:  
// 3.14  
// -4  
// 3  

Come per tutti i tipi di classe, le informazioni sul tipo per una classe statica vengono caricate da Common Language Runtime (CLR) di .NET Framework quando viene caricato il programma che fa riferimento alla classe.As is the case with all class types, the type information for a static class is loaded by the .NET Framework common language runtime (CLR) when the program that references the class is loaded. Il programma non può specificare esattamente quando la classe verrà caricata.The program cannot specify exactly when the class is loaded. Tuttavia, è garantito che la classe sarà caricata, che i suoi campi saranno inizializzati e che il costruttore statico sarà chiamato prima che il programma faccia riferimento per la prima volta alla classe stessa.However, it is guaranteed to be loaded and to have its fields initialized and its static constructor called before the class is referenced for the first time in your program. Un costruttore statico viene chiamato solo un volta e una classe statica rimane in memoria per la durata del dominio dell'applicazione in cui risiede il programma.A static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.

Nota

Per creare una classe non statica che consente la creazione di un'unica istanza di se stessa, vedere Implementing Singleton in C# (Implementare Singleton in C#).To create a non-static class that allows only one instance of itself to be created, see Implementing Singleton in C#.

Nell'esempio riportato di seguito sono indicate le principali funzionalità delle classi statiche:The following list provides the main features of a static class:

  • Contiene solo membri statici.Contains only static members.

  • Non è possibile crearne istanze.Cannot be instantiated.

  • È sealed.Is sealed.

  • Non può contenere costruttori di istanze.Cannot contain Instance Constructors.

La creazione di una classe statica è pertanto analoga alla creazione di una classe che contiene solo membri statici e un costruttore privato,Creating a static class is therefore basically the same as creating a class that contains only static members and a private constructor. che impedisce la creazione di istanze della classe.A private constructor prevents the class from being instantiated. Una classe statica presenta un indubbio vantaggio. Consente infatti al compilatore di verificare che non vengano aggiunti accidentalmente membri di istanzeThe advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. e quindi di garantire che non vengano create istanze di questa classe.The compiler will guarantee that instances of this class cannot be created.

Le classi statiche sono sealed e pertanto non possono essere ereditate.Static classes are sealed and therefore cannot be inherited. Possono ereditare solo dalla classe Object.They cannot inherit from any class except Object. Le classi statiche non possono contenere un costruttore di istanza; possono però contenere un costruttore statico.Static classes cannot contain an instance constructor; however, they can contain a static constructor. Le classi non statiche devono definire anche un costruttore statico se la classe contiene membri statici che richiedono un'inizializzazione più complessa.Non-static classes should also define a static constructor if the class contains static members that require non-trivial initialization. Per altre informazioni, vedere Costruttori statici.For more information, see Static Constructors.

EsempioExample

Di seguito è riportato un esempio di una classe statica contenente due metodi che consentono di convertire i valori relativi alla temperatura da gradi Celsius a gradi Fahrenheit e viceversa:Here is an example of a static class that contains two methods that convert temperature from Celsius to Fahrenheit and from Fahrenheit to Celsius:

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius)
    {
        // Convert argument to double for calculations.
        double celsius = Double.Parse(temperatureCelsius);

        // Convert Celsius to Fahrenheit.
        double fahrenheit = (celsius * 9 / 5) + 32;

        return fahrenheit;
    }

    public static double FahrenheitToCelsius(string temperatureFahrenheit)
    {
        // Convert argument to double for calculations.
        double fahrenheit = Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;
    }
}

class TestTemperatureConverter
{
    static void Main()
    {
        Console.WriteLine("Please select the convertor direction");
        Console.WriteLine("1. From Celsius to Fahrenheit.");
        Console.WriteLine("2. From Fahrenheit to Celsius.");
        Console.Write(":");

        string selection = Console.ReadLine();
        double F, C = 0;

        switch (selection)
        {
            case "1":
                Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine());
                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());
                Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                break;

            default:
                Console.WriteLine("Please select a convertor.");
                break;
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Example Output:
    Please select the convertor direction
    1. From Celsius to Fahrenheit.
    2. From Fahrenheit to Celsius.
    :2
    Please enter the Fahrenheit temperature: 20
    Temperature in Celsius: -6.67
    Press any key to exit.
 */

Membri staticStatic Members

Una classe non statica può contenere metodi, campi, proprietà o eventi statici.A non-static class can contain static methods, fields, properties, or events. È possibile chiamare il membro statico di una classe anche quando non sono state create istanze della classe.The static member is callable on a class even when no instance of the class has been created. Al membro statico si accede sempre tramite il nome della classe, non tramite il nome dell'istanza.The static member is always accessed by the class name, not the instance name. Di un membro statico esiste una sola copia, indipendentemente dal numero di istanze della classe create.Only one copy of a static member exists, regardless of how many instances of the class are created. Proprietà e metodi statici non possono accedere a campi non statici ed eventi nel tipo che li contiene e non possono accedere a una variabile dell'istanza di qualsiasi oggetto a meno che non venga esplicitamente passata in un parametro del metodo.Static methods and properties cannot access non-static fields and events in their containing type, and they cannot access an instance variable of any object unless it is explicitly passed in a method parameter.

È più frequente dichiarare una classe non statica con alcuni membri statici, che dichiarare un'intera classe come statica.It is more typical to declare a non-static class with some static members, than to declare an entire class as static. Due utilizzi comuni di campi statici sono: tenere un conteggio del numero di oggetti di cui è stata creata un'istanza o archiviare un valore che deve essere condiviso fra tutte le istanze.Two common uses of static fields are to keep a count of the number of objects that have been instantiated, or to store a value that must be shared among all instances.

I metodi statici possono essere sottoposti a overload ma non a override, perché appartengono alla classe e non a qualsiasi istanza della classe.Static methods can be overloaded but not overridden, because they belong to the class, and not to any instance of the class.

Sebbene non sia possibile dichiarare un campo come static const, il campo const è essenzialmente statico nel comportamento.Although a field cannot be declared as static const, a const field is essentially static in its behavior. Appartiene al tipo, non a istanze del tipo.It belongs to the type, not to instances of the type. Pertanto, non è possibile accedere ai campi const tramite la stessa notazione ClassName.MemberName usata per i campi statici.Therefore, const fields can be accessed by using the same ClassName.MemberName notation that is used for static fields. Non è richiesta alcuna istanza dell'oggetto.No object instance is required.

C# non supporta variabili locali statiche (variabili dichiarate nell'ambito del metodo).C# does not support static local variables (variables that are declared in method scope).

I membri delle classi statiche vengono dichiarati tramite la parola chiave static prima del tipo restituito, come illustrato nell'esempio seguente:You declare static class members by using the static keyword before the return type of the member, as shown in the following example:

public class Automobile
{
    public static int NumberOfWheels = 4;
    public static int SizeOfGasTank
    {
        get
        {
            return 15;
        }
    }
    public static void Drive() { }
    public static event EventType RunOutOfGas;

    // Other non-static fields and properties...
}

I membri statici vengono inizializzati prima dell'accesso iniziale e prima dell'eventuale chiamata al costruttore statico, se presente.Static members are initialized before the static member is accessed for the first time and before the static constructor, if there is one, is called. Per accedere a un membro di una classe statica, usare il nome della classe anziché il nome di una variabile per specificare la posizione del membro, come illustrato nell'esempio seguente:To access a static class member, use the name of the class instead of a variable name to specify the location of the member, as shown in the following example:

Automobile.Drive();
int i = Automobile.NumberOfWheels;

Se la classe contiene campi statici, fornire un costruttore statico che li inizializzi al caricamento della classe.If your class contains static fields, provide a static constructor that initializes them when the class is loaded.

Una chiamata a un metodo statico genera un'istruzione call in Microsoft Intermediate Language (MSIL), mentre una chiamata a un metodo di istanza genera un'istruzione callvirt che verifica anche la presenza di riferimenti a un oggetto null.A call to a static method generates a call instruction in Microsoft intermediate language (MSIL), whereas a call to an instance method generates a callvirt instruction, which also checks for a null object references. Tuttavia, nella maggior parte dei casi, la differenza di prestazioni tra i due non è significativa.However, most of the time the performance difference between the two is not significant.

Specifiche del linguaggio C#C# Language Specification

Per altre informazioni, vedere Classi statiche e Membri statici e di istanza nella specifica del linguaggio C#.For more information, see Static classes and Static and instance members in the C# Language Specification. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.The language specification is the definitive source for C# syntax and usage.

Vedere ancheSee also