Classi statiche, metodi, costruttori, campi in C#

In C#, statico rappresenta il contenuto non istanziabile. Non è possibile creare oggetti di classi statiche né accedere ai membri statici utilizzando oggetti.

Le classi, le variabili, i metodi, gli attributi, gli operatori, gli eventi e i costruttori possono essere definiti come statici utilizzando la parola chiave static.

Classi statiche

public static class Calculator
{
　　　　private static int _resultStorage = 0;
　　　　
　　　　public static string Type = "Arithmetic";
　　　　public static int Sum(int num1, int num2)
　　　　{
　　　　　　　　return num1 + num2;
　　　　}
　　　　public static void Store(int result)
　　　　{
　　　　　　　　_resultStorage = result;
　　　　}
}

La classe Calculator sopra indicata è statica. Tutti i suoi membri sono statici.

Non è possibile creare oggetti di classi statiche. Pertanto, i membri delle classi statiche possono essere acceduti direttamente utilizzando il nome della classe ClassName.MemberName, come indicato di seguito.

class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　var result = Calculator.Sum(10, 25); // Chiamata al metodo statico
　　　　　　　　Calculator.Store(result);　
　　　　　　　　var calcType = Calculator.Type; // Accesso alla variabile statica
　　　　　　　　Calculator.Type = "Scientific"; // Assegnazione di un valore alla variabile statica
　　　　}
}

Regole delle classi statiche

1. Le classi statiche non possono essere istanziate.

2. Tutti i membri delle classi statiche devono essere statici. Altrimenti, il compilatore genererà un errore.

3. Le classi statiche possono contenere variabili statiche, metodi statici, attributi statici, operatori statici, eventi statici e costruttori statici.

4. Le classi statiche non possono contenere membri di istanza e costruttori.

5. Gli indici e i distruttori non possono essere statici

6. var non può essere utilizzato per definire membri statici. È necessario specificare esplicitamente il tipo del membro dopo la parola chiave static.

7. Le classi statiche sono classi密封，quindi non possono essere ereditate.

8. Le classi statiche non possono ereditare da altre classi.

9. I membri delle classi statiche possono essere acceduti utilizzando ClassName.MemberName (ovvero: nomeclasse.nommembro).

10. Le classi statiche vengono mantenute in memoria per tutto il ciclo di vita dell'applicazione in cui si trova il programma.

Membri statici di classi non statiche

Le classi normali (classi non statiche) possono contenere uno o più metodi statici, campi, proprietà, eventi e altri membri non statici.

Definire alcune member statiche in una classe non statica, invece di dichiarare l'intera classe come statica, è più pratico.

Campi statici

Puoi definire campi statici in una classe non statica utilizzando la parola chiave static.

I campi statici di una classe non statica sono condivisi tra tutte le istanze. Pertanto, le modifiche fatte da una istanza si riflettono sulle altre istanze.

public class StopWatch
{
　　　　public static int InstanceCounter = 0;
　　　　// Costruttore dell'istanza
　　　　public StopWatch()
　　　　{
　　　　}
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　StopWatch sw1 = new StopWatch();
　　　　　　　　StopWatch sw2 = new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances); //2　
　　　　　　　　StopWatch sw3 = new StopWatch();
　　　　　　　　StopWatch sw4 = new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances); //4
　　　　}
}

Metodi statici

Puoi definire uno o più metodi statici in una classe non statica. Puoi chiamare metodi statici senza creare un oggetto. Non puoi chiamare metodi statici utilizzando un oggetto di classe non statica.

I metodi statici possono chiamare altri metodi statici e accedere ai membri statici. Non puoi accedere ai membri non statici della classe in un metodo statico.

class Program
{
　　　　static int counter = 0;
　　　　string name = "Demo Program";
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　counter++; //Posso accedere a campi statici
　　　　　　　　Display("Hello World!"); //Posso chiamare un metodo statico
　　　　　　　　name = "New Demo Program"; //Errore: impossibile accedere a membri non statici
　　　　　　　　SetRootFolder("C:\MyProgram"); //Errore: impossibile chiamare un metodo non statico
　　　　}
　　　　static void Display(string text)
　　　　{
　　　　　　　　Console.WriteLine(text);
　　　　}
　　　　public void SetRootFolder(string path) { }
}

Regole dei metodi statici

1. I metodi statici possono essere definiti prima del tipo di ritorno utilizzando la parola chiave static, poi dopo l'access modifier.

2. I metodi statici possono essere sovraccaricati ma non possono essere sovrascritti.

3. I metodi statici possono contenere variabili statiche locali.

4. I metodi statici non possono accedere o chiamare variabili non statiche, a meno che non vengano passate esplicitamente come parametri.

Costruttore statico

Una classe non statica può contenere un costruttore statico senza parametri. Può essere definito utilizzando la parola chiave static, senza l'access modifier, ad esempio public, private e protected.

Nell'esempio seguente viene dimostrato la differenza tra il costruttore statico e il costruttore dell'istanza.

public class StopWatch
{
　　　　// Costruttore statico
　　　　static StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("È stato chiamato il costruttore statico");
　　　　}
　　　　// Costruttore dell'istanza
　　　　public StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("È stato chiamato il costruttore dell'istanza");
　　　　}
　　　　// Metodo statico
　　　　public static void DisplayInfo()
　　　　{
　　　　　　　　Console.WriteLine("È stato chiamato DisplayInfo");
　　　　}
　　　　// Metodo dell'istanza
　　　　public void Start() { }
　　　　// Metodo dell'istanza
　　　　public void Stop() { }
}

La classe non statica StopWatch contiene un costruttore statico e anche un costruttore non statico.

Ogni volta che si utilizza un metodo statico o si crea la prima istanza, il costruttore statico viene chiamato una sola volta. Nell'esempio seguente, al primo chiamata del metodo statico viene chiamato il costruttore statico. La seconda chiamata del metodo statico non chiamerà il costruttore statico.

StopWatch.DisplayInfo(); // Qui viene chiamato il costruttore statico
StopWatch.DisplayInfo(); // Qui non viene chiamato il costruttore

È stato chiamato il costruttore statico.
È stato chiamato DisplayInfo
È stato chiamato DisplayInfo

Nell'esempio seguente, al primo creazione dell'istanza viene chiamato il costruttore statico.

StopWatch sw1 = new StopWatch(); // Prima il costruttore statico, poi il costruttore dell'istanza　
StopWatch sw2 = new StopWatch(); // Viene chiamato solo il costruttore dell'istanza　
StopWatch.DisplayInfo();

È stato chiamato il costruttore statico
È stato chiamato il costruttore dell'istanza
È stato chiamato il costruttore dell'istanza
È stato chiamato DisplayInfo

Regole del costruttore statico

1. Il costruttore statico è definito utilizzando la parola chiave static, senza utilizzare l'access modifier public, private o protected.

2. 非静态类可以包含一个无参数的静态构造函数。不允许使用参数化的静态构造函数。

3. 静态构造函数将在生命周期内仅执行一次。因此，如果在多个地方都使用了一个类，则无法确定何时在应用程序中调用它。

4. 静态构造函数只能访问静态成员。它不能包含或访问实例成员。

静态成员存储在内存中称为“高频堆”的特殊区域中。非静态类的静态成员在该类的所有实例之间共享。因此，一个实例所做的更改将反映在所有其他实例中。