Fehlerbehandlung & Logging

Jedes Skript kann Fehler machen – eine Datei fehlt, ein Ordner ist gesperrt, oder ein Benutzer hat nicht genug Rechte.
Wenn du diese Fehler nicht behandelst, bricht das Skript entweder mitten im Ablauf ab oder läuft weiter, obwohl etwas Wichtiges nicht geklappt hat.

Fehlerbehandlung sorgt dafür, dass dein Skript kontrolliert reagiert, statt einfach stehenzubleiben.
Logging wiederum speichert, was passiert ist – erfolgreich oder nicht – damit du oder andere später nachvollziehen können, was gelaufen ist.

Arten von Fehlern in PowerShell

PowerShell unterscheidet zwischen zwei Arten von Fehlern:

Nicht-terminierende Fehler:
Das Skript läuft weiter, auch wenn ein Problem auftritt. Beispiel: Get-Item kann eine Datei nicht lesen, aber die Schleife wird fortgesetzt.
Terminierende Fehler:
Der Fehler unterbricht die Ausführung – er kann mit try/catch abgefangen werden.

Viele Cmdlets erzeugen standardmäßig nicht-terminierende Fehler.
Du kannst aber selbst festlegen, dass sie als „kritisch“ behandelt werden sollen, indem du -ErrorAction Stop verwendest.

Beispiel: Unterschied zwischen „normalem“ und „Stop“-Fehler

# Standardverhalten – Skript läuft weiter
Get-Item "C:\nicht\da.txt"

# Mit Stop: Skript springt in den Fehlerblock
Get-Item "C:\nicht\da.txt" -ErrorAction Stop

Wenn du in einem Skript arbeitest, ist die zweite Variante sinnvoll, weil du den Fehler gezielt abfangen kannst.

Der Befehl try / catch

Das Grundprinzip ist einfach:

Im try-Block steht der Code, der schiefgehen könnte.
Im catch-Block steht, was im Fehlerfall passieren soll.

Beispiel:

try {
    Get-Content "C:\nichtda.txt" -ErrorAction Stop
    Write-Host "Datei erfolgreich gelesen."
}
catch {
    Write-Host "Es ist ein Fehler aufgetreten: $($_.Exception.Message)"
}

PowerShell probiert den try-Block.
Wenn etwas schiefgeht, springt es direkt in catch und gibt dort deine definierte Meldung aus.
$_.Exception.Message enthält die eigentliche Fehlermeldung (z. B. „Datei nicht gefunden“).

Der Block finally

Manchmal möchtest du am Ende immer etwas ausführen, egal ob ein Fehler passiert oder nicht – etwa um eine Verbindung zu schließen oder eine Logdatei zu schreiben.
Dafür gibt es den finally-Block.

try {
    Get-Content "C:\nichtda.txt" -ErrorAction Stop
}
catch {
    Write-Host "Fehler: $($_.Exception.Message)"
}
finally {
    Write-Host "Skript wurde beendet (egal ob Erfolg oder Fehler)."
}

Wie du den Fehler genau untersuchen kannst

Innerhalb von catch steht der aktuelle Fehler immer in der automatischen Variable $_.
Darin steckt ein komplettes Objekt mit allen Informationen – Typ, Nachricht, Zeilennummer usw.

Du kannst sie so ausgeben:

catch {
    $fehler = $_.Exception
    Write-Host "Fehlerart: $($fehler.GetType().Name)"
    Write-Host "Nachricht: $($fehler.Message)"
}

Das ist besonders hilfreich beim Debuggen oder wenn du Fehler später ins Log schreiben willst.

Der Unterschied zwischen `$Error` und `$?`

PowerShell merkt sich jeden Fehler in der globalen Variable $Error (die letzten Fehler stehen dort als Liste).
Mit $? kannst du direkt nach einem Befehl prüfen, ob er erfolgreich war.

Get-Item "C:\nichtda.txt"
$?         # gibt False zurück
$Error[0]  # zeigt den letzten Fehler

Diese Technik ist nützlich, wenn du einfache Skripte schreibst und keinen try/catch brauchst.

Fehler erzwingen oder unterdrücken

Manchmal willst du bewusst eine bestimmte Reaktion steuern:

# Fehler unterdrücken
Get-Item "C:\nichtda.txt" -ErrorAction SilentlyContinue

# Fehler erzwingen
Get-Item "C:\nichtda.txt" -ErrorAction Stop

Oder du kannst mit $ErrorActionPreference das Standardverhalten für dein ganzes Skript ändern:

$ErrorActionPreference = "Stop"

Damit wird jeder Fehler wie ein „kritischer“ Fehler behandelt.

Eigene Fehler auslösen

Du kannst mit throw selbst Fehler erzeugen, um z. B. falsche Eingaben abzufangen.

function Berechne-Steuer {
    param([double]$Betrag)

    if ($Betrag -lt 0) {
        throw "Ungültiger Betrag: darf nicht negativ sein."
    }

    return $Betrag * 0.19
}

Wenn jemand Berechne-Steuer -Betrag -50 eingibt, löst PowerShell deinen eigenen Fehler aus.

Logging – was passiert wann?

Fehlerbehandlung kümmert sich um den Ablauf.
Logging kümmert sich darum, was du davon aufzeichnen willst.

Du kannst Logs auf verschiedene Arten schreiben:

Variante 1: Einfache Textdatei

Add-Content -Path "$HOME\ps_log.txt" -Value "[$(Get-Date)] Start des Skripts"

Variante 2: Automatisches Protokoll (Transcript)

Mit Start-Transcript kannst du automatisch alles mitschneiden, was in der Konsole passiert:

Start-Transcript -Path "$HOME\Transkript.txt"
# beliebiger Code
Stop-Transcript

Variante 3: Eigene Logfunktion

Erstelle eine kleine Hilfsfunktion, die sauber formatierte Einträge schreibt:

function Write-Log {
    param(
        [string]$Text,
        [string]$Level = "INFO",
        [string]$Datei = "$HOME\PowerShell.log"
    )
    $zeile = "[{0:yyyy-MM-dd HH:mm:ss}] [{1}] {2}" -f (Get-Date), $Level, $Text
    Add-Content -Path $Datei -Value $zeile
}

Jetzt kannst du überall im Skript so loggen:

Write-Log -Text "Backup gestartet"
Write-Log -Text "Datei nicht gefunden" -Level "ERROR"

Alles zusammen: Beispiel eines robusten Skripts

function Backup-Dateien {
    param(
        [string]$Quelle,
        [string]$Ziel
    )

    try {
        Write-Log -Text "Starte Backup von $Quelle nach $Ziel"

        if (-not (Test-Path $Quelle)) {
            throw "Quellverzeichnis existiert nicht: $Quelle"
        }

        if (-not (Test-Path $Ziel)) {
            New-Item -Path $Ziel -ItemType Directory | Out-Null
        }

        Copy-Item -Path "$Quelle\*" -Destination $Ziel -Recurse -Force -ErrorAction Stop
        Write-Log -Text "Backup erfolgreich abgeschlossen."
    }
    catch {
        Write-Log -Text "Fehler beim Backup: $($_.Exception.Message)" -Level "ERROR"
    }
    finally {
        Write-Log -Text "Backup-Vorgang beendet."
    }
}

Wenn du das Skript ausführst, bekommst du am Ende im Log eine lückenlose Übersicht, was passiert ist – inklusive Fehlermeldung, falls etwas nicht funktioniert hat.