Nowoczesny C# w 2025 - Funkcje, Które Musisz Znać

C# jako język ciągle się rozwija i nowe wersje wprowadzają usprawnienia, które upraszczają kod i czynią go bardziej zrozumiałym. W 2025 roku mamy do dyspozycji wiele nowoczesnych funkcji i składni, o których jeszcze kilka lat temu mogliśmy tylko pomarzyć. Warto je znać, aby pisać czytelny, zwięzły i idiomatyczny kod – zarówno w nowych projektach, jak i modernizując stare aplikacje. W tym artykule omawiam najciekawsze funkcje języka C#, które każdy współczesny Programista C#/.NET powinien znać.

Top-level statements – prosty kod bez ceremonii

Globalne usingi i deklaracja przestrzeni nazw w jednym wierszu

/* Przed C# 10: */
namespace MyApp
{
    class Book { }
}

Teraz można zapisać zwięźlej:

/* C# 10 i nowsze: */
namespace MyApp;
class Book { }

Efekt jest ten sam, a zniknął jeden poziom wcięcia i para klamerek, przez co plik jest od razu czytelniejszy. W połączeniu z globalnymi using otrzymujemy czystszy, bardziej przejrzysty kod na starcie każdego pliku.

Dopasowywanie wzorców (Pattern Matching)

if (emp != null && emp.Department == "IT") 
{
    Console.WriteLine("Welcome");
}

W nowoczesnym C# zapiszemy to zgrabniej przy pomocy pattern matching:

if (emp is { Department: "IT" }) 
{
    Console.WriteLine("Welcome");
}

Wzorzec { Department: "IT" } sprawdza jednocześnie, czy emp nie jest null oraz czy jego właściwość Department ma wartość "IT". Możemy iść dalej – dopasowanie wzorca pozwala też od razu wyciągnąć wartości do zmiennych. Rozszerzmy przykład, aby od razu pobrać nazwisko pracownika:

if (emp is Employee { Department: "IT", Name: var n }) 
{
    Console.WriteLine($"Welcome {n}");
}

W powyższym kodzie warunek sprawdza, czy emp jest obiektem Employee z działu IT, a jeśli tak, to przypisuje jego Name do zmiennej n, którą możemy wykorzystać wewnątrz bloku. Wszystko to w jednej, czytelnej konstrukcji zamiast kilku zagnieżdżonych instrukcji.

Warto dodać, że najnowsze wersje C# wprowadziły także wzorce list (C# 11) pozwalające dopasowywać sekwencje i kolekcje (np. sprawdzić strukturę tablicy lub listy za pomocą składni [ ]). Dopasowywanie wzorców upraszcza kod warunkowy i pozwala wyrazić złożone logiki sprawdzania danych w deklaratywny, zwięzły sposób.

Rekordy i skrócona definicja obiektów

public record Person(string FirstName, string LastName);

W jednej linii zdefiniowaliśmy klasę Person z dwoma właściwościami tylko do odczytu (init-only). Kompilator wygeneruje za nas konstruktor, właściwości, a także metody Equals, GetHashCode i ToString odpowiednio porównujące i wyświetlające zawartość obiektu. Dzięki temu taki rekord możemy traktować jak wartość: dwie instancje Person("Jan", "Kowalski") będą sobie równe wartościowo (== zwróci true), co w przypadku zwykłych klas domyślnie nie ma miejsca bez nadpisania metod.

Rekordy idealnie nadają się do przechowywania danych konfiguracyjnych, wyników, DTO itp., gdzie chcemy prostego typu z właściwościami i bez zbędnej logiki. Dla bardziej złożonych przypadków można definiować rekordy w rozszerzonej formie (np. z ciałem klasy, dziedziczeniem lub mutowalnymi polami, jeśli naprawdę trzeba).

W kontekście rekordów pojawiło się też słowo kluczowe init dla setterów właściwości. Pozwala ono ustawiać wartość tylko podczas inicjalizacji obiektu (w konstruktorze lub przy użyciu składni object initializer), dzięki czemu po utworzeniu obiektu właściwość staje się tylko do odczytu. Przykładowo:

public record Book
{
    public string Title { get; init; }
    public string Author { get; init; }
}

Tutaj Title i Author można ustawić tylko raz przy tworzeniu Book, potem są one niemodyfikowalne – co wspiera niezmienność obiektów.
C# 12 idzie o krok dalej i udostępnia tzw. primary constructors również dla zwykłych klas i struktur (wcześniej taka składnia z parametrami przy nazwie typu dostępna była tylko w rekordach). Teraz możemy definiować konstruktory podstawowe bezpośrednio w deklaracji klasy. Na przykład:

public class Point(int x, int y)
{
    public int X => x;
    public int Y => y;
}

Taki zapis spowoduje, że kompilator wygeneruje konstruktor przyjmujący (int x, int y), a parametry te są dostępne wewnątrz ciała klasy (jak pokazano powyżej przy definicji właściwości). Oszczędzamy kilka dodatkowych linii kodu, które normalnie przeznaczylibyśmy na pisanie konstruktora i pól prywatnych. Warto pamiętać, że gdy klasa ma primary constructor, kompilator nie dodaje już domyślnego konstruktora bezparametrowego – mamy więc pełną kontrolę nad sposobem tworzenia obiektu.

Podsumowując, rekordy i konstruktory w definicji klasy to ukłon w stronę programistów ceniących zwięzłość. Pozwalają szybciej definiować modele danych i proste klasy, skupiając się na tym co dana klasa przechowuje, zamiast na ceremonialnym kodzie jak to przechować.

Bezpieczniejsze operacje na null i wymagane właściwości

public class User 
{
    public required string Name { get; init; }
    public required string Email { get; init; }
}

var u = new User { Name = "Ala" }; /* Błąd kompilacji – brakuje Email */

Tutaj klasa User oznacza, że Name i Email są obowiązkowe. Przy próbie utworzenia obiektu bez podania tych właściwości dostaniemy błąd jeszcze przed uruchomieniem programu. Dzięki temu unikamy sytuacji, w której obiekt jest niekompletnie zainicjowany, co często prowadziło do błędów w czasie działania aplikacji. Mechanizm required świetnie uzupełnia się z ideą typów nullowalnych – razem zapewniają, że nasze obiekty mają wszystkie potrzebne dane i że raczej nie trafimy na niespodziewane null tam, gdzie ich być nie powinno.

Warto przy okazji wspomnieć, że już wcześniej C# ułatwił radzenie sobie z null poprzez operator bezpiecznego dostępu ?. i operator łączenia z wartością domyślną ??. Pozwalają one zwięźle obsłużyć przypadki, gdy coś może być null (np. var length = str?.Length ?? 0; da długość stringa lub 0, gdy str jest null). Te operatory to dziś standardowy element składni, lecz to właśnie nullable reference types i required przenoszą bezpieczeństwo o poziom wyżej – na etap kompilacji.

Surowe literały tekstowe (raw string literals)

string query = """
SELECT * 
FROM Users
WHERE Name = "Jan Kowalski"
AND IsActive = true;
""";

Dzięki użyciu """ cały ten tekst (wraz z znakami nowej linii i cudzysłowami wewnątrz) został zapisany dokładnie tak, jak chcemy, bez żadnych dodatkowych znaczków typu \n czy \". Surowe literały znakowe znakomicie sprawdzają się przy wstawianiu większych bloków tekstu w kodzie – np. przy budowaniu ciągów JSON, wyrażeń regularnych czy komunikatów, które wcześniej przez nadmiar znaków escape były trudne do czytania.

Co więcej, surowe literały współpracują z interpolacją stringów. Jeśli potrzebujemy użyć składni ${...} wewnątrz takiego literału, możemy to zrobić zaczynając ciąg od dolarów i odpowiedniej liczby cudzysłowów, np. $""" (wtedy wewnątrz pojedyncze { i } są traktowane dosłownie, a {{ }} oznaczają faktyczne nawiasy dla interpolacji). To nieco bardziej zaawansowane, ale ważne, że projektanci języka pomyśleli i o tym przypadku.

Podsumowując, raw string literals to mała zmiana, która ogromnie poprawia wygodę pracy z tekstem w kodzie. Koniec z chaotycznymi ciągami pełnymi ukośników – teraz widzimy w kodzie od razu docelowy tekst w czytelnej formie.

Zakończenie