Partager via

static (référence C#)

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

Utilisez le static modificateur 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.

class Calc1
{
    public void CalculateSum()
    {
        int a = 3;
        int b = 7;

        // Static local function - cannot access 'a' or 'b' directly
        static int Add(int x, int y)
        {
            return x + y;
        }

        int result = Add(a, b); 
        Console.WriteLine($"Sum: {result}");
    }
}
  /*
 Output:
 Sum: 10
 */

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 de l’instance.

class Calc2
{
    static void Main()
    {
        Func<int, int, int> add = static (a, b) => a + b;

        int result = add(5, 10);
        Console.WriteLine($"Sum: {result}");
    }
}
/*
Output:
Sum: 15
*/

Exemple : classe statique

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

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

Une constante ou une déclaration 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 nom du type. Par exemple, considérez 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 n’y a qu’une seule copie de chaque static champ. Pour les types génériques, chaque type générique fermé a sa propre copie de champs statiques. Les champs statiques marqués avec ThreadStaticAttribute ont une copie par thread.

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 classes static peuvent avoir des constructeurs static. Un static constructeur est appelé à un moment donné entre le démarrage du programme et lorsque la classe est instanciée.

Remarque

Le static mot clé a des utilisations plus limitées que dans C++. Pour la comparaison avec le mot clé C++, voir les classes de stockage (C++).

Pour illustrer static les 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é en particulier. Au lieu de cela, 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 le compteur de l’employé par un et affiche les informations relatives au nouvel employé et au 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