Classe statique, méthode, constructeur, champ en C#

Dans C#, statique signifie qu'il est impossible de l'instancier. Vous ne pouvez pas créer d'objets de classes statiques, ni utiliser des objets pour accéder aux membres statiques.

Les classes, variables, méthodes, propriétés, opérateurs, événements et constructeurs peuvent être définis comme statiques en utilisant le mot-clé modificateur static.

Classe statique

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 ci-dessus est statique. Tous ses membres sont également statiques.

Vous ne pouvez pas créer d'objets de classes statiques. Par conséquent, vous pouvez accéder directement aux membres statiques de la classe ClassName.MemberName, comme indiqué ci-dessous.

class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　var result = Calculator.Sum(10,　25);　//Appeler une méthode statique
　　　　　　　　Calculator.Store(result);　
　　　　　　　　var calcType = Calculator.Type;　//　Accéder à la variable statique
　　　　　　　　Calculator.Type = "Scientific";　//　Affecter une valeur à une variable statique
　　　　}
}

Règles des classes statiques

1. Les classes statiques ne peuvent pas être instanciées.

2. Tous les membres d'une classe statique doivent être statiques. Sinon, le compilateur donnera une erreur.

3. Les classes statiques peuvent contenir des variables statiques, des méthodes statiques, des propriétés statiques, des opérateurs statiques, des événements statiques et des constructeurs statiques.

4. Les classes statiques ne peuvent pas contenir des membres d'instance et des constructeurs.

5. Les indexeurs et les destructeurs ne peuvent pas être statiques

6. var ne peut pas être utilisé pour définir des membres statiques. Vous devez spécifier explicitement le type de membre après la clé static.

7. Les classes statiques sont des classes scellées, par conséquent, elles ne peuvent pas être héritées.

8. Les classes statiques ne peuvent pas hériter de autres classes.

9. Vous pouvez accéder aux membres de la classe statique en utilisant ClassName.MemberName (c'est-à-dire : nomDeClasse.nomDeMembre).

10. Les classes statiques restent en mémoire tout au long de la durée de vie de l'espace d'applications où se trouve le programme.

Membres statiques dans une classe non statique

Classe ordinaire (classe non statique) peut contenir une ou plusieurs méthodes statiques, champs, propriétés, événements et autres membres non statiques.

Utiliser certains membres statiques pour définir une classe non statique, au lieu de déclarer toute la classe comme statique, est plus pratique.

Champ statique

Vous pouvez utiliser la clé static pour définir un champ statique dans une classe non statique.

Les champs statiques d'une classe non statique sont partagés entre toutes les instances. Par conséquent, les modifications apportées par une instance se reflètent dans les autres instances.

public class StopWatch
{
　　　　public static int InstanceCounter = 0;
　　　　//　Constructeur d'instance
　　　　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
　　　　}
}

Méthode statique

Vous pouvez définir une ou plusieurs méthodes statiques dans une classe non statique. Vous pouvez appeler des méthodes statiques sans créer d'objet. Vous ne pouvez pas utiliser un objet de classe non statique pour appeler une méthode statique.

Les méthodes statiques ne peuvent appeler que d'autres méthodes statiques et accéder aux membres statiques. Vous ne pouvez pas accéder aux membres non statiques de la classe dans une méthode statique.

class Program
{
　　　　static int counter = 0;
　　　　string name = "Demo Program";
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　counter++;　//　Il est possible d'accéder aux champs statiques
　　　　　　　　Display("Hello World!");　//　Il est possible d'appeler des méthodes statiques
　　　　　　　　name = "New Demo Program";　//Erreur : accès impossible à un membre non statique
　　　　　　　　SetRootFolder("C:\MyProgram");　//Erreur : impossible d'appeler une méthode non statique
　　　　}
　　　　static void Display(string text)
　　　　{
　　　　　　　　Console.WriteLine(text);
　　　　}
　　　　public void SetRootFolder(string path) { }
}

Règles des méthodes statiques

1. Les méthodes statiques peuvent être définies avec la clé de mots-clés static avant le type de retour, puis définies après les modificateurs d'accès.

2. Les méthodes statiques peuvent être surchargées, mais ne peuvent pas être overrides.

3. Les méthodes statiques peuvent contenir des variables statiques locales.

4. Les méthodes statiques ne peuvent pas accéder ou appeler des variables non statiques, sauf si elles sont explicitement passées en tant que paramètres.

Constructeur statique

Une classe non statique peut contenir un constructeur statique sans paramètres. Il peut être défini en utilisant la clé de mots-clés static, sans modificateurs d'accès, par exemple public, private et protected.

L'exemple suivant montre la différence entre le constructeur statique et le constructeur d'instance.

public class StopWatch
{
　　　　//　Constructeur statique
　　　　static StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Appelé le constructeur statique");
　　　　}
　　　　//　Constructeur d'instance
　　　　public StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Appelé le constructeur d'instance");
　　　　}
　　　　//　Méthode statique
　　　　public static void DisplayInfo()
　　　　{
　　　　　　　　Console.WriteLine("Appelé DisplayInfo");
　　　　}
　　　　//　Méthode d'instance
　　　　public void Start() { }
　　　　//　Méthode d'instance
　　　　public void Stop() { }
}

Le classe non statique StopWatch contient un constructeur statique, ainsi qu'un constructeur non statique.

Le constructeur statique est appelé une seule fois à chaque fois que l'on utilise une méthode statique ou crée une instance pour la première fois. L'exemple suivant montre que lors de la première appel de la méthode static, le constructeur static est appelé. La deuxième fois que l'on appelle la méthode static, le constructeur statique ne sera pas appelé.

StopWatch.DisplayInfo();　//　Ici, le constructeur statique est appelé
StopWatch.DisplayInfo();　//　Ici, le constructeur n'est pas appelé

Le constructeur statique a été appelé.
Appelé DisplayInfo
Appelé DisplayInfo

L'exemple suivant montre que lors de la création de l'instance pour la première fois, le constructeur statique est appelé.

StopWatch sw1　= new StopWatch();　//　Tout d'abord, le constructeur statique, puis le constructeur d'instance　
StopWatch sw2　= new StopWatch();//　Seul le constructeur d'instance est appelé　
StopWatch.DisplayInfo();

Appelé le constructeur statique
Appelé le constructeur d'instance
Appelé le constructeur d'instance
Appelé DisplayInfo

Règles du constructeur statique

1. Le constructeur statique est défini en utilisant la clé de mots-clés static, sans utiliser les modificateurs d'accès public, private ou protected.

2. Une classe non statique peut contenir un constructeur statique sans paramètres. Il n'est pas autorisé d'utiliser un constructeur statique paramétré.

3. Le constructeur statique ne s'exécute qu'une seule fois dans sa vie. Par conséquent, s'il est utilisé à plusieurs endroits dans une application, il n'est pas possible de déterminer quand il est appelé dans l'application.

4. Le constructeur statique ne peut accéder qu'aux membres statiques. Il ne peut pas contenir ou accéder aux membres d'instance.

Les membres statiques de la classe non statique sont partagés entre toutes les instances de la classe. Par conséquent, les modifications apportées par une instance se reflètent dans toutes les autres instances. Les membres statiques de la classe non statique sont stockés dans une zone spéciale appelée 'haute fréquence' en mémoire. Les membres statiques des classes non statiques sont partagés entre toutes les instances de la classe. Par conséquent, les modifications apportées par une instance se reflètent dans toutes les autres instances.