Program C# do sortowania nazw

Program C# do sortowania nazw

Napiszemy teraz program w C# do sortowania ciągu nazw oddzielonych średnikami. Program będzie zawierał funkcję do sortowania zarówno w porządku rosnącym, jak i malejącym. Użytkownik będzie mógł wybrać preferowany sposób sortowania.

Poniżej przykładowy kod:

using System;
using System.Linq;

class SortNames
{
    static void Main()
    {
        Console.WriteLine("Wprowadź ciąg nazw oddzielonych średnikiem:");
        string input = Console.ReadLine();
        
        string[] names = input.Split(';');

        Console.WriteLine("Wybierz sposób sortowania: 1 dla rosnącego, 2 dla malejącego");
        int choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                SortAscending(names);
                break;
            case 2:
                SortDescending(names);
                break;
            default:
                Console.WriteLine("Nieprawidłowy wybór!");
                break;
        }
    }

    static void SortAscending(string[] names)
    {
        var sortedNames = names.OrderBy(n => n).ToArray();
        Console.WriteLine("Posortowane nazwy (rosnąco):");
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }

    static void SortDescending(string[] names)
    {
        var sortedNames = names.OrderByDescending(n => n).ToArray();
        Console.WriteLine("Posortowane nazwy (malejąco):");
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

W tym programie:

1. Użytkownik wprowadza ciąg nazw oddzielonych średnikiem.
2. Następnie użytkownik wybiera, czy chce sortować w porządku rosnącym (1) czy malejącym (2).
3. Program sortuje nazwy zgodnie z wybraną opcją i wyświetla posortowany ciąg.

Uwagi:

• Sortowanie odbywa się alfabetycznie (według wartości ASCII znaków).
• Pusty ciąg między średnikami (;;) będzie traktowany jako pusta nazwa.
• Program jest prosty i nie zawiera zaawansowanego obsługi błędów (np. dla nieprawidłowego wejścia). Można to rozszerzyć w zależności od potrzeb.

Istnieje kilka aspektów, które można dodać lub uwzględnić w programie C#
do sortowania ciągu nazw,
aby lepiej zilustrować różne koncepcje programowania i praktyki.

Oto kilka sugestii:

1. Walidacja Wejścia

Dodaj kod do walidacji wejścia użytkownika. Sprawdź, czy użytkownik faktycznie wprowadził ciąg znaków, czy wprowadzono właściwe opcje sortowania. Dzięki temu program będzie bardziej odporny na błędy.

2. Użycie Wyrażeń Lambda

Wykorzystaj wyrażenia lambda do bardziej zwięzłego kodu sortowania, co może być dobrym przykładem ich praktycznego zastosowania.

3. Porównywanie Bez Wrażliwości na Wielkość Liter

Dodaj opcję sortowania bez wrażliwości na wielkość liter, aby zaprezentować jak można manipulować porównywaniem ciągów w różnych kontekstach.

4. Testy Jednostkowe

Zaproponuj napisanie prostych testów jednostkowych dla funkcji sortujących, co jest ważnym elementem w praktyce profesjonalnego programowania.

5. Użycie Generików

Jeśli to możliwe, zmodyfikuj funkcje sortujące, aby były bardziej ogólne (używając generików), co pozwoli na sortowanie różnych typów danych, nie tylko ciągów znaków.

6. Obsługa Błędów i Wyjątków

Rozwiń obsługę błędów, na przykład dodając obsługę wyjątków dla nieprawidłowych danych wejściowych.

7. Komentarze i Dokumentacja

Uzupełnij kod o komentarze i dokumentację, wyjaśniając działanie poszczególnych segmentów kodu, co jest kluczowe w nauczaniu dobrych praktyk kodowania.

8. Interfejs Użytkownika

Rozważ dodanie prostego interfejsu użytkownika (GUI), na przykład za pomocą Windows Forms lub WPF, aby zaprezentować, jak ten sam kod logiki może być używany w różnych kontekstach aplikacji.

9. Refaktoryzacja i Czysty Kod

Skup się na refaktoryzacji kodu, aby był bardziej zrozumiały, łatwiejszy w utrzymaniu i bardziej modularny.

10. Porównanie Wydajności

Porównaj wydajność różnych metod sortowania, na przykład sortowania wbudowanego w .NET a sortowania wykonanego za pomocą własnej implementacji. To może być cenna lekcja na temat złożoności algorytmów i wydajności.

Zmodyfikowany Kod z Użyciem Wyrażeń Lambda:

Używanie wyrażeń lambda w C# to potężne narzędzie, które pozwala na pisanie bardziej zwięzłego i elastycznego kodu. W kontekście naszego programu do sortowania ciągu nazw, wyrażenia lambda mogą być użyte do uproszczenia logiki sortowania oraz do tworzenia bardziej elastycznych i konfigurowalnych rozwiązań.

Zmodyfikujmy nasz program, wykorzystując wyrażenia lambda do definiowania kryteriów sortowania:

using System;
using System.Linq;

class SortNamesWithLambda
{
    static void Main()
    {
        Console.WriteLine("Wprowadź ciąg nazw oddzielonych średnikiem:");
        string input = Console.ReadLine();

        string[] names = input.Split(';');

        Console.WriteLine("Wybierz sposób sortowania: 1 dla rosnącego, 2 dla malejącego");
        int choice = int.Parse(Console.ReadLine());

        Func<string[], string[]> sortFunction = choice == 1 ? 
            (Func<string[], string[]>)(array => array.OrderBy(n => n).ToArray()) : 
            array => array.OrderByDescending(n => n).ToArray();

        var sortedNames = sortFunction(names);

        Console.WriteLine("Posortowane nazwy:");
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

Wyjaśnienie Kodu:

• W tej wersji programu, wyrażenie lambda jest używane do określenia funkcji sortującej. Zależnie od wyboru użytkownika, sortFunction jest ustawiana na funkcję sortującą w porządku rosnącym lub malejącym.
• Wyrażenia lambda array => array.OrderBy(n => n).ToArray() i array => array.OrderByDescending(n => n).ToArray() są przypisywane do sortFunction w zależności od wyboru użytkownika. Te wyrażenia lambda biorą tablicę array i zwracają nową tablicę, posortowaną zgodnie z określonym kryterium.
• Następnie wywołujemy sortFunction z naszą tablicą nazw, aby uzyskać posortowaną tablicę, którą następnie wyświetlamy.

Użycie wyrażeń lambda w ten sposób znacznie upraszcza kod i czyni go bardziej elastycznym. Ponadto, jest to dobry przykład pokazujący, jak wyrażenia lambda mogą być używane do tworzenia konfigurowalnych i łatwo zmienianych operacji, co jest bardzo użyteczne w wielu różnych kontekstach programistycznych.

Przykładowy Kod z Użyciem Generików:

Dodanie użycia generików do naszego programu sortującego ciągi nazw może znacznie zwiększyć jego elastyczność i użyteczność. Generiki pozwalają na pisanie metod i klas, które działają z różnymi typami danych, co sprawia, że są bardziej wielofunkcyjne i ponownie wykorzystywane.

Oto przykładowa modyfikacja programu, w której funkcje sortujące są przekształcone w metody generyczne. Te metody mogą teraz sortować dowolne typy, które implementują interfejs IComparable, co jest wymagane do porównywania elementów podczas sortowania.

using System;
using System.Linq;

class SortUtility
{
    static void Main()
    {
        Console.WriteLine("Wprowadź ciąg słów oddzielonych średnikiem:");
        string input = Console.ReadLine();
        
        string[] words = input.Split(';');

        Console.WriteLine("Wybierz sposób sortowania: 1 dla rosnącego, 2 dla malejącego");
        int choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                DisplaySorted(words, SortAscending);
                break;
            case 2:
                DisplaySorted(words, SortDescending);
                break;
            default:
                Console.WriteLine("Nieprawidłowy wybór!");
                break;
        }
    }

    static T[] SortAscending<T>(T[] array) where T : IComparable
    {
        return array.OrderBy(x => x).ToArray();
    }

    static T[] SortDescending<T>(T[] array) where T : IComparable
    {
        return array.OrderByDescending(x => x).ToArray();
    }

    static void DisplaySorted<T>(T[] array, Func<T[], T[]> sortFunction)
    {
        var sortedArray = sortFunction(array);
        Console.WriteLine("Posortowane elementy:");
        foreach (var element in sortedArray)
        {
            Console.WriteLine(element);
        }
    }
}

Wyjaśnienie Kodu:

• Metody SortAscending i SortDescending są teraz metodami generycznymi, co oznacza, że mogą pracować z dowolnym typem T, który implementuje interfejs IComparable. Wymóg where T : IComparable zapewnia, że typ T może być porównywany, co jest niezbędne do sortowania.
• Metoda DisplaySorted przyjmuje tablicę i funkcję sortującą jako argumenty. Funkcja sortująca jest wywoływana, a wynikowy posortowany ciąg jest wyświetlany.
• Główna korzyść z tego podejścia polega na tym, że nasze funkcje sortujące są teraz bardziej uniwersalne. Mogą być używane do sortowania nie tylko ciągów znaków, ale także innych typów danych, takich jak liczby, daty, czy nawet niestandardowe obiekty, o ile implementują interfejs IComparable.

Użycie generików w ten sposób jest doskonałym przykładem, jak zwiększyć ponowne wykorzystanie kodu i elastyczność w programowaniu obiektowym. Dzięki generikom, możesz pisać metody, które są bardziej abstrakcyjne i mniej zależne od konkretnych typów danych.