Dlaczego Twój kod w C# nie działa? Problem mental model

Znasz składnię C#. Rozumiesz pętle, ify, zmienne…
A jednak gdy masz zbudować coś samodzielnie — blokada.

To nie jest problem wiedzy.
To problem mental modelu programowania.

W tym artykule pokażę Ci:

dlaczego Twój kod „działa”, ale nie da się go rozwijać
czym różni się junior od seniora (naprawdę)
jak myśleć o kodzie jak o fabryce danych
oraz jak przejść od chaosu do struktury (na realnym przykładzie w C#)

🧩 Czym jest mental model w programowaniu?

Mental model to sposób, w jaki rozumiesz działanie systemu.

❌ Mental model juniora

Kod = lista instrukcji wykonywana linia po linii

Efekt:

piszesz wszystko w jednym miejscu
brak separacji odpowiedzialności
trudność w debugowaniu
brak możliwości testowania

✅ Mental model seniora

Program = pipeline przetwarzania danych

Czyli:

dane wchodzą → są przetwarzane → wychodzą jako wynik
każda część ma swoją odpowiedzialność

🔥 Problem: Kod działa, ale jest nie do utrzymania

Spójrz na typowy kod początkującego:

Console.WriteLine("Podaj pierwszą liczbę:");
int a = int.Parse(Console.ReadLine());

Console.WriteLine("Podaj drugą liczbę:");
int b = int.Parse(Console.ReadLine());

Console.WriteLine("Co chcesz zrobić? (+, -, *, /)");
string op = Console.ReadLine();

if (op == "+")
{
    Console.WriteLine(a + b);
}
else if (op == "-")
{
    Console.WriteLine(a - b);
}
else if (op == "*")
{
    Console.WriteLine(a * b);
}
else if (op == "/")
{
    Console.WriteLine(a / b);
}

🚨 Co tu jest nie tak?

❌ brak walidacji (crash przy błędnym input)
❌ dzielenie przez zero
❌ brak testowalności
❌ wszystko w jednym miejscu (brak SRP)
❌ każda zmiana = ryzyko

👉 Ten kod działa… ale nie jest inżynierią oprogramowania

🏭 Nowy mental model: Kod jako fabryka

Zamiast myśleć o kodzie jak o tekście, myśl o nim jak o systemie:

🔄 Pipeline:

INPUT → VALIDATION → PROCESSING → OUTPUT

🧱 1. Magazyn danych (Input)

public class CalculationInput
{
    public double FirstNumber { get; set; }
    public double SecondNumber { get; set; }
    public string Operation { get; set; }
}

👉 Wszystkie dane w jednym miejscu
👉 Brak „rozrzuconych zmiennych”

⚙️ 2. Walidacja (Quality Control)

public class InputValidator
{
    public bool IsValid(CalculationInput input)
    {
        if (input.SecondNumber == 0 && input.Operation == "/")
        {
            Console.WriteLine("❌ Nie możesz dzielić przez zero!");
            return false;
        }

        var validOperations = new[] { "+", "-", "*", "/" };
        if (!validOperations.Contains(input.Operation))
        {
            Console.WriteLine("❌ Nieprawidłowa operacja!");
            return false;
        }

        return true;
    }
}

👉 Oddzielna odpowiedzialność
👉 Łatwe testowanie
👉 Brak side-effectów w logice biznesowej (do poprawy → Console out)

🧮 3. Logika (Processing)

public class Calculator
{
    public double Calculate(CalculationInput input)
    {
        return input.Operation switch
        {
            "+" => input.FirstNumber + input.SecondNumber,
            "-" => input.FirstNumber - input.SecondNumber,
            "*" => input.FirstNumber * input.SecondNumber,
            "/" => input.FirstNumber / input.SecondNumber,
            _ => throw new InvalidOperationException("Nieobsługiwana operacja")
        };
    }
}

👉 Single Responsibility Principle
👉 Zero zależności od UI
👉 Gotowe pod unit testy

🏁 4. Orkiestracja (Flow aplikacji)


// ✅ Główna "linia montażowa"
class Program
{
    static void Main()
    {
        // 1. Zbierz surowce (dane od użytkownika)
        var input = new CalculationInput
        {
            FirstNumber = GetNumber("Podaj pierwszą liczbę:"),
            SecondNumber = GetNumber("Podaj drugą liczbę:"),
            Operation = GetOperation()
        };

        // 2. Kontrola jakości
        var validator = new InputValidator();
        if (!validator.IsValid(input))
            return;

        // 3. Przetwarzanie
        var calculator = new Calculator();
        double result = calculator.Calculate(input);

        // 4. Wysyłka produktu (wynik)
        Console.WriteLine($"Wynik: {result}");
    }

    static double GetNumber(string prompt)
    {
        Console.WriteLine(prompt);
        while (true)
        {
            if (double.TryParse(Console.ReadLine(), out double number))
                return number;

            Console.WriteLine("❌ To nie jest liczba! Spróbuj ponownie:");
        }
    }

    static string GetOperation()
    {
        Console.WriteLine("Wybierz operację (+, -, *, /):");
        return Console.ReadLine();
    }
}

⚖️ Porównanie: Stary vs Nowy kod

Stary kod	Nowy kod
Wszystko w Main	Podział na komponenty
Brak walidacji	Kontrola jakości
Trudny w testowaniu	Testowalny
Chaos	Struktura

🧠 Dlaczego to działa?

Zmieniasz sposób myślenia:

❌ było:

„Co napisać, żeby działało?”

✅ jest:

„Jak przepływają dane przez system?”

🛠️ Gdzie to wykorzystasz w praktyce?

Ten model to fundament:

ASP.NET Core

Request → Validation → Service → Response

EF Core

Query → Transform → Result

Clean Architecture

Controller → UseCase → Domain → Infrastructure

👉 To cały czas ten sam wzorzec

✅ Checklist: Czy Twój kod jest fabryką?

Sprawdź:

dane są w jednym miejscu?
walidacja jest oddzielna?
logika nie zależy od UI?
możesz testować bez Console/DB?
zmiana jednej rzeczy nie psuje reszty?

Jeśli NIE → masz zły mental model

📚 Zobacz też

Zobacz także — powiązane artykuły

👉 MCP w .NET (C#) – jak zbudować serwer AI krok po kroku

👉 T worzenie klas i obiektów w C# — kompletny przewodnik

👉 Pattern Matching w C# – switch expressions i type patterns

🚀 Call To Action

👉 Weź swój stary projekt
👉 znajdź 1 fragment, który robi za dużo
👉 wydziel go do osobnej klasy

💬 Wrzuć PRZED / PO w komentarzu — zobaczę i dam feedback

📩 Chcesz więcej takich materiałów?
Zapisz się na Listę VIP pobierz roadmapę .NET

Dołącz do Listy VIP

I otrzymaj roadmapę Junior .NET Developer oraz najlepszą ofertę, gdy tylko ruszą zapisy!!!