static (référence C#)

Cette page couvre le static mot clé modificateur. Le static mot clé fait également partie de la using static directive.

Utilisez le modificateur static pour déclarer un membre statique, qui appartient au type lui-même plutôt qu’à un objet spécifique. Le static modificateur peut être utilisé pour déclarer static des classes. Dans les classes, interfaces et structs, vous pouvez ajouter le static modificateur aux champs, méthodes, propriétés, opérateurs, événements et constructeurs. Le static modificateur ne peut pas être utilisé avec des indexeurs ou des finaliseurs. Pour plus d’informations, consultez la page Classes statiques et membres de classes statiques.

Vous pouvez ajouter le static modificateur à une fonction locale. Une fonction locale statique ne peut pas capturer les variables locales ou l’état de l’instance.

À compter de C# 9.0, vous pouvez ajouter le static modificateur à une expression lambda ou à une méthode anonyme. Une méthode lambda statique ou anonyme ne peut pas capturer les variables locales ou l’état d’instance.

Exemple : classe statique

La classe suivante est déclarée comme static et contient uniquement des méthodes static :

static class CompanyEmployee
{
    public static void DoSomething() { /*...*/ }
    public static void DoSomethingElse() { /*...*/  }
}

Une déclaration de constante ou de type est implicitement un static membre. Un static membre ne peut pas être référencé par le biais d’une instance. Au lieu de cela, il est référencé par le biais du nom de type. Par exemple, considérons la classe suivante :

public class MyBaseC
{
    public struct MyStruct
    {
        public static int x = 100;
    }
}

Pour faire référence au static membre x, utilisez le nom complet, MyBaseC.MyStruct.xsauf si le membre est accessible à partir de la même étendue :

Console.WriteLine(MyBaseC.MyStruct.x);

Bien qu’une instance d’une classe contient une copie distincte de tous les champs d’instance de la classe, il n’y a qu’une seule copie de chaque static champ.

Il n’est pas possible d’utiliser this pour référencer static des méthodes ou des accesseurs de propriétés.

Si le static mot clé est appliqué à une classe, tous les membres de la classe doivent être static.

Les classes, interfaces et static classes peuvent avoir static des constructeurs. Un static constructeur est appelé à un moment donné entre le démarrage du programme et la classe est instanciée.

Notes

L’utilisation du mot clé static est plus restreinte que dans C++. Pour comparer avec le mot clé C++, consultez Classes de stockage (C++).

Pour illustrer les static membres, considérez une classe qui représente un employé de l’entreprise. Supposons que la classe contient une méthode pour compter les employés et un champ pour stocker le nombre d’employés. La méthode et le champ n’appartiennent à aucune instance d’employé. Au lieu de cela, ils appartiennent à la classe des employés dans leur ensemble. Ils doivent être déclarés en tant que static membres de la classe.

Exemple : champ statique et méthode

Cet exemple lit le nom et l’ID d’un nouvel employé, incrémente d’une unité le compteur d’employés et affiche les informations concernant le nouvel employé et le nouveau nombre d’employés. Ce programme lit le nombre actuel d’employés du clavier.

public class Employee4
{
    public string id;
    public string name;

    public Employee4()
    {
    }

    public Employee4(string name, string id)
    {
        this.name = name;
        this.id = id;
    }

    public static int employeeCounter;

    public static int AddEmployee()
    {
        return ++employeeCounter;
    }
}

class MainClass : Employee4
{
    static void Main()
    {
        Console.Write("Enter the employee's name: ");
        string name = Console.ReadLine();
        Console.Write("Enter the employee's ID: ");
        string id = Console.ReadLine();

        // Create and configure the employee object.
        Employee4 e = new Employee4(name, id);
        Console.Write("Enter the current number of employees: ");
        string n = Console.ReadLine();
        Employee4.employeeCounter = Int32.Parse(n);
        Employee4.AddEmployee();

        // Display the new information.
        Console.WriteLine($"Name: {e.name}");
        Console.WriteLine($"ID:   {e.id}");
        Console.WriteLine($"New Number of Employees: {Employee4.employeeCounter}");
    }
}
/*
Input:
Matthias Berndt
AF643G
15
 *
Sample Output:
Enter the employee's name: Matthias Berndt
Enter the employee's ID: AF643G
Enter the current number of employees: 15
Name: Matthias Berndt
ID:   AF643G
New Number of Employees: 16
*/

Exemple : initialisation statique

Cet exemple montre que vous pouvez initialiser un static champ à l’aide d’un autre static champ qui n’est pas encore déclaré. Les résultats ne seront pas définis jusqu’à ce que vous affectiez explicitement une valeur au static champ.

class Test
{
    static int x = y;
    static int y = 5;

    static void Main()
    {
        Console.WriteLine(Test.x);
        Console.WriteLine(Test.y);

        Test.x = 99;
        Console.WriteLine(Test.x);
    }
}
/*
Output:
    0
    5
    99
*/

spécification du langage C#

Pour plus d'informations, voir 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