Porządki w Kodzie C# - Refaktoryzacja Istniejącego Projektu

Każdy programista prędzej czy później natrafi na fragment kodu, który aż się prosi o poprawę. Być może to starszy projekt pisany pod presją czasu, albo kod odziedziczony po kimś innym. Zamiast jednak przepisywać wszystko od zera, warto skorzystać z refaktoryzacji – techniki stopniowego ulepszania kodu bez zmieniania jego zewnętrznego działania. Refaktoryzacja sprawia, że kod staje się czytelniejszy, prostszy w utrzymaniu i rozwoju, a ryzyko błędów maleje. Co ważne, takie ulepszenia można wplatać na bieżąco w codzienną pracę (np. przy dodawaniu nowej funkcjonalności czy podczas code review), zamiast odkładać je w nieskończoność. Dzisiaj przedstawię konkretne techniki refaktoryzacji w C#, dzięki którym nawet początkujący programiści odświeżą swój projekt i zamienią spaghetti code w czysty kod.

Najważniejsze techniki refaktoryzacji w C#

public void CreateUser(string name, string email) 
{
    /* Walidacja danych wejściowych */
    if (string.IsNullOrEmpty(name) || !email.Contains("@")) 
    {
        Console.WriteLine("Dane nieprawidłowe");
        return;
    }
    /* Zapis użytkownika do bazy */
    Database.Save(name, email);
    /* Wysłanie powiadomienia mailowego */
    EmailService.Send(email, "Witaj", "Cześć " + name + ", witamy!");
}

Po refaktoryzacji: Podzieliliśmy kod na mniejsze metody pełniące osobne role:

public bool ValidateUserData(string name, string email) 
{
    if (string.IsNullOrEmpty(name) || !email.Contains("@"))
        return false;
    /* ...ewentualne inne warunki... */
    return true;
}

public void CreateUser(string name, string email) 
{
    if (!ValidateUserData(name, email)) 
    {
        Console.WriteLine("Dane nieprawidłowe");
        return;
    }
    Database.Save(name, email);
    SendWelcomeEmail(name, email);
}

private void SendWelcomeEmail(string name, string email) 
{
    EmailService.Send(email, "Witaj", $"Cześć {name}, witamy!");
}

Nowa wersja jest bardziej przejrzysta – główna metoda CreateUser jasno pokazuje logikę wysokiego poziomu (walidacja -> zapis -> powiadomienie), delegując detale do mniejszych metod. Każda z tych metod robi dokładnie jedną rzecz, co ułatwia jej ponowne użycie i testowanie.

3. Popraw nazewnictwo i czytelność – Często najprostszą formą refaktoryzacji jest zmiana nazw zmiennych, metod czy klas na bardziej zrozumiałe. Kod czytamy o wiele częściej niż piszemy, dlatego nazwy powinny mówić, co dana rzecz robi lub przechowuje. Unikaj nazw typu x, temp czy DoStuff() – zastąp je np. count, userEmail czy SendWelcomeEmail(). Dobra nazwa eliminuje potrzebę komentarza. Poświęć chwilę na przemyślenie, czy nazwy w Twoim kodzie są jasne dla kogoś, kto widzi go pierwszy raz. Jeśli nie – śmiało je zrefaktoruj (w IDE zrobisz to bezpiecznie opcją Rename, która zmieni nazwę wszędzie). To drobna zmiana, która natychmiast poprawia jakość kodu.

4. Jedna klasa = jedna odpowiedzialność – Zwróć uwagę, czy Twoje klasy nie urosły do wielu zadań na raz. Klasa powinna skupiać się na jednym głównym zagadnieniu lub funkcjonalności (zgodnie z zasadą Single Responsibility Principle). Jeśli np. klasa UserManager zajmuje się walidacją danych, połączeniem z bazą i wysyłaniem e-maili, to znak, że warto podzielić jej obowiązki na kilka mniejszych klas lub modułów. Dzięki temu każda część systemu ma jasno określoną rolę i łatwiej ją modyfikować. Podobnie zbyt długa lista metod w klasie sugeruje, że można wydzielić nową klasę pomocniczą. Taka refaktoryzacja upraszcza strukturę projektu i zapobiega powstawaniu "god class", którą trudno utrzymać. Pamiętaj: mniejszy, wyspecjalizowany kod jest z reguły bardziej elastyczny i mniej awaryjny.

5. Upraszczaj złożoną logikę warunkową – Rozbudowane instrukcje if...else if...else czy wielkie bloki switch bywają trudne w utrzymaniu. C# oferuje nowoczesne konstrukcje, które mogą uczynić taką logikę czytelniejszą – np. wyrażenia switch pozwalają zapisać decyzje w zgrabnej formie. Przykładowo zamiast szeregu if-ów ustawiających wartość bonus zależnie od typu użytkownika:

bonus = userType switch 
{
    "Admin"   => 1000,
    "Manager" => 500,
    _         => 0
};

Taki zapis jest bardziej zwięzły i czytelny. Jeśli jednak logika warunkowa robi zupełnie różne rzeczy w zależności od wartości (np. różne obiekty wykonują inny kod), rozważ głębszą refaktoryzację – często polimorfizm albo wzorzec strategii pozwala zastąpić skomplikowany warunek zestawem czytelnych klas. Zamiast pytać obiekt "jaki masz typ?" i na tej podstawie wykonywać akcje, można powiedzieć obiektowi co ma zrobić, a wewnątrz każda klasa zadba o własną implementację. To bardziej zaawansowana technika, ale warto o niej wiedzieć – ułatwia dodawanie nowych wariantów działania bez ruszania istniejącego kodu (zasada OCP – Open/Closed Principle). Niezależnie od podejścia, celem jest prostszy, przejrzysty kod pozbawiony zagmatwanych warunków.

Podsumowanie

Refaktoryzacja to nie luksus, a konieczność w pracy programisty – dzięki niej kod naszego C#-owego projektu pozostaje w dobrej formie mimo upływu czasu. 

Poznaliśmy dziś kilka podstawowych technik: eliminowanie duplikacji, dzielenie kodu na mniejsze części, ulepszanie nazw, wydzielanie odpowiedzialności i upraszczanie logiki. Stosując te metody regularnie, unikniesz narastania tzw. długu technologicznego i sprawisz, że dodawanie nowych funkcjonalności stanie się szybsze i przyjemniejsze. 

Pamiętaj, by refaktoryzować krok po kroku – małe zmiany, testowanie działania i dopiero kolejna porcja poprawek. Dzięki temu Twoja aplikacja będzie rozwijać się stabilnie, a Ty nabierzesz dobrych nawyków pisania czystego kodu.

Na koniec, jeśli chcesz rozwinąć swoje umiejętności C#/.NET od podstaw i zdobyć pierwszą pracę jako programista, zachęcam do sprawdzenia mojego szkolenia online "Zostań Programistą .NET" – to kompleksowa droga od zera do junior developera w 3 miesiące.