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

Článek
06/10/2015

A statické třídy je v podstatě stejný jako nestatický třídy, ale existuje jeden rozdíl: statické třídy nelze vytvořit instanci.Jinými slovy, nemůžete použít nové klíčové slovo vytvořit proměnné typu třídy.Protože žádné proměnné instance přístupu členy statické třídy pomocí samotný název třídy.Například pokud máte statické třídy, s názvem UtilityClass , nemá veřejnou metodu s názvem MethodA, volat metodu, jak ukazuje následující příklad:

UtilityClass.MethodA();

Statické třídy lze použít jako vhodný kontejner pro sady metod, které právě pracují vstupní parametry a nemusíte získat nebo nastavit pole instance interní.Například v.NET Framework, knihovna tříd, statickými Math třída obsahuje metody, které provádějí matematické operace, bez jakéhokoli požadavku pro uložení nebo načtení dat, který je jedinečný pro konkrétní instanci Math třídy.Můžete použít členové třídy zadáním názvu třídy a názvu metody, jak ukazuje následující příklad.

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 v případě všech typů třídy, informace o statické třídy typu zavedená .NET Framework společného jazykového modulu runtime (CLR), když je načten program, který odkazuje třídu. Program nelze zadat přesně při načtení třídy.Je však zaručeno načtení a její pole inicializována a jeho statický konstruktor volána před třídy odkazované poprvé v programu.Statický konstruktor se nazývá pouze jednou a statické třídy zůstává v paměti dobu existence domény aplikace, ve které je umístěn program.

[!POZNÁMKA]

Vytvoření umožňující samotné vytvořena pouze jedna instance třídy nestatický naleznete v tématu Provádění Singleton v jazyce C#.

Následující seznam poskytuje hlavní funkce Statická třída:

Obsahuje pouze statické členy.
Nelze vytvořit instanci.
Je uzavřena.
Nemůže obsahovat Konstruktory instancí.

Vytvoření statické třídy je tedy v podstatě stejný jako při vytvář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 zkontrolujte omylem přidány žádné instance členy.Kompilátor zaručit, že instance této třídy nelze vytvořit.

Statické třídy jsou uzavřeny a proto nelze dědit.Nelze zdědit všechny třídy kromě Object.Statické třídy nemohou obsahovat konstruktoru instance; může však obsahovat statický konstruktor.Nestatický třídy definují statický konstruktor, pokud třída obsahuje statické členy, které vyžadují-trivial inicializace.Další informace naleznete v tématu Statické konstruktory (Průvodce programováním v C#).

Příklad

Zde je příklad statické třídy, která obsahuje dvě metody, které z Celsia na Fahrenheita a k Celsia Fahrenheita převést teploty:

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());
                    Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                    break;

                case "2":
                    Console.Write("Please enter the Fahrenheit temperature: ");
                    C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());
                    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řídy mohou obsahovat statické metody, polí, vlastnosti a události.Statický člen je callable na třídu, i když byla vytvořena žádná instance třídy.Statický člen je vždy přistupovat pomocí názvu třídy, název instance.Pouze jednu kopii statický člen existuje bez ohledu na to, kolik instancí třídy jsou vytvořeny.Statické metody a vlastnosti nelze získat přístup k nestatickému polí a události v jejich typ a nelze pokud výslovně předaný parametru metody přístupu k proměnné instance objektu.

Je obvykle více deklarovat třídu nestatický některé statické členy než prohlásit celou třídu jako statické.Dva obvyklé využití statické pole jsou zachovat celkový počet objektů, které byly vytvořeny nebo uložit hodnotu, musí být sdíleny všechny instance.

Statické metody lze přetížený, ale nelze přepsat, protože patří do třídy a ne na všechny instance třídy.

Přestože pole nelze deklarovat jako static const, const pole je v podstatě statický v jeho chování.Patří k typu není do instancí typu.Proto je const pole přístupná pomocí stejné ClassName.MemberName zápis pro statické pole.Je vyžadována žádná instance objektu.

C# nepodporuje statické místní proměnné (proměnné, které jsou deklarovány v oboru metoda).

Deklarovat členy statických tříd pomocí static klíčové slovo před návratový typ člena, jak ukazuje následující příklad:

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 statický člen se před přístupem k první a před statický konstruktor, pokud existuje, se nazývá.Chcete-li člen statické třídy, pomocí název třídy namísto názvu proměnné určit umístění tohoto člena, jak ukazuje následující příklad:

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

Pokud vaše třída obsahuje statické pole, poskytují statický konstruktor, který inicializuje jim při načtení třídy.

Volání, statické metody generuje volání instrukce v Microsoft zprostředkující jazyk (MSIL) vzhledem k tomu, že při volání metody instance generuje callvirt pokyn také kontroluje odkazuje na objekt null.Však ve většině případů výkonu rozdíl mezi nimi není důležité.