Delen via

statisch (C#-verwijzing)

Op deze pagina wordt het static wijzigingswoord beschreven. Het static trefwoord maakt ook deel uit van de using static richtlijn.

Gebruik de static wijzigingsfunctie om een statisch lid te declareren, dat deel uitmaakt van het type zelf in plaats van een specifiek object. De static modifier kan worden gebruikt om static klassen te declareren. In klassen, interfaces en structs kunt u de static modifier toevoegen aan velden, methoden, eigenschappen, operators, gebeurtenissen en constructors. De static wijzigingsfunctie kan niet worden gebruikt met indexeerfuncties of finalizers. Zie Statische klassen en statische klasseleden voor meer informatie.

U kunt de static wijzigingsfunctie toevoegen aan een lokale functie. Een statische lokale functie kan geen lokale variabelen of instantiestatus vastleggen.

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

U kunt de static wijzigingsfunctie toevoegen aan een lambda-expressie of anonieme methode. Een statische lambda- of anonieme methode kan geen lokale variabelen of instantiestatus vastleggen.

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

Voorbeeld- statische klasse

De volgende klasse wordt gedeclareerd als static en bevat alleen static methoden:

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

Een constante of typedeclaratie is impliciet een static lid. Een static lid kan niet worden verwezen via een exemplaar. In plaats daarvan wordt ernaar verwezen via de typenaam. Denk bijvoorbeeld aan de volgende klasse:

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

Als u naar het static lid xwilt verwijzen, gebruikt u de volledig gekwalificeerde naam, MyBaseC.MyStruct.xtenzij het lid toegankelijk is vanuit hetzelfde bereik:

Console.WriteLine(MyBaseC.MyStruct.x);

Hoewel een exemplaar van een klasse een afzonderlijke kopie bevat van alle exemplaarvelden van de klasse, is er slechts één exemplaar van elk static veld. Voor algemene typen heeft elk gesloten algemeen type een eigen kopie van statische velden. Statische velden die zijn gemarkeerd met ThreadStaticAttribute hebben één kopie per thread.

Het is niet mogelijk om this te gebruiken om naar static-methoden of eigenschapstoegangsmethoden te verwijzen.

Als het static trefwoord wordt toegepast op een klasse, moeten alle leden van de klasse zijn static.

Klassen, interfaces en static klassen kunnen constructors hebben static . Een static constructor wordt op een bepaald moment aangeroepen tussen het moment waarop het programma wordt gestart en de klasse wordt geïnstantieerd.

Opmerking

Het static trefwoord heeft beperktere toepassingen dan in C++. Zie Storage-klassen (C++) om te vergelijken met het trefwoord C++.

Om static leden te demonstreren, overweeg een klasse die een werknemer van een bedrijf vertegenwoordigt. Stel dat de klasse een methode bevat voor het tellen van werknemers en een veld voor het opslaan van het aantal werknemers. Zowel de methode als het veld behoren niet tot een enige werknemerinstantie. In plaats daarvan behoren ze tot de klasse werknemers als geheel. Ze moeten worden gedeclareerd als static leden van de klas.

Voorbeeld: statisch veld en methode

In dit voorbeeld worden de naam en id van een nieuwe werknemer gelezen, wordt de teller van de werknemer met één verhoogd en worden de gegevens voor de nieuwe werknemer en het nieuwe aantal werknemers weergegeven. Dit programma leest het huidige aantal werknemers van het toetsenbord.

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

Voorbeeld: statische initialisatie

In dit voorbeeld ziet u dat u een static veld kunt initialiseren met behulp van een ander static veld dat nog niet is gedeclareerd. De resultaten worden niet gedefinieerd totdat u expliciet een waarde aan het static veld toewijst.

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#-taalspecificatie

Zie de C#-taalspecificatievoor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Zie ook