Freigeben über

static (C#-Referenz)

Diese Seite behandelt das static Modifizierer-Schlüsselwort. Das static Schlüsselwort ist auch Teil der using static Direktive.

Verwenden Sie den static Modifizierer, um ein statisches Element zu deklarieren, das zum Typ selbst gehört, anstatt zu einem bestimmten Objekt. Der static Modifizierer kann zum Deklarieren von static Klassen verwendet werden. In Klassen, Schnittstellen und Strukturen können Sie den static Modifizierer zu Feldern, Methoden, Eigenschaften, Operatoren, Ereignissen und Konstruktoren hinzufügen. Der static Modifizierer kann nicht mit Indexern oder Finalizern verwendet werden. Weitere Informationen finden Sie unter "Static Classes" und "Static Class Members".

Sie können den static Modifizierer einer lokalen Funktion hinzufügen. Eine statische lokale Funktion kann keine lokalen Variablen oder den Instanzstatus erfassen.

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
 */

Sie können den static Modifizierer einem Lambda-Ausdruck oder einer anonymen Methode hinzufügen. Eine statische Lambda- oder anonyme Methode kann keine lokalen Variablen oder Den Instanzstatus erfassen.

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
*/

Beispiel : statische Klasse

Diese Klasse wird als static deklariert und enthält nur static Methoden.

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

Eine Konstante oder Typdeklaration ist implizit ein static Element. Auf ein static Element kann nicht über eine Instanz verwiesen werden. Stattdessen wird er über den Typnamen verwiesen. Betrachten Sie beispielsweise die folgende Klasse:

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

Verwenden Sie zum Verweisen auf einen static-Member x den vollqualifizierten Namen MyBaseC.MyStruct.x, außer es kann auf den Member vom selben Geltungsbereich zugegriffen werden:

Console.WriteLine(MyBaseC.MyStruct.x);

Während eine Instanz einer Klasse eine separate Kopie aller Instanzfelder der Klasse enthält, gibt es nur eine Kopie jedes static Felds. Bei generischen Typen verfügt jeder geschlossene generische Typ über eine eigene Kopie statischer Felder. Statische Felder, die mit ThreadStaticAttribute gekennzeichnet sind, haben jeweils eine Kopie pro Thread.

Es ist nicht möglich, this zu verwenden, um Methoden oder Eigenschaftszugriffe in static zu referenzieren.

Wenn das static Schlüsselwort auf eine Klasse angewendet wird, müssen alle Member der Klasse sein static.

Klassen, Schnittstellen und static Klassen verfügen möglicherweise über static Konstruktoren. Ein static Konstruktor wird irgendwann zwischen dem Start des Programms und der Instanziierung der Klasse aufgerufen.

Hinweis

Das static Schlüsselwort hat eine eingeschränkte Verwendung als in C++. Informationen zum Vergleichen mit dem C++-Schlüsselwort finden Sie unter Speicherklassen (C++).

Um Mitglieder zu veranschaulichen static , ziehen Sie eine Klasse in Betracht, die einen Unternehmensmitarbeiter darstellt. Angenommen, die Klasse enthält eine Methode zum Zählen von Mitarbeitern und einem Feld zum Speichern der Anzahl der Mitarbeiter. Sowohl die Methode als auch das Feld gehören keiner Mitarbeiterinstanz. Stattdessen gehören sie zur Klasse der Mitarbeiter insgesamt. Sie sollten als static Mitglieder der Klasse deklariert werden.

Beispiel : statisches Feld und Methode

In diesem Beispiel wird der Name und die ID eines neuen Mitarbeiters gelesen, der Mitarbeiterzähler um eins erhöht und die Informationen für den neuen Mitarbeiter und die neue Anzahl von Mitarbeitern angezeigt. Dieses Programm liest die aktuelle Anzahl der Mitarbeiter über die Tastatur.

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
*/

Beispiel : statische Initialisierung

In diesem Beispiel wird gezeigt, dass Sie ein Feld mithilfe eines static anderen static Felds initialisieren können, das noch nicht deklariert ist. Die Ergebnisse werden nicht definiert, bis Sie dem static Feld explizit einen Wert zuweisen.

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
*/

C#-Sprachspezifikation

Weitere Informationen finden Sie in der C#-Sprachspezifikation. Die Sprachspezifikation ist die endgültige Quelle für C#-Syntax und -Verwendung.

Siehe auch