Partager via

Classes statiques et membres de classe statique (Guide de programmation C#)

Une classe statique est essentiellement identique à une classe non statique, mais il existe une différence : une classe statique ne peut pas être instanciée. En d’autres termes, vous ne pouvez pas utiliser le nouvel opérateur pour créer une variable du type de classe. Étant donné qu’il n’existe aucune variable d’instance, vous accédez aux membres d’une classe statique à l’aide du nom de classe lui-même. Par exemple, si vous avez une classe statique nommée UtilityClass qui a une méthode statique publique nommée MethodA, vous appelez la méthode comme indiqué dans l’exemple suivant :

UtilityClass.MethodA();

Une classe statique peut être utilisée comme conteneur pratique pour les ensembles de méthodes qui fonctionnent simplement sur les paramètres d’entrée et n’ont pas besoin d’obtenir ou de définir des champs d’instance internes. Par exemple, dans la bibliothèque de classes .NET, la classe statique System.Math contient des méthodes qui effectuent des opérations mathématiques, sans qu’il soit nécessaire de stocker ou de récupérer des données uniques à une instance particulière de la Math classe. Autrement dit, vous appliquez les membres de la classe en spécifiant le nom de la classe et le nom de la méthode, comme illustré dans l’exemple suivant.

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

Comme c’est le cas avec tous les types de classes, le runtime .NET charge les informations de type d’une classe statique lorsque le programme qui référence la classe est chargé. Le programme ne peut pas spécifier exactement quand la classe est chargée. Toutefois, il est garanti de charger et d’avoir ses champs initialisés et son constructeur statique appelé avant que la classe soit référencée pour la première fois dans votre programme. Un constructeur statique n’est appelé qu’une seule fois et une classe statique reste en mémoire pendant la durée de vie du domaine d’application dans lequel réside votre programme.

Remarque

Pour créer une classe non statique qui autorise la création d’une seule instance de lui-même, consultez Implémentation de Singleton en C#.

La liste suivante fournit les principales fonctionnalités d’une classe statique :

  • Contient uniquement des membres statiques.

  • Impossible d’instancier.

  • Est scellé.

  • Elle ne peut pas contenir de constructeurs d’instances.

La création d’une classe statique est donc essentiellement identique à la création d’une classe qui contient uniquement des membres statiques et un constructeur privé. Un constructeur privé empêche l’instanciation de la classe. L’avantage de l’utilisation d’une classe statique est que le compilateur peut vérifier qu’aucun membre d’instance n’est ajouté accidentellement. Le compilateur garantit que les instances de cette classe ne peuvent pas être créées.

Les classes statiques sont scellées et ne peuvent donc pas être héritées. Ils ne peuvent hériter d’aucune classe ou interface, sauf Object. Les classes statiques ne peuvent pas contenir de constructeur d’instance. Toutefois, elles peuvent contenir un constructeur statique. Les classes non statiques doivent également définir un constructeur statique si la classe contient des membres statiques qui nécessitent une initialisation non triviale. Pour plus d’informations, consultez Constructeurs statiques.

Exemple :

Voici un exemple de classe statique qui contient deux méthodes qui convertissent la température de Celsius en Fahrenheit et de Fahrenheit en 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() ?? "0");
                Console.WriteLine($"Temperature in Fahrenheit: {F:F2}");
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine() ?? "0");
                Console.WriteLine($"Temperature in Celsius: {C:F2}");
                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.
 */

Membres statiques

Une classe non statique peut contenir des méthodes statiques, des champs, des propriétés ou des événements. Le membre statique est appelant sur une classe même lorsqu’aucune instance de la classe n’existe. Le membre statique est toujours accessible par le nom de la classe, et non par le nom de l’instance. Une seule copie d’un membre statique existe, quel que soit le nombre d’instances de la classe créées. Les méthodes statiques et les propriétés ne peuvent pas accéder aux champs et événements non statiques dans leur type conteneur, et ils ne peuvent pas accéder à une variable d’instance d’un objet, sauf si elle est transmise explicitement dans un paramètre de méthode.

Il est plus courant de déclarer une classe non statique avec certains membres statiques que de déclarer une classe entière comme statique. Deux utilisations courantes des champs statiques sont de conserver le nombre d’objets instanciés ou de stocker une valeur qui doit être partagée entre toutes les instances.

Les méthodes statiques peuvent être surchargées, mais non substituées, car elles appartiennent à la classe, et non à une instance de la classe.

Bien qu’un champ ne puisse pas être déclaré en tant que static const, un champ const est essentiellement statique dans son comportement. Il appartient au type, et non aux instances du type. Par conséquent, const champs sont accessibles à l’aide de la même notation ClassName.MemberName utilisée pour les champs statiques. Aucune instance d’objet n’est requise.

C# ne prend pas en charge les variables locales statiques (autrement dit, les variables déclarées dans l’étendue de la méthode).

Vous déclarez des membres de classe statique à l’aide du mot clé static avant le type de retour du membre, comme indiqué dans l’exemple suivant :

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...
}

Les membres statiques sont initialisés avant que le membre statique soit accessible pour la première fois et avant le constructeur statique, s’il en existe un, est appelé. Pour accéder à un membre de classe statique, utilisez le nom de la classe au lieu d’un nom de variable pour spécifier l’emplacement du membre, comme illustré dans l’exemple suivant :

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

Si votre classe contient des champs statiques, fournissez un constructeur statique qui les initialise lorsque la classe est chargée.

Un appel à une méthode statique génère une instruction d’appel dans le langage intermédiaire commun (CIL), tandis qu’un appel à une méthode d’instance génère une instruction callvirt, qui vérifie également les références d’objet Null. Toutefois, la plupart du temps, la différence de performances entre les deux n’est pas significative.

Spécification du langage C#

Pour plus d’informations, consultez classes statiques, membres statiques et membres d’instance et constructeurs statiques dans la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi