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

  • Article

Les classes statiques et les membres de classe sont utilisés pour créer des données et des fonctions auxquelles il est possible d'accéder sans créer d'instance de la classe. Des membres de classes statiques peuvent être utilisés pour séparer les données et le comportement, qui est indépendant de toute identité de l'objet : les données et les fonctions ne changent pas, quoi qu'il arrive à l'objet. Les classes statiques peuvent être utilisées lorsqu'il n'y a pas de données ou de comportement dans la classe qui dépende de l'identité de l'objet.

Classes statiques

Une classe peut être déclarée comme static, ce qui indique qu'elle contient uniquement des membres statiques. Il n'est pas possible de créer des instances d'une classe statique à l'aide du mot clé new. Les classes statiques sont chargées automatiquement par le common language runtime (CLR) du .NET Framework lorsque le programme ou l'espace de noms qui contient la classe est chargé.

Utilisez une classe statique pour stocker des méthodes qui ne sont pas associées à un objet particulier. Par exemple, il est une spécification requise commune de créer un jeu des méthodes qui n'agissent pas sur les données d'instance et ne sont pas associées à un objet spécifique dans votre code. Vous pourriez utiliser une classe statique pour stocker ces méthodes.

Les fonctionnalités principales d'une classe statique sont :

La création d'une classe statique est par conséquent très semblable à la création d'une classe qui contient uniquement des membres statiques et un constructeur privé. Un constructeur privé empêche la classe d'être instanciée.

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. Le compilateur garantira que les instances de cette classe ne peuvent pas être créées.

Les classes statiques sont sealed et ne peuvent par conséquent pas être héritées. Les classes statiques ne peuvent pas contenir de constructeur, bien qu'il soit encore possible de déclarer un constructeur statique pour assigner des valeurs initiales ou configurer un état statique. Pour plus d'informations, consultez Constructeurs statiques (Guide de programmation C#).

Utilisation des classes statiques

Supposez que vous ayez une classe CompanyInfo qui contient les méthodes suivantes pour obtenir des informations sur le nom et l'adresse de la société.

class CompanyInfo
{
    public string GetCompanyName() { return "CompanyName"; }
    public string GetCompanyAddress() { return "CompanyAddress"; }
    //...
}

Ces méthodes n'ont pas besoin d'être attachées à une instance spécifique de la classe. Par conséquent, au lieu de créer des instances inutiles de cette classe, vous pouvez la déclarer comme une classe statique, comme suit :

static class CompanyInfo
{
    public static string GetCompanyName() { return "CompanyName"; }
    public static string GetCompanyAddress() { return "CompanyAddress"; }
    //...
}

Utilisez une classe statique comme une unité d'organisation pour les méthodes qui ne sont associées à aucun objet particulier. Par ailleurs, une classe statique peut simplifier et accélérer votre implémentation, car vous n'êtes pas obligé de créer un objet pour appeler ses méthodes. Il est utile d'organiser les méthodes à l'intérieur de la classe d'une manière significative, comme les méthodes de la classe Math dans l'espace de noms System.

Membres statiques

Une méthode, champ, propriété ou événement statique peut être appelé sur une classe même si aucune instance de l'a classe n'a été créée. Si des instances de la classe sont créées, elles ne peuvent pas être utilisées pour accéder au membre statique. Une seule copie des champs et des événements statiques existe, et les méthodes et propriétés statiques peuvent uniquement accéder aux champs et aux événements statiques. Les membres statiques sont souvent utilisés pour représenter des données ou des calculs qui ne changent pas en fonction de l'état d'un objet. Par exemple, une bibliothèque de calcul peut contenir des méthodes statiques pour calculer des sinus et des cosinus.

Les membres de classe statiques sont déclarés à l'aide du mot clé static avant le type de retour du membre, par exemple :

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 fasse l'objet d'un accès pour la première fois, et avant que le constructeur statique, le cas échéant, soit 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. Par exemple :

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

Exemple

Voici un exemple d'une classe statique qui contient deux méthodes qui convertissent la température de Celsius en Fahrenheit, et inversement :

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius)
    {
        // Convert argument to double for calculations.
        double celsius = System.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 = System.Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;
    }
}

class TestTemperatureConverter
{
    static void Main()
    {
        System.Console.WriteLine("Please select the convertor direction");
        System.Console.WriteLine("1. From Celsius to Fahrenheit.");
        System.Console.WriteLine("2. From Fahrenheit to Celsius.");
        System.Console.Write(":");

        string selection = System.Console.ReadLine();
        double F, C = 0;

        switch (selection)
        {
            case "1":
                System.Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(System.Console.ReadLine());
                System.Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;

            case "2":
                System.Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(System.Console.ReadLine());
                System.Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                break;

            default:
                System.Console.WriteLine("Please select a convertor.");
                break;
        }
    }
}

Entrée

2

98.6

Résultat de l'exemple :

Please select the convertor

1. From Celsius to Fahrenheit.

2. From Fahrenheit to Celsius.

:2

Please enter the Fahrenheit temperature: 98.6

Temperature in Celsius: 37.00

Autre résultat possible :

Please select the convertor

1. From Celsius to Fahrenheit.

2. From Fahrenheit to Celsius.

:1

Please enter the Celsius temperature: 37.00

Temperature in Fahrenheit: 98.60

Spécifications du langage C#

Pour plus d'informations, consultez les sections suivantes dans Spécifications du langage C#.

  • 25.2 Classes statiques

Voir aussi

Référence

class (Référence C#)
Constructeurs d'instances (Guide de programmation C#)

Concepts

Guide de programmation C#
Conception de classes statiques
Classes (Guide de programmation C#)