static w C#: klasy, metody, pola i konstruktory statyczne

static oznacza składową, która należy do typu, a nie do obiektu. Pole instancji istnieje raz na obiekt; pole statyczne istnieje raz i kropka. Metoda instancyjna działa na obiekcie (order.Ship()); metoda statyczna działa na typie (Math.Round(x)) i w ogóle nie potrzebuje obiektu.

Pola statyczne: jedna kopia, współdzielona

Najprościej zobaczyć różnicę na liczniku. Każde Order ma własne Id, ale liczba dotąd utworzonych zamówień musi być przechowywana w jakimś wspólnym miejscu.

using System;

class Order
{
    private static int created;   // one copy for the whole program
    public int Id { get; }        // one copy per order
    public string Customer { get; }

    public Order(string customer)
    {
        created++;
        Id = created;
        Customer = customer;
    }

    public static int Created => created;
}

class Program
{
    static void Main()
    {
        var a = new Order("Ana");
        var b = new Order("Ben");
        var c = new Order("Chen");

        Console.WriteLine($"{a.Customer} #{a.Id}, {b.Customer} #{b.Id}, {c.Customer} #{c.Id}");
        Console.WriteLine($"Orders created: {Order.Created}");
    }
}

Wynik:

Ana #1, Ben #2, Chen #3
Orders created: 3

Do składowych statycznych odwołuje się przez nazwę typu: Order.Created, a nie a.Created. C# nie pozwala sięgać do składowej statycznej przez instancję (błąd CS0176), dzięki czemu w miejscu wywołania od razu widać, że wartość jest współdzielona.

Metody statyczne

Metoda statyczna nie ma this. Pracuje tylko ze swoimi parametrami i innymi składowymi statycznymi. Dlatego to naturalny kształt dla funkcji pomocniczych, które obliczają coś z danych wejściowych:

using System;

class Pricing
{
    public static decimal WithVat(decimal net, decimal rate) => Math.Round(net * (1 + rate), 2);

    public static string Format(decimal amount) => amount.ToString("0.00") + " EUR";
}

class Program
{
    static void Main()
    {
        decimal gross = Pricing.WithVat(49.90m, 0.23m);
        Console.WriteLine(Pricing.Format(gross));
        Console.WriteLine(Math.Max(3, 7)); // Math is full of static methods
    }
}

Wynik:

61.38 EUR
7

Samo Main jest statyczne: środowisko uruchomieniowe wywołuje je, zanim powstanie jakikolwiek obiekt.

Błąd CS0120: kod statyczny używa składowych instancji

Ponieważ Main jest statyczne, początkujący często trafiają na ten błąd, gdy tylko dodadzą drugą metodę:

class Program
{
    int visits;
    void Greet() { Console.WriteLine("Hello"); }

    static void Main()
    {
        Greet();    // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
        visits++;   // error CS0120: An object reference is required for the non-static field, method, or property 'Program.visits'
    }
}

Metoda statyczna nie ma obiektu, więc nie ma dla niej żadnego visits do zwiększenia. Są dwa rozwiązania, a właściwe zależy od tego, czym jest składowa:

• Składowa to naprawdę dane konkretnego obiektu: utwórz obiekt i użyj go. var app = new Program(); app.Greet();
• Składowa nie potrzebuje stanu obiektu: oznacz ją jako static. static void Greet() { ... }

Oznaczanie wszystkiego jako static, żeby błąd zniknął, działa w malutkim programie, a w prawdziwym zamienia się w stan globalny. Zdecyduj, pytając, czy dane należą do jednego obiektu, czy do całego programu.

W drugą stronę zawsze wolno: metody instancyjne mogą swobodnie wywoływać składowe statyczne.

Klasy statyczne

Klasa zadeklarowana jako static może zawierać tylko składowe statyczne i nigdy nie można utworzyć jej instancji. To nazwana grupa funkcji i stałych.

using System;

static class Temperature
{
    public const decimal FreezingC = 0m;

    public static decimal ToFahrenheit(decimal c) => c * 9 / 5 + 32;
    public static decimal ToCelsius(decimal f) => (f - 32) * 5 / 9;
    public static bool IsFreezing(decimal c) => c <= FreezingC;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(25m));
        Console.WriteLine(Temperature.ToCelsius(212m));
        Console.WriteLine(Temperature.IsFreezing(-3m));
        // var t = new Temperature(); // error CS0712: Cannot create an instance of the static class 'Temperature'
    }
}

Wynik:

77
100
True

Kompilator pilnuje tej umowy: składowa instancji w klasie statycznej to błąd CS0708, a new na niej to błąd CS0712. Math, Console, File, Path i Enumerable to klasy statyczne. Metody rozszerzające również muszą znajdować się w klasie statycznej.

Konstruktory statyczne i static readonly

Pole statyczne, którego wartość wymaga więcej niż jednego wyrażenia, można ustawić w konstruktorze statycznym, który środowisko uruchomieniowe wykonuje raz, przed pierwszym użyciem typu:

using System;
using System.Collections.Generic;

class ShippingRates
{
    public static readonly IReadOnlyDictionary<string, decimal> ByCountry;
    public static readonly DateTime LoadedOn = new DateTime(2026, 1, 1);

    static ShippingRates()
    {
        Console.WriteLine("ShippingRates initialized");
        ByCountry = new Dictionary<string, decimal> { ["PT"] = 4.90m, ["ES"] = 5.50m, ["FR"] = 6.20m };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before first use");
        Console.WriteLine(ShippingRates.ByCountry["ES"]);
        Console.WriteLine(ShippingRates.ByCountry.Count);
        Console.WriteLine(ShippingRates.LoadedOn.ToString("yyyy-MM-dd"));
    }
}

Wynik:

Before first use
ShippingRates initialized
5.50
3
2026-01-01

readonly oznacza, że pole można przypisać tylko w jego inicjalizatorze albo w konstruktorze statycznym. Potem nie da się go ponownie przypisać, choć obiekt, na który wskazuje, nadal może być modyfikowalny, i dlatego słownik jest udostępniony jako IReadOnlyDictionary.

const a static readonly

Oba dają nazwaną wartość współdzieloną przez cały program, a różnią się tym, kiedy wartość zostaje ustalona:

Wiersz o kopiowaniu ma znaczenie dla bibliotek: jeśli assembly A deklaruje public const int MaxItems = 50;, a assembly B go używa, B zawiera literał 50. Zmiana w A na 100 nic nie daje w B, dopóki B nie zostanie ponownie skompilowane. Dla wartości, które mogą się zmieniać między wersjami, wybieraj static readonly.

using static

Dyrektywa using static (C# 6) importuje statyczne składowe typu, więc możesz je wywoływać bez nazwy typu:

using System;
using static System.Math;
using static System.Console;

class Program
{
    static void Main()
    {
        double radius = 3;
        double area = PI * Pow(radius, 2);
        WriteLine($"Area: {area:F2}");
        WriteLine(Max(12, 40));
    }
}

Wynik:

Area: 28.27
40

Dobrze się to czyta w kodzie pełnym obliczeń matematycznych. Gdzie indziej używaj tego oszczędnie: samo WriteLine albo Parse ukrywa, z którego typu pochodzi metoda.

Stan statyczny i wątki

Pole statyczne jest współdzielone przez każdy wątek w procesie. Zwiększanie go jednocześnie z kilku wątków gubi aktualizacje, bo created++ to odczyt, dodawanie i zapis, a dwa wątki mogą je przeplatać. Do liczników używaj Interlocked.Increment(ref created), a do czegokolwiek większego lock. Najczęściej daje to o sobie znać w aplikacjach webowych: każde żądanie działa na jakimś wątku, więc pole statyczne przechowujące "bieżącego użytkownika" jest wspólne dla wszystkich użytkowników.

Jeszcze jeden niuans: w klasie generycznej każdy skonstruowany typ dostaje własne pola statyczne. Cache<int>.Count i Cache<string>.Count to dwa różne pola.

Kiedy używać static

Dobre zastosowania:

• Czyste funkcje pomocnicze, które obliczają wynik ze swoich argumentów: formatowanie, konwersje, walidacja.
• Stałe i dane wyszukiwania tylko do odczytu współdzielone przez program.
• Metody fabrykujące, takie jak TimeSpan.FromMinutes(5) albo twoje własne Temperature.FromCelsius(21).
• Metody rozszerzające.

Złe zastosowania:

• Modyfikowalny stan globalny (bieżący użytkownik, koszyk, zmieniające się ustawienia). Wiąże ze sobą każdy fragment kodu, który go dotyka, i uzależnia testy od pozostałości po innych testach.
• Wszystko, co zechcesz podmienić w testach, na przykład zegar, bazę danych albo nadawcę e-maili. Wywołań statycznych nie da się zastąpić atrapą; instancję przekazaną do konstruktora da się.