0Pricing
C# Academy · Lekcja

Konstruktory statyczne

Inicjalizuj stan statyczny dokładnie raz.

Konstruktory statyczne to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Czym jest konstruktor statyczny

Konstruktor statyczny inicjalizuje dane statyczne klasy. Jest uruchamiany automatycznie raz, przed pierwszym użyciem klasy, i nigdy nie wywołuje się go bezpośrednio.

using System;

class App
{
    public static string Version;

    static App()
    {
        Version = "1.0.0";
        Console.WriteLine("Static constructor ran");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(App.Version);
    }
}

Zasady składni

Konstruktor statyczny używa słowa kluczowego static, ma nazwę klasy, nie przyjmuje żadnych parametrów i nie ma modyfikatora dostępu.

using System;

class Config
{
    public static int MaxUsers;

    static Config()
    {
        MaxUsers = 100;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Max: " + Config.MaxUsers);
    }
}

Wykonywany dokładnie raz

Niezależnie od tego, ile razy użyje się klasy, konstruktor statyczny zostanie wykonany tylko raz — przy pierwszej potrzebie jego użycia.

using System;

class Counter
{
    public static int Instances;

    static Counter()
    {
        Console.WriteLine("Initializing static state");
        Instances = 0;
    }

    public Counter() { Instances++; }
}

class Program
{
    static void Main()
    {
        new Counter();
        new Counter();
        Console.WriteLine("Instances: " + Counter.Instances);
    }
}

Kiedy jest uruchamiany

Środowisko uruchomieniowe wywołuje go tuż przed pierwszym dostępem do dowolnego składowego elementu statycznego LUB przed utworzeniem pierwszej instancji — zależnie od tego, co nastąpi wcześniej.

using System;

class Lazy
{
    public static string Data;

    static Lazy()
    {
        Console.WriteLine("Triggered now");
        Data = "ready";
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before access");
        Console.WriteLine(Lazy.Data);
    }
}

Inicjalizowanie złożonych danych statycznych

Konstruktora statycznego należy użyć, gdy pola statyczne wymagają rzeczywistej logiki konfiguracji, a nie tylko prostych literałów.

using System;
using System.Collections.Generic;

class Lookup
{
    public static Dictionary<int, string> Table;

    static Lookup()
    {
        Table = new Dictionary<int, string>();
        for (int i = 1; i <= 3; i++)
            Table[i] = "Item" + i;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lookup.Table[2]);
    }
}

Konstruktor statyczny a inicjalizator pola

Proste wartości można ustawiać za pomocą inicjalizatorów inline. Konstruktor statyczny służy do konfiguracji wymagającej instrukcji, pętli lub obsługi błędów.

using System;

class Settings
{
    public static int Simple = 10;        // inline initializer
    public static int Computed;            // needs logic

    static Settings()
    {
        Computed = Simple * Simple;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Settings.Simple + ", " + Settings.Computed);
    }
}

Parametry są niedozwolone

Ponieważ środowisko uruchomieniowe wywołuje go automatycznie, konstruktor statyczny nie może przyjmować argumentów. Wszystkie jego dane wejściowe muszą pochodzić z innych danych statycznych lub stałych.

using System;

class Clock
{
    public static int StartHour;

    static Clock()
    {
        StartHour = 9;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Start: " + Clock.StartHour);
    }
}

Łączenie konstruktorów statycznych i instancji

Klasa może mieć oba rodzaje konstruktorów. Konstruktor statyczny jest wykonywany raz dla typu, a konstruktor instancji — dla każdego obiektu.

using System;

class Game
{
    public static string Title;
    public int Score;

    static Game()
    {
        Title = "Coddy Quest";
    }

    public Game(int score)
    {
        Score = score;
    }
}

class Program
{
    static void Main()
    {
        var g = new Game(50);
        Console.WriteLine(Game.Title + " score " + g.Score);
    }
}

Gwarancja kolejności

Konstruktor statyczny musi zakończyć działanie przed wykonaniem ciała dowolnego konstruktora instancji, który go wywołuje, dzięki czemu stan statyczny jest zawsze gotowy.

using System;

class Service
{
    public static string Endpoint;

    static Service()
    {
        Endpoint = "https://api.example.com";
    }

    public Service()
    {
        Console.WriteLine("Using " + Endpoint);
    }
}

class Program
{
    static void Main()
    {
        new Service();
    }
}

Używaj oszczędnie

Konstruktory statyczne wprowadzają jednorazowe sprawdzenie przed użyciem klasy i mogą pogorszyć wydajność, jeśli są nadużywane lub zgłaszają wyjątki. Należy utrzymywać je w niewielkim rozmiarze i zapewnić ich niezawodność.

using System;

class Cache
{
    public static int[] Data;

    static Cache()
    {
        Data = new int[] { 2, 4, 6, 8 };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Cache.Data[3]);
    }
}

Połączenie wszystkiego

Konstruktory statyczne idealnie nadają się do jednorazowej konfiguracji współdzielonych danych tylko do odczytu, takich jak tabele wyszukiwania lub konfiguracja wczytywana ze stałych.

using System;
using System.Collections.Generic;

class Currency
{
    public static Dictionary<string, string> Symbols;

    static Currency()
    {
        Symbols = new Dictionary<string, string>
        {
            ["USD"] = "$",
            ["EUR"] = "E",
            ["JPY"] = "Y"
        };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("USD symbol: " + Currency.Symbols["USD"]);
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat konstruktorów statycznych.

Podsumowanie

Konstruktor statyczny używa zapisu static ClassName(), nie przyjmuje parametrów i nie ma modyfikatora dostępu. Jest uruchamiany raz, automatycznie, przed pierwszym użyciem klasy, aby zainicjalizować stan statyczny wymagający rzeczywistej logiki. Należy używać go oszczędnie do jednorazowej konfiguracji współdzielonych danych.

using System;

class Demo
{
    public static int Value;
    static Demo() { Value = 42; }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.Value);
    }
}

Często zadawane pytania

Czy lekcja „Konstruktory statyczne” jest bezpłatna?

Tak — pełny tekst „Konstruktory statyczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konstruktory statyczne”?

Inicjalizuj stan statyczny dokładnie raz. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Konstruktory statyczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Definiowanie konstruktorów
  2. Łańcuchowanie konstruktorów za pomocą this
  3. Inicjalizatory obiektów i kolekcji
  4. Konstruktory statyczne
← Powrót do C# Academy