• Htw
  • Anleitung zur Prüfungsgruppenanmeldung
• Programming
  • Zahlensysteme und Zeichendarstellung
  • Objektorientierte Programmierung
  • Programmieren 1
  • Programmierung und Tic-Tac-Toe
  • Was sind Web APIs?
  • Abstract
    • Jeder kann coden
    • Jeder kann coden
  • Cmdline
    • Bash
    • 💡 Erstes Skript & sandbox
    • Navigation durch den Verzeichnisbaum
    • Howtos
    • Linux-Skript zur Systeminformationenserfassung
    • Kommandozeile
  • Csharp
    • Csharp_introduction
      • Arrays in C#
      • Komplexere Datenstrukturen
      • Bedingte Anweisungen
      • Prozeduren und Funktionen
      • Schleifen
      • Operatoren
      • Mit Strings arbeiten
      • Das Konzept einer Variablen
    • Einführung in C#
    • Eisbrecher
    • Framework
      • Exceptions
      • Dateioperationen in C#
      • .NET System.Random
      • Reguläre Ausdrücke
      • Wpf
        • Einführung in die Grundlagen von WPF und C#
        • Data Binding mit WPF und C#
    • Oop
      • Zugriffsmodifizierer in C#
      • Grundlagen der objektorientierten Programmierung (OOP) in C#
      • Objektorientierte Programmierung in C# Samples
      • 💡 Vergleich von Objekten
      • Konstruktoren in C#
      • Beispiel: Spielfeldmanagement in C#
      • Properties (Attribute) in C#
    • Procedural-functional
      • Arrays in C#
      • Grundlagen Boolesche Operatoren
      • Bedingte Anweisungen in C#
      • Bedingte Anweisungen & TicTacToe
      • Enums in C#
      • C# - Struktur eines Programms
      • Schleifen in C#
      • Schleifen & TicTacToe
      • Prozeduren, Funktionen und Methoden in C#
      • Numerische Gleitkomma-Typen
      • Ganzzahlige numerische Typen
      • Grundlagen weiterer Operatoren
      • Referenztypen und Werttypen in C#
      • String Typen in C#
      • Structs in C#
      • Grundlagen C# ReadLine
      • Grundlagen C# WriteLine
      • C# WriteLine Samples
      • C# WriteLine & TicTacToe
    • Tools
      • Debugger und Breakpoints
      • Entwicklungswerkzeuge für Programmierung
• Tools
  • Quellcodeverwaltung mit GIT
  • Visual Studio für Mac ist tot – was nun?

Jeder kann coden / Programmieren & TicTacToe / C# Einführung

Debugger und Breakpoints

Link zum roten Faden auf Miro

Debugger

• Tool, um Fehler im Code zu finden und zu beheben.
• Ermöglicht:
  • Schrittweise Ausführung (Zeile für Zeile).
  • Überprüfung von Variablenwerten.
  • Analyse des Call-Stacks.
  • Testen von Ausdrücken.
  • Identifikation von Fehlerstellen.

Breakpoint

• Markierung im Code, an der die Ausführung stoppt.
• Funktionen:
  • Programm anhalten, um Variablen und Abläufe zu prüfen.
  • Bedingungen für das Anhalten definieren (z. B. x == 10).
  • Ausnahmen fangen und analysieren.

---

Debuggen in Visual Studio Code

1. Breakpoint setzen: Klicke links neben die Zeilennummer (roter Punkt erscheint).
2. Start: Drücke F5 oder klicke auf Start Debugging.
3. Steuerung:
   • Weiter: F5 (bis nächster Breakpoint).
   • Step Over: F10 (aktuelle Zeile ausführen).
   • Step Into: F11 (in Methode springen).
   • Step Out: Shift+F11 (Methode verlassen).
4. Überprüfung: Werte im Debug-Fenster analysieren.

---

Debuggen in Visual Studio

1. Breakpoint setzen: Klicke links von der Zeilennummer oder wähle Breakpoint.
2. Optionen: Bedingungen und Hit Counts einstellen.
3. Start: Drücke F5 (Debug starten).
4. Weitere Tools:
   • Watches: Variablen/Ausdrücke überwachen.
   • Locals & Autos: Lokale und kürzlich genutzte Variablen.
   • Immediate Window: Ausdrücke testen.

Nochmal zum Nachlesen...

Ein Debugger ist ein Tool, das Dir dabei hilft, Fehler im Code zu finden und zu beheben. Damit kannst Du den Code schrittweise durchgehen und den Zustand des Programms sowie die Werte von Variablen während der Laufzeit überprüfen. Der Debugger ist besonders nützlich, wenn es darum geht, komplexe Fehler zu verstehen und gezielt zu lösen.

Wie funktioniert ein Debugger?

Im Debugging-Modus läuft Dein Programm nicht wie gewohnt, sondern wird so gesteuert, dass Du es jederzeit anhalten und untersuchen kannst. Hier sind einige Dinge, die Du mit einem Debugger machen kannst:

1. Schrittweise Ausführung: Du kannst den Code Zeile für Zeile durchlaufen und sehen, was passiert.
2. Variablen-Überprüfung: Du kannst die aktuellen Werte von Variablen sehen und nachvollziehen, wie sie sich ändern.
3. Ausdrucksauswertung: Der Debugger erlaubt Dir, Berechnungen oder Ausdrücke direkt zu testen.
4. Call Stack und Rückverfolgung: Du kannst sehen, welche Funktionen oder Methoden aufgerufen wurden, um zur aktuellen Stelle zu gelangen.
5. Fehlermeldungen und Ausnahmen: Der Debugger zeigt Dir die genaue Stelle im Code, an der ein Fehler oder eine Ausnahme aufgetreten ist.

Was ist ein Breakpoint?

Ein Breakpoint ist ein Punkt im Code, an dem die Programmausführung stoppt, sobald der Debugger aktiv ist. Mit Breakpoints kannst Du das Programm an einer bestimmten Stelle anhalten, um zu überprüfen, was bis dahin passiert ist.

Einige Dinge, die Du mit Breakpoints tun kannst:

• Den Wert von Variablen zu einem bestimmten Zeitpunkt beobachten.
• Den Ablauf des Programms an bestimmten Stellen stoppen.
• Bedingungen setzen, unter denen das Programm anhält (z. B. nur, wenn eine Variable einen bestimmten Wert hat).
• Ausnahmen abfangen und die Fehlerquelle finden.

Debuggen in Visual Studio Code für C#

In Visual Studio Code gibt es eine Debugging-Erweiterung für .NET (C#), die Dir das Debuggen von C#-Code ermöglicht. Hier ist ein Leitfaden für das Debuggen und die Verwendung von Breakpoints:

1. Breakpoints setzen:

   • Öffne die Datei, die Du debuggen möchtest.
   • Klicke links neben die Zeilennummer, um einen roten Punkt zu setzen, der den Breakpoint markiert.

2. Debugging starten:

   • Drücke F5 oder klicke auf Start Debugging in der Debug-Symbolleiste.
   • Visual Studio Code startet das Programm und stoppt an Deinem ersten Breakpoint.

3. Debugging-Steuerung:

   • Weiter (Continue): Setzt die Ausführung bis zum nächsten Breakpoint fort (F5).
   • Schrittweise Ausführung (Step Over): Führt die aktuelle Zeile aus, ohne in eine Funktion hineinzuspringen (F10).
   • Schritt in (Step Into): Tritt in die Methode oder Funktion ein, falls es sich um einen Aufruf handelt (F11).
   • Schritt zurück (Step Out): Verlasse die aktuelle Methode und kehre zur aufrufenden Methode zurück (Shift+F11).

4. Variablen und Ausdrücke überprüfen:

   • Im Debug-Fenster kannst Du die aktuellen Variablen und ihre Werte sehen.
   • Du kannst auch eigene Ausdrücke hinzufügen und überwachen.
   • Im Call Stack siehst Du, wie die Methoden aufgerufen wurden.

Debuggen in Visual Studio für C#

Visual Studio bietet eine umfangreiche Debugging-Umgebung mit vielen hilfreichen Funktionen. So nutzt Du den Debugger und Breakpoints in Visual Studio:

1. Breakpoints setzen:

   • Öffne den Code und klicke links von der Zeilennummer auf die graue Leiste, um einen Breakpoint zu setzen, oder klicke mit der rechten Maustaste und wähle Breakpoint aus.

2. Erweiterte Breakpoint-Optionen:

   • Bedingte Breakpoints: Setze Bedingungen, wann der Breakpoint ausgelöst wird (z. B. x == 10).
   • Hit Count Breakpoints: Der Breakpoint wird nur ausgelöst, wenn eine bestimmte Anzahl an Treffern erreicht ist.
   • Logische Ausdrücke: Füge komplexere Bedingungen hinzu, um gezielt anzuhalten.

3. Debugging starten:

   • Klicke auf Start Debugging oder drücke F5.
   • Dein Programm stoppt am ersten Breakpoint, und Du kannst den Code untersuchen.

4. Zusätzliche Debugging-Funktionen:

   • Watches: Beobachte Variablen und Ausdrücke im Watch-Fenster.
   • Locals und Autos: Im Locals-Fenster siehst Du alle lokalen Variablen, und Autos zeigt Variablen an, die kürzlich verwendet wurden.
   • Immediate Window: Hier kannst Du Ausdrücke testen und Ergebnisse sofort sehen.

5. Debugging beenden oder fortsetzen:

   • Du kannst jederzeit das Debuggen beenden oder fortsetzen.
   • Mit Continue (F5) läuft das Programm weiter bis zum nächsten Breakpoint oder bis zur Fertigstellung.

Tipps für effektives Debuggen

1. Bedingte Breakpoints nutzen: So stoppst Du das Programm nur unter bestimmten Bedingungen.
2. Variablen und den Call Stack analysieren: Das hilft, den Zustand des Programms und die Ursache für Fehler zu verstehen.
3. Watches und Immediate Window verwenden: Damit kannst Du Variablen gezielt beobachten und Code testen.
4. Schrittweise vorgehen: Setze Dir beim Debuggen klare Ziele, um die Fehlerquelle schneller zu finden.

Mit diesen Werkzeugen und Tipps kannst Du den Debugger in Visual Studio Code und Visual Studio optimal nutzen, um Fehler in Deinem C#-Code zu beheben.