Megosztás a következőn keresztül:

Statikus osztályok és statikus osztálytagok (C# programozási útmutató)

  • Cikk

A statikus osztály alapvetően megegyezik a nem statikus osztályéval, de van egy különbség: a statikus osztály nem hozható létre. Más szóval az új operátorral nem hozhat létre osztálytípusú változót. Mivel nincs példányváltozó, a statikus osztály tagjait magát az osztálynevet használva érheti el. Ha például van egy statikus osztálya, amelynek neve UtilityClass nyilvános statikus metódus MethodA, akkor a metódust az alábbi példában látható módon hívhatja meg:

UtilityClass.MethodA();

A statikus osztály kényelmes tárolóként használható olyan metóduskészletekhez, amelyek csak bemeneti paramétereken működnek, és nem kell belső példánymezőket lekérni vagy beállítani. A .NET-osztálytárban például a statikus System.Math osztály olyan metódusokat tartalmaz, amelyek matematikai műveleteket hajtanak végre anélkül, hogy az osztály egy adott példányára Math egyedi adatokat kell tárolni vagy lekérni. Vagyis az osztály tagjait az osztálynév és a metódus nevének megadásával alkalmazza, ahogyan az az alábbi példában is látható.

double dub = -3.14;
Console.WriteLine(Math.Abs(dub));
Console.WriteLine(Math.Floor(dub));
Console.WriteLine(Math.Round(Math.Abs(dub)));

// Output:
// 3.14
// -4
// 3

Ahogy az összes osztálytípus esetében, a .NET-futtatókörnyezet betölti egy statikus osztály típusadatait, amikor az osztályra hivatkozó program betöltődik. A program nem tudja pontosan megadni, hogy mikor töltődik be az osztály. Azonban garantáltan betöltődik, és inicializálja a mezőket, és meghívja a statikus konstruktort, mielőtt a program első alkalommal hivatkozik az osztályra. A statikus konstruktorokat csak egyszer nevezik, és a statikus osztály a memóriában marad annak az alkalmazástartománynak az élettartama alatt, amelyben a program található.

Feljegyzés

Ha olyan nem statikus osztályt szeretne létrehozni, amely csak egy példány létrehozását teszi lehetővé, olvassa el a Singleton implementálását a C#-ban című témakörben.

Az alábbi lista a statikus osztály fő funkcióit tartalmazza:

  • Csak statikus tagokat tartalmaz.

  • Nem lehet példányt létrehozni.

  • Le van zárva.

  • Nem tartalmazhat példánykonstruktorokat.

A statikus osztály létrehozása tehát alapvetően ugyanaz, mint egy olyan osztály létrehozása, amely csak statikus tagokat és privát konstruktorokat tartalmaz. A privát konstruktor megakadályozza az osztály példányosítását. A statikus osztály használatának előnye, hogy a fordító ellenőrizheti, hogy véletlenül nem lettek-e példánytagok hozzáadva. A fordító garantálja, hogy az osztály példányai nem hozhatók létre.

A statikus osztályok lezárva vannak, ezért nem örökölhetők. Csak osztályból vagy felületről Objectörökölhetnek. A statikus osztályok nem tartalmazhatnak példánykonstruktort. Azonban statikus konstruktort is tartalmazhatnak. A nem statikus osztályok statikus konstruktort is definiálnak, ha az osztály olyan statikus tagokat tartalmaz, amelyek nem triviális inicializálást igényelnek. További információ: Statikus konstruktorok.

Példa

Íme egy példa egy statikus osztályra, amely két metódust tartalmaz, amelyek a hőmérsékletet Celsiusról Fahrenheitre, a Fahrenheitből pedig Celsius-fokra konvertálják:

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius)
    {
        // Convert argument to double for calculations.
        double celsius = Double.Parse(temperatureCelsius);

        // Convert Celsius to Fahrenheit.
        double fahrenheit = (celsius * 9 / 5) + 32;

        return fahrenheit;
    }

    public static double FahrenheitToCelsius(string temperatureFahrenheit)
    {
        // Convert argument to double for calculations.
        double fahrenheit = Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;
    }
}

class TestTemperatureConverter
{
    static void Main()
    {
        Console.WriteLine("Please select the convertor direction");
        Console.WriteLine("1. From Celsius to Fahrenheit.");
        Console.WriteLine("2. From Fahrenheit to Celsius.");
        Console.Write(":");

        string? selection = Console.ReadLine();
        double F, C = 0;

        switch (selection)
        {
            case "1":
                Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine() ?? "0");
                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine() ?? "0");
                Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                break;

            default:
                Console.WriteLine("Please select a convertor.");
                break;
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Example Output:
    Please select the convertor direction
    1. From Celsius to Fahrenheit.
    2. From Fahrenheit to Celsius.
    :2
    Please enter the Fahrenheit temperature: 20
    Temperature in Celsius: -6.67
    Press any key to exit.
 */

Statikus tagok

A nem statikus osztály tartalmazhat statikus metódusokat, mezőket, tulajdonságokat vagy eseményeket. A statikus tag akkor is meghívható egy osztályon, ha az osztálynak nincs példánya. A statikus tagot mindig az osztály neve, nem pedig a példány neve éri el. A statikus tagnak csak egy példánya létezik, függetlenül attól, hogy az osztály hány példánya jön létre. A statikus metódusok és tulajdonságok nem férnek hozzá a nem statikus mezőkhöz és eseményekhez a bennük található típusban, és nem férhetnek hozzá egyetlen objektum példányváltozóihoz sem, kivéve, ha a metódusparaméter explicit módon adja át.

Jellemzőbb, ha nem statikus osztályt deklarál néhány statikus taggal, mint egy teljes osztályt statikusként deklarálni. A statikus mezők két gyakori használata a példányosított objektumok számának megtartása, vagy egy olyan érték tárolása, amelyet meg kell osztani az összes példány között.

A statikus metódusok túlterhelhetők, de nem felülbíráltak, mert az osztályhoz tartoznak, és nem az osztály egyik példányához sem.

Bár egy mező nem deklarálható, static consta const mező működése alapvetően statikus. A típushoz tartozik, nem a típuspéldányokhoz. Ezért a const mezők a ClassName.MemberName statikus mezőkhöz használt jelöléssel érhetők el. Nincs szükség objektumpéldányra.

A C# nem támogatja a statikus helyi változókat (vagyis a metódus hatókörében deklarált változókat).

A statikus osztálytagokat a static tag visszatérési típusa előtti kulcsszóval deklarálhatja, ahogyan az alábbi példában látható:

public class Automobile
{
    public static int NumberOfWheels = 4;

    public static int SizeOfGasTank
    {
        get
        {
            return 15;
        }
    }

    public static void Drive() { }

    public static event EventType? RunOutOfGas;

    // Other non-static fields and properties...
}

A statikus tagok inicializálása a statikus tag első elérése előtt történik, és a statikus konstruktor előtt , ha van ilyen, a rendszer meghívja. Statikus osztálytag eléréséhez használja az osztály nevét változónév helyett a tag helyének megadásához, ahogyan az az alábbi példában látható:

Automobile.Drive();
int i = Automobile.NumberOfWheels;

Ha az osztály statikus mezőket tartalmaz, adjon meg egy statikus konstruktort, amely inicializálja őket az osztály betöltésekor.

A statikus metódus hívása egy hívásutasítást generál a közös köztes nyelven (CIL), míg egy példánymetódus hívása létrehoz egy utasítást callvirt , amely null objektumhivatkozásokat is keres. A legtöbb esetben azonban a kettő közötti teljesítménykülönbség nem jelentős.

C# nyelvi specifikáció

További információ: Statikus osztályok, statikus és példánytagok és statikus konstruktorok a C# nyelvi specifikációjában. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

Lásd még