Classes statiques et membres de classe statique (Guide de programmation C#)Static Classes and Static Class Members (C# Programming Guide)

Une classe statique est fondamentalement identique à une classe non statique, à une différence près : une classe statique ne peut pas être instanciée.A static class is basically the same as a non-static class, but there is one difference: a static class cannot be instantiated. En d’autres termes, vous ne pouvez pas utiliser le mot clé new pour créer une variable du type classe.In other words, you cannot use the new keyword to create a variable of the class type. Étant donné qu’il n’y a aucune variable d’instance, vous accédez aux membres d’une classe statique en utilisant le nom de classe lui-même.Because there is no instance variable, you access the members of a static class by using the class name itself. 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 illustré dans l’exemple suivant :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();  

Une classe statique peut servir de conteneur pratique pour des ensembles de méthodes qui opèrent simplement sur des paramètres d’entrée et n’ont pas à obtenir ou définir de champs d’instance internes.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. Par exemple, dans la bibliothèque de classes .NET Framework, la classe System.Math statique 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 spécifiques à une instance particulière de la 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. 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.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  

Comme c’est le cas avec tous les types de classes, les informations de type pour une classe statique sont chargées par le Common Language Runtime (CLR) .NET Framework quand le programme qui fait référence à la classe est chargé.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. Le programme ne peut pas spécifier exactement quand la classe est chargée.The program cannot specify exactly when the class is loaded. Toutefois, il est garanti qu’elle sera chargée, que ses champs seront initialisés et que son constructeur statique sera appelé avant que la classe soit référencée pour la première fois dans votre programme.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 constructeur statique est appelé une seule fois et une classe statique reste en mémoire pendant la durée de vie du domaine d’application dans lequel votre programme réside.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.

Notes

Pour créer une classe non statique permettant la création d’une seule instance d’elle-même, consultez Implémentation d’un singleton en C#.To create a non-static class that allows only one instance of itself to be created, see Implementing Singleton in C#.

La liste suivante fournit les fonctionnalités principales d’une classe statique :The following list provides the main features of a static class:

  • Elle contient uniquement des membres statiques.Contains only static members.

  • Elle ne peut pas être instanciée.Cannot be instantiated.

  • Elle est verrouillée (sealed).Is sealed.

  • Elle ne peut pas contenir de constructeurs d’instances.Cannot contain Instance Constructors.

La création d’une classe statique est par conséquent très semblable à la création d’une classe contenant uniquement des membres statiques et un constructeur privé.Creating a static class is therefore basically the same as creating a class that contains only static members and a private constructor. Un constructeur privé empêche la classe d’être instanciée.A private constructor prevents the class from being instantiated. L’avantage de l’utilisation d’une classe statique est que le compilateur peut vérifier qu’aucun membre d’instance n’a été ajouté par erreur.The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. Le compilateur garantit que les instances de cette classe ne peuvent pas être créées.The compiler will guarantee that instances of this class cannot be created.

Les classes statiques sont scellées (sealed) et ne peuvent par conséquent pas être héritées.Static classes are sealed and therefore cannot be inherited. Elles ne peuvent hériter d’aucune classe à part Object.They cannot inherit from any class except Object. Les classes statiques ne peuvent pas contenir un constructeur d’instance. Toutefois, elles peuvent contenir un constructeur statique.Static classes cannot contain an instance constructor; however, they can contain a static constructor. Les classes non statiques doivent également définir un constructeur statique si la classe contient des membres statiques qui requièrent une initialisation non triviale.Non-static classes should also define a static constructor if the class contains static members that require non-trivial initialization. Pour plus d’informations, consultez Constructeurs statiques.For more information, see Static Constructors.

ExempleExample

Voici un exemple d’une classe statique qui contient deux méthodes qui convertissent la température des degrés Celsius en degrés Fahrenheit et des degrés Fahrenheit en degrés Celsius :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.
 */

Membres staticStatic Members

Une classe non statique peut contenir des méthodes, des champs, des propriétés ou des événements statiques.A non-static class can contain static methods, fields, properties, or events. Le membre statique peut être appelé sur une classe même quand aucune instance de la classe n’a été créée.The static member is callable on a class even when no instance of the class has been created. Le membre statique est toujours accessible par le nom de la classe, et non par le nom de l’instance.The static member is always accessed by the class name, not the instance name. Une seule copie d’un membre statique existe, quel que soit le nombre d’instances de la classe qui ont été créées.Only one copy of a static member exists, regardless of how many instances of the class are created. Les méthodes et propriétés statiques ne peuvent pas accéder à des champs ou des événements non statiques dans leur type contenant. Elles ne peuvent pas non plus accéder à une variable d’instance d’un objet quelconque à moins qu’elle soit passée explicitement dans un paramètre de méthode.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.

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.It is more typical to declare a non-static class with some static members, than to declare an entire class as static. Deux utilisations courantes des champs statiques consistent à conserver un décompte du nombre d’objets qui ont été instanciés ou à stocker une valeur qui doit être partagée entre toutes les instances.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.

Les méthodes statiques peuvent être surchargées mais pas substituées, car elles appartiennent à la classe et non pas à une instance de la classe.Static methods can be overloaded but not overridden, because they belong to the class, and not to any instance of the class.

Bien qu’un champ ne puisse pas être déclaré en tant que static const, un champ const est essentiellement statique dans son comportement.Although a field cannot be declared as static const, a const field is essentially static in its behavior. Il appartient au type, pas aux instances du type.It belongs to the type, not to instances of the type. Par conséquent, les champs const sont accessibles à l’aide de la même notation ClassName.MemberName utilisée pour les champs statiques.Therefore, const fields can be accessed by using the same ClassName.MemberName notation that is used for static fields. Aucune instance d’objet n’est requise.No object instance is required.

C# ne prend pas en charge les variables locales statiques (variables déclarées dans la portée de la méthode).C# does not support static local variables (variables that are declared in method scope).

Vous déclarez des membres de classe statique en utilisant le mot clé static avant le type de retour du membre, comme illustré dans l’exemple suivant :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...
}

Les membres statiques sont initialisés avant le premier accès au membre statique et avant que le constructeur statique, s’il en existe un, soit appelé.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. 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 :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;

Si votre classe contient des champs statiques, fournissez un constructeur statique qui les initialise quand la classe est chargée.If your class contains static fields, provide a static constructor that initializes them when the class is loaded.

Un appel à une méthode statique génère une instruction d’appel en langage MSIL (Microsoft Intermediate Language), alors qu’un appel à une méthode d’instance génère une instruction callvirt, qui vérifie également l’existence de références d’objet 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. Toutefois, la plupart du temps, l’écart de performances entre les deux n’est pas significatif.However, most of the time the performance difference between the two is not significant.

Spécification du langage C#C# Language Specification

Pour plus d’informations, voir Classes statiques et Membres statiques et d’instances dans la spécification du langage C#.For more information, see Static classes and Static and instance members in the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also