À propos du mot-clé « static » en C#

Voici les principaux cas d’utilisation et exemples d’utilisation du mot-clé static en C# :

Utilisations

Champs statiques

Ils représentent des variables qui appartiennent au type lui-même et sont partagées par toutes les instances du type.

Par exemple :

1
2
3
4
5
6
7

public class Example
{
    public static int PI = 3.14;
}

//Outputs 3.14
Console.WriteLine(Example.PI);

Méthodes statiques

Ces méthodes appartiennent au type lui-même et vous pouvez les appeler sans créer d’instance du type.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Example
{
    public static void SayHello()
    {
        Console.WriteLine("Salut !");
    }
}

//Outputs "Salut !"
Example.SayHello()

Propriétés statiques

Ce type de propriétés appartient au type lui-même.

1
2
3
4
5
6
7
8
9

public class Person
{
    public static int Count { get; private set; }

    public Person()
    {
        Count++;
    }
}

L’exemple ci-dessus illustre un cas d’utilisation dans lequel une propriété statique permet de suivre le nombre d’instances de classe créées. La propriété reste accessible (Person.Count) plutôt que par une instance.

Constructeurs statiques

Ces constructeurs initialisent les membres statiques du type. Ils sont appelés automatiquement avant tout accès aux membres statiques et ne sont exécutés qu’une seule fois.

1
2
3
4
5
6
7
8
9

public class Example
{
    public static int StaticField;

    static Example()
    {
        StaticField = 42;
    }
}

Classes statiques

Ces classes ne peuvent contenir que des membres statiques. Vous ne pouvez pas créer d’instance d’une classe statique, et elle est généralement utilisée pour regrouper des méthodes utilitaires.

1
2
3
4
5
6
7

public static class Utility
{
    public static void HelperMethod()
    {
       Console.WriteLine("This is a helper method.");
    }
}

Avantages et inconvénients

L’utilisation de static en C# offre plusieurs avantages clés pour le développement d’applications :

• Efficacité de la mémoire : une seule copie existe pour l’ensemble de l’application, quel que soit le nombre d’instances de classe créées, et l’utilisation de la mémoire est réduite puisqu’aucune instanciation d’objet n’est nécessaire.

• Gestion de l’état : en termes d’accès global, ils fournissent des valeurs partagées accessibles à l’ensemble de l’application sans création d’instance. Il s’agit par exemple de maintenir des constantes ou des valeurs de configuration à l’échelle de l’application. Au niveau de la classe, c’est avantageux pour mettre en œuvre des modèles de singleton ou gérer un état à l’échelle de la classe.

Cependant, vous devez tenir compte de certaines limitations :

• Ils ne sont pas « thread-safe » par défaut et peuvent causer des fuites de données.
• Elles peuvent rendre le code plus difficile à maintenir si elles sont utilisées de manière excessive en tant que variables globales.
• Elles ne peuvent pas accéder aux membres non statiques sans une référence d’instance explicite.

Cas d’utilisation du mot clé static

Méthodes utilitaires

Comme nous l’avons expliqué ci-dessus, les classes utilitaires utilisent généralement le mot-clé static.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static class MathHelper
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
    public static int Subtrack(int a, int b)
    {
        return a - b;
    }

    /// etc...
}

Modèle Singleton

S’assurer qu’une classe n’a qu’une seule instance, et fournir un point d’accès global à celle-ci, c’est un cas bien classique.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class Singleton
{
    private static Singleton _instance;

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new Singleton();
            }
            return _instance;
        }
    }
}

Constantes

Définir des valeurs qui ne changent pas est un autre cas d’utilisation courant.

1
2
3
4

public class Constants
{
   public static const string AppName = "MyApplication";
}

Données partagées

Lorsque vous avez besoin de partager des données entre toutes les instances d’une classe, vous pouvez utiliser le mot-clé static.

1
2
3
4

public class Configuration
{
   public static string ConnectionString;
}

Conclusion

Pour en savoir plus, consultez les ressources de Microsoft sur le sujet :

• Microsoft Docs : Classes statiques et membres de classe statique (Guide de programmation C#)
• Microsoft Docs : static (référence C#)