Prosty Kalkulator w C#

Prosty Kalkulator w C#

Stworzymy prosty kalkulator w C#, który będzie obsługiwał podstawowe operacje matematyczne: dodawanie, odejmowanie, mnożenie i dzielenie.

Program będzie prosił użytkownika o wybór operacji, a następnie o wprowadzenie dwóch liczb, na których ma zostać wykonana ta operacja.

Oto przykładowy kod:

using System;

class Kalkulator
{
    static void Main()
    {
        while (true)
        {
            Console.WriteLine("Prosty Kalkulator");
            Console.WriteLine("1. Dodawanie");
            Console.WriteLine("2. Odejmowanie");
            Console.WriteLine("3. Mnożenie");
            Console.WriteLine("4. Dzielenie");
            Console.WriteLine("5. Wyjście");

            Console.Write("Wybierz operację (1-5): ");
            int operacja = int.Parse(Console.ReadLine());

            if (operacja == 5)
            {
                break;
            }

            Console.Write("Wprowadź pierwszą liczbę: ");
            double liczba1 = double.Parse(Console.ReadLine());

            Console.Write("Wprowadź drugą liczbę: ");
            double liczba2 = double.Parse(Console.ReadLine());

            double wynik;

            switch (operacja)
            {
                case 1:
                    wynik = liczba1 + liczba2;
                    break;
                case 2:
                    wynik = liczba1 - liczba2;
                    break;
                case 3:
                    wynik = liczba1 * liczba2;
                    break;
                case 4:
                    if (liczba2 == 0)
                    {
                        Console.WriteLine("Błąd: Dzielenie przez zero!");
                        continue;
                    }
                    wynik = liczba1 / liczba2;
                    break;
                default:
                    Console.WriteLine("Nieprawidłowy wybór!");
                    continue;
            }

            Console.WriteLine("Wynik: " + wynik);
            Console.WriteLine();
        }

        Console.WriteLine("Dziękujemy za skorzystanie z kalkulatora!");
    }
}

Jak działa ten kalkulator:

1. Menu Wyboru: Użytkownik wybiera rodzaj operacji matematycznej (dodawanie, odejmowanie, mnożenie, dzielenie) lub decyduje się na wyjście z programu.
2. Wprowadzanie Liczb: Użytkownik jest proszony o wprowadzenie dwóch liczb, na których będzie wykonana wybrana operacja.
3. Obliczenia: Na podstawie wyboru użytkownika, program wykonuje odpowiednią operację matematyczną.
4. Obsługa Błędów: Program obsługuje potencjalne błędy, takie jak dzielenie przez zero.
5. Wyjście z Programu: Użytkownik może zakończyć działanie programu, wybierając odpowiednią opcję.

Ten program jest dobrym przykładem prostego kalkulatora w C#, demonstrującego podstawowe koncepty programowania, takie jak pętle, instrukcje warunkowe, operacje wejścia/wyjścia i obsługa błędów.

W celach dydaktycznych możemy rozszerzyć nasz program kalkulatora w C#
o kilka dodatkowych funkcjonalności i praktyk programistycznych.

Oto kilka sugestii:

1. Funkcje dla Operacji Matematycznych

Można wyciągnąć każdą operację matematyczną (dodawanie, odejmowanie, mnożenie, dzielenie) do osobnych funkcji. To poprawi czytelność kodu i wprowadzi pojęcie dekompozycji problemu na mniejsze, zarządzalne części.

2. Obsługa Wyjątków

Dodaj obsługę wyjątków (try-catch) do lepszego radzenia sobie z błędami, na przykład błędami konwersji string na double. To wprowadzi koncept obsługi błędów w programowaniu.

3. Walidacja Wejścia Użytkownika

Zamiast zakładać, że użytkownik zawsze wprowadzi poprawne dane, dodaj walidację wejścia. Na przykład sprawdź, czy wprowadzona wartość jest faktycznie liczbą.

4. Pętla Głównego Menu

Użyj pętli do powtarzania wyświetlania menu głównego po każdej operacji, zamiast zakończenia programu. To pozwoli użytkownikowi na wykonanie wielu operacji bez restartowania programu.

5. Testy Jednostkowe

Jeśli to możliwe, wprowadź prosty zestaw testów jednostkowych dla Twoich funkcji matematycznych. To pokaże, jak ważne jest zapewnienie, że kod działa poprawnie we wszystkich przypadkach.

6. Dokumentacja i Komentarze

Dodaj komentarze i dokumentację do kodu, wyjaśniając, jak każda część działa. To jest kluczowe dla dobrych praktyk programowania, szczególnie w kontekście edukacyjnym.

7. Refaktoryzacja

Po napisaniu pierwszej wersji programu, można przeprowadzić refaktoryzację, aby poprawić jakość kodu, np. poprzez eliminowanie powtarzającego się kodu.

8. Interfejs Użytkownika (UI)

Wprowadź prosty interfejs użytkownika, na przykład za pomocą Windows Forms, aby zapewnić bardziej przyjazne doświadczenie użytkownika.

9. Rozszerzalność

Pomyśl o tym, jak program mógłby być rozszerzony w przyszłości. Na przykład, jak łatwo byłoby dodać więcej operacji matematycznych?

10. Kod Źródłowy i Kontrola Wersji

Zachęcaj do korzystania z systemu kontroli wersji, jak Git, do śledzenia zmian w kodzie, co jest standardową praktyką w rozwoju oprogramowania.

Każda z tych zmian dodaje wartość edukacyjną do projektu i pomaga lepiej zrozumieć różne aspekty programowania w C#.

Poniżej znajdziesz zmodyfikowany kod kalkulatora w C#, który implementuje punkty 1, 7 i 9: dekompozycję operacji matematycznych na funkcje, refaktoryzację kodu dla lepszej jakości i czytelności, oraz myślenie o rozszerzalności programu.

Zmodyfikowany Kod Kalkulatora:

using System;

class Kalkulator
{
    static void Main()
    {
        while (true)
        {
            Console.WriteLine("Prosty Kalkulator");
            Console.WriteLine("1. Dodawanie");
            Console.WriteLine("2. Odejmowanie");
            Console.WriteLine("3. Mnożenie");
            Console.WriteLine("4. Dzielenie");
            Console.WriteLine("5. Wyjście");

            Console.Write("Wybierz operację (1-5): ");
            int operacja = int.Parse(Console.ReadLine());

            if (operacja == 5)
            {
                break;
            }

            Console.Write("Wprowadź pierwszą liczbę: ");
            double liczba1 = double.Parse(Console.ReadLine());

            Console.Write("Wprowadź drugą liczbę: ");
            double liczba2 = double.Parse(Console.ReadLine());

            double wynik = 0;

            switch (operacja)
            {
                case 1:
                    wynik = Dodawanie(liczba1, liczba2);
                    break;
                case 2:
                    wynik = Odejmowanie(liczba1, liczba2);
                    break;
                case 3:
                    wynik = Mnozenie(liczba1, liczba2);
                    break;
                case 4:
                    wynik = Dzielenie(liczba1, liczba2);
                    break;
                default:
                    Console.WriteLine("Nieprawidłowy wybór!");
                    continue;
            }

            Console.WriteLine("Wynik: " + wynik);
            Console.WriteLine();
        }

        Console.WriteLine("Dziękujemy za skorzystanie z kalkulatora!");
    }

    static double Dodawanie(double a, double b)
    {
        return a + b;
    }

    static double Odejmowanie(double a, double b)
    {
        return a - b;
    }

    static double Mnozenie(double a, double b)
    {
        return a * b;
    }

    static double Dzielenie(double a, double b)
    {
        if (b == 0)
        {
            Console.WriteLine("Błąd: Dzielenie przez zero!");
            return 0;
        }
        return a / b;
    }
}

Wyjaśnienie Zmian:

1. Dekompozycja na Funkcje: Każda operacja matematyczna (dodawanie, odejmowanie, mnożenie, dzielenie) została wyciągnięta do osobnej funkcji. To ułatwia zrozumienie kodu i jego późniejsze utrzymanie.
2. Refaktoryzacja: Przeniesienie logiki do osobnych funkcji to przykład refaktoryzacji, która czyni kod bardziej modułowym i łatwiejszym w utrzymaniu. Dzięki temu łatwiej jest zarządzać każdą operacją matematyczną niezależnie.
3. Rozszerzalność: Teraz, jeśli chcesz dodać więcej operacji do kalkulatora, możesz to zrobić, dodając nową funkcję i rozszerzając instrukcję switch w Main(). Ta struktura jest znacznie bardziej elastyczna i gotowa na rozszerzenia w przyszłości.

Te zmiany nie tylko poprawiają jakość i czytelność kodu, ale także demonstrują dobre praktyki programistyczne, takie jak enkapsulacja logiki w funkcjach i przygotowanie kodu na przyszłe rozszerzenia.