C# Grundlagen

Das lernst du

• Code, Ausgabe und Fehler verstehen.
• Daten sinnvoll speichern.
• Regeln ausdrücken.
• Wiederholung kontrollieren.
• Mehrere Werte organisieren.
• Code in Teile zerlegen.
• Dynamische Daten und Eingaben.
• Daten und Verhalten modellieren.
• Zustände und Regeln beherrschen.
• Vorhaben planen und umsetzen.
• Vertiefung der Sprachfeatures.
• Daten persistent speichern.
• Nicht-blockierender Code.
• Code automatisch prüfen.
• Code skalierbar organisieren.
• Komplexe Anwendung entwickeln.

Kursinhalt

1. Kapitel 1 Dein erstes Programm

   Code, Ausgabe und Fehler verstehen.

   1. Code und Run
   2. Hello World
   3. Mehrere Ausgaben
   4. Kommentare
   5. Fehlersuche
   6. Vorstellung
   7. Struktur
   8. Projektstart

2. Kapitel 2 Werte und Typen

   Daten sinnvoll speichern.

   1. Ganze Zahlen
   2. Text
   3. Kombination
   4. Wahr/Falsch
   5. Typinferenz
   6. Charakterkarte
   7. Typumwandlung
   8. Datenmodell

3. Kapitel 3 Rechnen und Entscheiden

   Regeln ausdrücken.

   1. Rechnen
   2. Vergleiche
   3. If-Else
   4. Else If
   5. Logik
   6. Rabattregeln
   7. Switch
   8. Entscheidungsbaum

4. Kapitel 4 Schleifen

   Wiederholung kontrollieren.

   1. For-Schleife
   2. While-Schleife
   3. Endlosschleifen
   4. Break/Continue
   5. Verschachtelung
   6. Simulation
   7. Do-While
   8. Rundensystem

5. Kapitel 5 Arrays und Daten

   Mehrere Werte organisieren.

   1. Arrays anlegen
   2. Index
   3. Werte ändern
   4. Foreach
   5. Statistik
   6. Inventar
   7. Mehrdimensionale Arrays
   8. Datenanalyse

6. Kapitel 6 Methoden

   Code in Teile zerlegen.

   1. Erste Methode
   2. Parameter
   3. Rückgabewerte
   4. Gültigkeit
   5. Randfälle
   6. Refactoring
   7. Überladung
   8. Strukturierte Simulation

7. Kapitel 7 Sammlungen und Eingaben

   Dynamische Daten und Eingaben.

   1. Listen
   2. Elemente
   3. Dictionaries
   4. Parsing
   5. Fehlersichere Eingabe
   6. Bestandsverwaltung
   7. LINQ-Grundlagen
   8. Daten-Tool

8. Kapitel 8 Klassen und Objekte

   Daten und Verhalten modellieren.

   1. Klasse vs Objekt
   2. Felder
   3. Konstruktoren
   4. Properties
   5. Methoden
   6. Spielermodell
   7. Vererbung
   8. Objekt-System

9. Kapitel 9 Klarer und zuverlässiger Code

   Zustände und Regeln beherrschen.

   1. Benennung
   2. Enums
   3. Null
   4. Testfälle
   5. Debugging
   6. Zustandsmodell
   7. Interfaces
   8. Robustes System

10. Kapitel 10 Dein eigenes Projekt

    Vorhaben planen und umsetzen.

    1. Planung
    2. Datenmodell
    3. Kernlogik
    4. Fehlerbehandlung
    5. Refactoring
    6. Dokumentation
    7. Erweiterung
    8. Abschluss

11. Kapitel 11 Erweiterte Konzepte

    Vertiefung der Sprachfeatures.

    1. Delegates
    2. Events
    3. Generics
    4. Extension Methods
    5. Lambda
    6. LINQ-Vertiefung
    7. Exceptions
    8. Framework-Nutzung

12. Kapitel 12 Dateiverarbeitung

    Daten persistent speichern.

    1. Dateisystem
    2. Lesen
    3. Schreiben
    4. CSV-Format
    5. JSON-Serialisierung
    6. Fehlersicheres IO
    7. Daten-Migration
    8. Datenbank-Simulation

13. Kapitel 13 Asynchronität

    Nicht-blockierender Code.

    1. Threads
    2. Tasks
    3. Async/Await
    4. Wartezeiten
    5. Fehler in Tasks
    6. Parallele Daten
    7. CancellationToken
    8. Async-Projekt

14. Kapitel 14 Unit Testing

    Code automatisch prüfen.

    1. Test-Grundlagen
    2. Asserts
    3. Test-Methoden
    4. Test-Daten
    5. Mocking
    6. TDD-Ansatz
    7. Coverage
    8. Test-Suite

15. Kapitel 15 Architektur-Grundlagen

    Code skalierbar organisieren.

    1. SOLID-Prinzipien
    2. Dependency Injection
    3. Namespaces
    4. Design Patterns
    5. Refactoring-Techniken
    6. Modularisierung
    7. Code-Review
    8. Architektur-Projekt

16. Kapitel 16 Abschluss-Projekt

    Komplexe Anwendung entwickeln.

    1. Anforderungsanalyse
    2. Architektur-Design
    3. Implementierung I
    4. Implementierung II
    5. Testing
    6. Dokumentation
    7. Refactoring
    8. Präsentation

So funktioniert jede Lektion

Keine stundenlangen Videos. Jede Lektion ist eine kurze Runde, die du selbst machst, bis die Idee sitzt.

1. Lesen

   Eine kurze Erklärung und eine klare Aufgabe. Gerade genug, um loszulegen.

2. Schreiben

   Du tippst den Code selbst, in einem echten Editor direkt im Browser.

3. Ausführen

   Führ ihn aus und sieh sofort, was dein Programm wirklich tut.

4. Prüfen

   Prüfen sagt dir, ob die Aufgabe gelöst ist, und was noch fehlt, falls nicht.

Gut zu wissen

• Keine Installation: Editor, Ausgabe und Prüfung laufen in deinem Browser-Tab.
• Ohne Konto als Gast starten; dein Fortschritt bleibt auf diesem Gerät.
• Ein kostenloses Ostrae-Konto synchronisiert Fortschritt und Einstellungen und schaltet den Coach MICA frei.
• Du schreibst echte C#-Syntax. Im Browser läuft sie auf einem vereinfachten C#-Interpreter, nicht auf einem vollständigen .NET-Compiler. So bleibt alles schnell und ohne Installation.

Weitere Kurse

• HTML: Websites strukturieren
• CSS: Websites gestalten
• JavaScript
• Python Grundlagen und Automatisierung
• Git, GitHub und Hosting
• Design für Entwickler
• GSAP Animationen