C#-Konsolenanwendung mit Vererbung und Polymorphie für ein Bildungszentrum – Tutorial zu COMP1551

Einführung in die Anwendungsentwicklung mit C#

Im Modul COMP1551 – Application Development steht die Entwicklung eines Desktop-Informationssystems für ein Bildungszentrum im Mittelpunkt. Du wirst eine C#-Konsolenanwendung schreiben, die Daten über Benutzergruppen (Lehrkräfte, Verwaltung, Studenten) verwaltet. Dieses Tutorial führt dich Schritt für Schritt durch die Kernkonzepte: Objektorientierte Programmierung (OOP), Vererbung, Polymorphie und Datenstrukturen – angewendet auf ein praxisnahes Szenario.

Stell dir vor, dein Bildungszentrum ist wie eine E-Sport-Liga: Jeder Spieler (Benutzer) hat eine Rolle (Teacher, Admin, Student), aber alle teilen Basisattribute wie Name und ID. Genau das bildest du mit einer Basisklasse Person und abgeleiteten Klassen ab.

1. Systembeschreibung und Anforderungsspezifikation (Teil 1)

Bevor du eine Zeile Code schreibst, musst du das System aus Benutzersicht beschreiben. In der Systembeschreibung (max. 300 Wörter) erklärst du, welche Funktionalität das Desktop-Informationssystem bietet, welche Daten verarbeitet werden und auf welcher Plattform es läuft (Microsoft Windows).

Die Software-Anforderungsspezifikation (SRS) (max. 500 Wörter) geht detaillierter auf Zweck, Umfang, Benutzer, Betriebsumgebung, funktionale Anforderungen, Performance, Sicherheit und Sicherheit ein. Orientiere dich an Wiegers & Beatty, „Software Requirements“, Kapitel 10–11.

Tipp: Nutze aktuelle Trends wie KI-gestützte Lernplattformen oder Gamification, um die Anforderungen lebendig zu beschreiben. Dein System könnte z. B. Rollen-basierte Zugriffsrechte wie in einer Online-Spiele-Plattform haben.

2. UML-Diagramme (Teil 2)

Die Designphase umfasst ein Klassendiagramm und ein Use-Case-Diagramm. Das Klassendiagramm zeigt die Basisklasse Person mit Attributen wie Name, Alter, Rolle und Methoden wie Anzeigen(). Die abgeleiteten Klassen Teacher, Admin und Student erben diese und fügen spezifische Eigenschaften hinzu (z. B. Fachbereich für Teacher).

Das Use-Case-Diagramm visualisiert, wie Benutzer mit dem System interagieren: Benutzer hinzufügen, anzeigen, bearbeiten, löschen und nach Rolle filtern. Verwende das Buch „UML 2.0 in Action“ von Patrick Grassle als Referenz.

3. Implementierung in C# (Teil 3)

Jetzt wird programmiert! Du erstellst eine einzelne .cs-Datei mit einer Konsolenanwendung. Die Struktur folgt dem MVC-ähnlichen Muster (Modell: Klassen, View: Konsolenausgabe, Controller: Menülogik).

3.1 Basisklasse Person

public class Person
{
    public string Name { get; set; }
    public int Alter { get; set; }
    public string Rolle { get; set; }

    public Person(string name, int alter, string rolle)
    {
        Name = name;
        Alter = alter;
        Rolle = rolle;
    }

    public virtual void Anzeigen()
    {
        Console.WriteLine($"Name: {Name}, Alter: {Alter}, Rolle: {Rolle}");
    }
}

3.2 Abgeleitete Klassen mit Polymorphie

public class Teacher : Person
{
    public string Fachbereich { get; set; }

    public Teacher(string name, int alter, string fachbereich)
        : base(name, alter, "Lehrkraft")
    {
        Fachbereich = fachbereich;
    }

    public override void Anzeigen()
    {
        base.Anzeigen();
        Console.WriteLine($"Fachbereich: {Fachbereich}");
    }
}

public class Admin : Person
{
    public string Abteilung { get; set; }

    public Admin(string name, int alter, string abteilung)
        : base(name, alter, "Verwaltung")
    {
        Abteilung = abteilung;
    }

    public override void Anzeigen()
    {
        base.Anzeigen();
        Console.WriteLine($"Abteilung: {Abteilung}");
    }
}

public class Student : Person
{
    public string Studiengang { get; set; }

    public Student(string name, int alter, string studiengang)
        : base(name, alter, "Student")
    {
        Studiengang = studiengang;
    }

    public override void Anzeigen()
    {
        base.Anzeigen();
        Console.WriteLine($"Studiengang: {Studiengang}");
    }
}

3.3 Datenstruktur: List<Person>

Verwende eine List<Person>, um eine unbekannte Anzahl von Objekten zu speichern. Dank Polymorphie kannst du alle abgeleiteten Typen in derselben Liste halten.

List<Person> personen = new List<Person>();

3.4 Textbasiertes Menü

Das Menü bietet Optionen zum Hinzufügen, Anzeigen (alle oder nach Rolle), Bearbeiten und Löschen. Hier ein Ausschnitt:

static void Main(string[] args)
{
    List<Person> personen = new List<Person>();
    bool beenden = false;

    while (!beenden)
    {
        Console.WriteLine("\n--- Desktop-Informationssystem ---");
        Console.WriteLine("1. Person hinzufügen");
        Console.WriteLine("2. Alle Personen anzeigen");
        Console.WriteLine("3. Personen nach Rolle anzeigen");
        Console.WriteLine("4. Person bearbeiten");
        Console.WriteLine("5. Person löschen");
        Console.WriteLine("6. Beenden");
        Console.Write("Wähle eine Option: ");
        string auswahl = Console.ReadLine();

        switch (auswahl)
        {
            case "1":
                PersonHinzufuegen(personen);
                break;
            case "2":
                AlleAnzeigen(personen);
                break;
            case "3":
                NachRolleAnzeigen(personen);
                break;
            case "4":
                PersonBearbeiten(personen);
                break;
            case "5":
                PersonLoeschen(personen);
                break;
            case "6":
                beenden = true;
                break;
            default:
                Console.WriteLine("Ungültige Eingabe.");
                break;
        }
    }
}

Die Methoden PersonHinzufuegen etc. fragt die spezifischen Daten ab und erzeugt das entsprechende Objekt. Vergiss nicht, Kommentare (ca. 30 % des Codes) einzufügen, die die Funktionalität erklären – das ist Teil der Bewertung.

4. Abgabekriterien und Tipps

• Dateiformat: Teil 1+2 als PDF, Teil 3 als einzelne .cs-Datei.
• Dateigröße: Maximal 100 MB.
• KI-Nutzung: Wenn du KI-generierte Inhalte verwendest, setze sie in Anführungszeichen und referenziere sie – sonst droht Plagiatsvorwurf.
• Verspätete Abgabe: Beachte die Regelungen der Universität.

Ein häufiger Fehler ist, die Polymorphie nicht zu nutzen: Rufe virtual Methoden auf der Basisklassen-Referenz auf, und die abgeleitete Implementierung wird ausgeführt. Teste dein Programm mit mindestens einem Objekt pro Rolle.

5. Trend-Beispiel: Gamification im Bildungszentrum

Stell dir vor, dein System verwaltet nicht nur Benutzer, sondern auch Erfolge (Achievements) wie in einer Gaming-Plattform. Ein Teacher könnte „Bester Kurs“-Abzeichen erhalten, ein Admin „Effizienteste Verwaltung“. Mit Vererbung könntest du eine weitere Klasse Achievement einführen und sie an Person anhängen. Solche Erweiterungen zeigen dein Verständnis für OOP.

Fazit

Mit diesem Tutorial hast du die Grundlagen für die COMP1551-Aufgabe gelegt: Systembeschreibung, SRS, UML-Diagramme und eine voll funktionsfähige C#-Konsolenanwendung mit Vererbung, Polymorphie und Datenstrukturen. Achte auf saubere Kommentare und die Einhaltung der Abgabeformate. Viel Erfolg!