Megosztás:

statikus (C# referencia)

Ez a cikk a static módosító kulcsszót ismerteti. A static kulcsszó is része az using static irányelvnek.

static A módosító használatával deklarálhat egy statikus tagot, amely nem egy adott objektumhoz, hanem magához a típushoz tartozik. Osztályokat deklarálhat static a static módosítóval. Osztályokban, felületekben és szerkezetekben a módosító mezőkhöz, metódusokhoz, tulajdonságokhoz, operátorokhoz, eseményekhez és konstruktorokhoz is hozzáadható static . A módosítót nem használhatja static indexelőkkel vagy véglegesítőkkel. További információ: Statikus osztályok és statikus osztálytagok.

Hozzáadhatja a static módosítót egy helyi függvényhez. A statikus helyi függvények nem tudnak helyi változókat vagy példányállapotokat rögzíteni.

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

A módosító hozzáadható static egy lambda kifejezéshez vagy egy névtelen metódushoz. A statikus lambda vagy névtelen metódus nem tudja rögzíteni a helyi változókat vagy a példány állapotát.

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

A következő osztály deklarálva van, static és csak static metódusokat tartalmaz:

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

Az állandó vagy típusdeklaráció implicit módon egy static tagja. Nem hivatkozhat tagra static egy példányon keresztül. Ehelyett hivatkozzon rá a típusnéven keresztül. Vegyük például a következő osztályt:

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

A static tagra való hivatkozáshoz használja a teljes x nevet, kivéve, ha a MyBaseC.MyStruct.x tag ugyanabból a hatókörből érhető el:

Console.WriteLine(MyBaseC.MyStruct.x);

Bár az osztály egy példánya az osztály összes példánymezőjének külön másolatát tartalmazza, az egyes static mezőkből csak egy példány van. Általános típusok esetén minden zárt generikus típusnak saját másolata van a statikus mezőkről. A ThreadStaticAttribute jelzett statikus mezők szálanként egy példánnyal rendelkeznek.

Metódusokra vagy tulajdonságkiegészítőkre static nem hivatkozhatthis.

Ha egy osztályra alkalmazza a static kulcsszót, az osztály minden tagjának meg kell lennie static.

Az osztályok, felületek és static osztályok konstruktorokkal is rendelkezhetnek static . A static konstruktor meghívása valamikor megtörténik a program indítása és az osztály példányosítása között.

Megjegyzés:

A static kulcsszónak korlátozottabb felhasználási módja van, mint a C++-ban. A C++ kulcsszóval való összehasonlításhoz tekintse meg a Tárolási osztályok (C++) című témakört.

Egy osztály tagjainak bemutatására vegyen fontolóra egy vállalati alkalmazottat képviselő osztályt. Tegyük fel, hogy az osztály tartalmaz egy metódust az alkalmazottak megszámlálására, valamint egy mezőt az alkalmazottak számának tárolására. A metódus és a mező nem tartozik egyetlen alkalmazotti példányhoz sem. Ehelyett az alkalmazottak egész osztályához tartoznak. Az osztály tagjaiként kell static deklarálni ezeket.

Ez a példa beolvassa egy új alkalmazott nevét és azonosítóját, egyenként növeli az alkalmazott számlálóját, és megjeleníti az új alkalmazott adatait és az új alkalmazottak számát. Ez a program beolvassa az alkalmazottak aktuális számát a billentyűzetről.

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

Ez a példa azt mutatja, hogy egy mezőt inicializálhat egy static másik static , még nem deklarált mező használatával. Az eredmények nem lesznek meghatározva, amíg explicit módon nem rendel hozzá értéket a static mezőhöz.

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# nyelvspecifikáció

További információkért lásd a C# nyelvi specifikációját. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

Lásd még

  • Last updated on