Partager via

static (référence C#)

  • Article

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

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 modificateur static peut être utilisé pour déclarer des classes static. Dans les classes, interfaces et structs, vous pouvez ajouter le modificateur static aux champs, méthodes, propriétés, opérateurs, événements et constructeurs. Le modificateur static 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 modificateur static à une fonction locale. Une fonction locale statique ne peut pas capturer les variables locales ou l’état de l’instance.

Vous pouvez ajouter le modificateur static à une expression lambda ou à une méthode anonyme. Une méthode lambda ou anonyme statique ne peut pas capturer les variables locales ou l’état de l’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 constante ou une déclaration de type est implicitement un membre static. Un membre static ne peut pas être référencé via une instance. Il sera référencé par le nom du 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 staticmembrex, utilisez le nom complet, MyBaseC.MyStruct.x, sauf si le membre est accessible à partir de la même étendue :

Console.WriteLine(MyBaseC.MyStruct.x);

Alors qu’une instance d’une classe contient une copie distincte de tous les champs d’instance de la classe, il existe une seule copie de chaque champ static.

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

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

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

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 membres static, 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é en particulier. Ils appartiennent à la classe des employés dans son ensemble. Ils doivent être déclarés en tant que membres static 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 à partir 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 champ static à l’aide d’un autre champ static qui n’est pas encore déclaré. Les résultats ne seront pas définis jusqu’à ce que vous affectiez explicitement une valeur au champ static.

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