Statické třídy a jejich členové (Průvodce programováním v C#)

  • Článek

Statická třída je v podstatě stejná jako nestatická třída, ale existuje jeden rozdíl: statickou třídu nelze vytvořit instanci. Jinými slovy, nový operátor nemůžete použít k vytvoření proměnné typu třídy. Vzhledem k tomu, že neexistuje žádná proměnná instance, přistupujete k členům statické třídy pomocí samotného názvu třídy. Pokud máte například statickou třídu s názvem UtilityClass , která má veřejnou statickou metodu s názvem MethodA, zavoláte metodu, jak je znázorněno v následujícím příkladu:

UtilityClass.MethodA();

Statickou třídu lze použít jako pohodlný kontejner pro sady metod, které pouze pracují se vstupními parametry a nemusí získat ani nastavovat žádná interní pole instance. Například v knihovně tříd .NET obsahuje statická System.Math třída metody, které provádějí matematické operace bez nutnosti ukládat nebo načítat data, která jsou jedinečná pro konkrétní instanci Math třídy. To znamená, že použijete členy třídy zadáním názvu třídy a názvu metody, jak je znázorněno v následujícím příkladu.

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

Stejně jako u všech typů tříd modul runtime .NET načte informace o typu pro statickou třídu při načtení programu, který odkazuje na třídu. Program nemůže přesně určit, kdy je třída načtena. Je však zaručeno načtení a inicializace polí a jeho statický konstruktor volaný před prvním odkazem třídy ve vašem programu. Statický konstruktor se nazývá pouze jednou a statická třída zůstává v paměti po celou dobu životnosti domény aplikace, ve které se program nachází.

Poznámka:

Pokud chcete vytvořit nestatická třída, která umožňuje vytvoření pouze jedné instance samotné, přečtěte si téma Implementace Singletonu v jazyce C#.

Následující seznam obsahuje hlavní funkce statické třídy:

  • Obsahuje pouze statické členy.

  • Nelze vytvořit instanci.

  • Je zapečetěný.

  • Nelze obsahovat konstruktory instance.

Vytvoření statické třídy je tedy v podstatě stejné jako vytvoření třídy, která obsahuje pouze statické členy a privátní konstruktor. Privátní konstruktor zabraňuje vytvoření instance třídy. Výhodou použití statické třídy je, že kompilátor může zkontrolovat, zda nejsou náhodně přidány žádné členy instance. Kompilátor zaručuje, že instance této třídy nelze vytvořit.

Statické třídy jsou zapečetěné, a proto je nelze zdědit. Nemůžou dědit z žádné třídy nebo rozhraní s výjimkou Object. Statické třídy nemohou obsahovat konstruktor instance. Mohou však obsahovat statický konstruktor. Nestatické třídy by také měly definovat statický konstruktor, pokud třída obsahuje statické členy, které vyžadují ne triviální inicializaci. Další informace naleznete v tématu Statické konstruktory.

Příklad

Tady je příklad statické třídy, která obsahuje dvě metody, které převádějí teplotu ze stupně Celsia na Fahrenheita a Fahrenheita na stupně Celsia:

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

Statické členy

Nestatická třída může obsahovat statické metody, pole, vlastnosti nebo události. Statický člen je volán pro třídu, i když neexistuje žádná instance třídy. Statický člen je vždy přístupný názvem třídy, nikoli názvem instance. Existuje pouze jedna kopie statického členu bez ohledu na to, kolik instancí třídy je vytvořeno. Statické metody a vlastnosti nemají přístup k nestatickému poli a událostem v jejich typu, a nemohou získat přístup k proměnné instance jakéhokoli objektu, pokud není explicitně předán v parametru metody.

Je obvyklejší deklarovat nestatické třídy s některými statickými členy, než deklarovat celou třídu jako statickou. Dvě běžná použití statických polí slouží k zachování počtu objektů, které se vytvářejí instance, nebo k uložení hodnoty, která se musí sdílet mezi všemi instancemi.

Statické metody mohou být přetíženy, ale ne přepsány, protože patří do třídy, a ne do žádné instance třídy.

I když pole nelze deklarovat jako static const, pole const je v podstatě statické ve svém chování. Patří k typu, nikoli k instancím typu. const K polím je proto možné přistupovat pomocí stejného ClassName.MemberName zápisu, který se používá pro statická pole. Není vyžadována žádná instance objektu.

Jazyk C# nepodporuje statické místní proměnné (to znamená proměnné deklarované v oboru metody).

Statické členy třídy deklarujete pomocí klíčového static slova před návratovým typem členu, jak je znázorněno v následujícím příkladu:

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...
}

Statické členy jsou inicializovány před prvním přístupem ke statickému členu a před statickým konstruktorem, pokud existuje, je volána. Pokud chcete získat přístup ke statickému členu třídy, použijte místo názvu proměnné název člena, jak je znázorněno v následujícím příkladu:

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

Pokud vaše třída obsahuje statická pole, zadejte statický konstruktor, který je inicializuje při načtení třídy.

Volání statické metody generuje instrukce volání v běžném přechodném jazyce (CIL), zatímco volání metody instance generuje callvirt instrukce, která také kontroluje odkazy na objekt null. Ve většině případů ale rozdíl mezi výkonem mezi těmito dvěma není významný.

Specifikace jazyka C#

Další informace naleznete v tématu Statické třídy, Statické a instance členy a Statické konstruktory ve specifikaci jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.

Viz také