Zum Inhalt springen

Powershell - Fehlerbehandlung

Aus Gerhards Wiki

Dauer: 4 Stunden

Voraussetzungen: Kurs 1-5 abgeschlossen

Lernziele:

  • Du verstehst Fehlertypen in PowerShell
  • Du verwendest Try-Catch-Finally effektiv
  • Du steuerst Fehlerverhalten mit ErrorAction
  • Du implementierst eigene Fehlerbehandlung
  • Du debuggst Skripte systematisch
  • Du erstellst robuste, produktionsreife Skripte

Modul 6.1: Fehlertypen verstehen

[Bearbeiten | Quelltext bearbeiten]

Terminating vs. Non-Terminating Errors

[Bearbeiten | Quelltext bearbeiten]

PowerShell kennt zwei Haupttypen von Fehlern:

Typ Verhalten Beispiel Try-Catch?
Terminating Stoppt Ausführung sofort Division durch Null Ja
Non-Terminating Fehler anzeigen, weiter Get-Item für nicht existierende Datei Nein (außer mit -ErrorAction Stop)
# Terminating Error - stoppt sofort
function Test-Terminating {
    Write-Host "Vor dem Fehler"
    $zahl = 1 / 0  # Division durch Null
    Write-Host "Nach dem Fehler"  # Wird nicht ausgeführt
}

Test-Terminating

# Non-Terminating Error - läuft weiter
function Test-NonTerminating {
    Write-Host "Vor dem Fehler"
    Get-Item "C:\GibtEsNicht.txt"  # Fehler, aber weiter
    Write-Host "Nach dem Fehler"  # Wird ausgeführt!
}

Test-NonTerminating
ℹ️
Hinweis
Die meisten PowerShell-Cmdlets erzeugen Non-Terminating Errors standardmäßig!

$Error Variable

[Bearbeiten | Quelltext bearbeiten]

PowerShell speichert alle Fehler in der automatischen Variable $Error:

# Letzter Fehler
$Error[0]

# Alle Fehler anzeigen
$Error

# Anzahl der Fehler
$Error.Count

# Fehlerdetails
$Error[0] | Format-List *

# Fehler-Verlauf leeren
$Error.Clear()

# Fehler-Eigenschaft
$Error[0].Exception.Message
$Error[0].CategoryInfo
$Error[0].FullyQualifiedErrorId

$? und $LASTEXITCODE

[Bearbeiten | Quelltext bearbeiten]
# $? - War der letzte Befehl erfolgreich?
Get-Process
$?  # True

Get-Process -Name "GibtEsNicht"
$?  # False

# $LASTEXITCODE - Exit-Code externer Programme
ping localhost
$LASTEXITCODE  # 0 = Erfolg

ping 999.999.999.999
$LASTEXITCODE  # 1 = Fehler

Modul 6.2: Try-Catch-Finally

[Bearbeiten | Quelltext bearbeiten]

Grundlegende Try-Catch-Struktur

[Bearbeiten | Quelltext bearbeiten]
# Einfaches Try-Catch
try {
    # Code, der fehlschlagen könnte
    $inhalt = Get-Content "C:\GibtEsNicht.txt" -ErrorAction Stop
    Write-Host "Datei gelesen"
} catch {
    # Fehlerbehandlung
    Write-Host "Fehler aufgetreten: $($_.Exception.Message)" -ForegroundColor Red
}

Write-Host "Skript läuft weiter"
⚠️
Warnung
Try-Catch fängt nur Terminating Errors! Verwende -ErrorAction Stop für Cmdlets.

Der Finally-Block wird immer ausgeführt, egal ob Fehler oder nicht:

$datei = $null

try {
    Write-Host "Öffne Datei..."
    $datei = [System.IO.File]::Open("C:\test.txt", "Open", "Read")
    $inhalt = $datei.ReadToEnd()
    Write-Host "Datei gelesen"
    
} catch {
    Write-Host "Fehler: $($_.Exception.Message)" -ForegroundColor Red
    
} finally {
    # Aufräumen - wird immer ausgeführt!
    if ($null -ne $datei) {
        $datei.Close()
        $datei.Dispose()
        Write-Host "Datei geschlossen"
    }
}

Fehler-Objekt analysieren

[Bearbeiten | Quelltext bearbeiten]

Das automatische $_ Variable enthält im Catch-Block den Fehler:

try {
    Get-Content "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
    Write-Host "=== Fehler-Details ===" -ForegroundColor Red
    Write-Host "Nachricht: $($_.Exception.Message)"
    Write-Host "Typ: $($_.Exception.GetType().FullName)"
    Write-Host "Zeile: $($_.InvocationInfo.ScriptLineNumber)"
    Write-Host "Befehl: $($_.InvocationInfo.Line.Trim())"
    Write-Host "Kategorie: $($_.CategoryInfo.Category)"
}

Mehrere Catch-Blöcke

[Bearbeiten | Quelltext bearbeiten]

Fange verschiedene Fehlertypen unterschiedlich ab:

try {
    $zahl = [int]"keine zahl"
    
} catch [System.FormatException] {
    Write-Host "Formatierungs-Fehler: Ungültige Zahl" -ForegroundColor Yellow
    
} catch [System.IO.IOException] {
    Write-Host "Datei-/IO-Fehler" -ForegroundColor Red
    
} catch [System.UnauthorizedAccessException] {
    Write-Host "Zugriff verweigert" -ForegroundColor Red
    
} catch {
    # Alle anderen Fehler
    Write-Host "Unbekannter Fehler: $($_.Exception.GetType().FullName)" -ForegroundColor Red
    Write-Host $_.Exception.Message
}

Verschachtelte Try-Catch

[Bearbeiten | Quelltext bearbeiten]
try {
    Write-Host "Äußerer Try-Block"
    
    try {
        Write-Host "Innerer Try-Block"
        Get-Content "C:\Fehler.txt" -ErrorAction Stop
        
    } catch {
        Write-Host "Innerer Catch: $($_.Exception.Message)" -ForegroundColor Yellow
        throw  # Fehler nach außen weitergeben
    }
    
} catch {
    Write-Host "Äußerer Catch: $($_.Exception.Message)" -ForegroundColor Red
}

Modul 6.3: ErrorAction Parameter

[Bearbeiten | Quelltext bearbeiten]

ErrorAction Optionen

[Bearbeiten | Quelltext bearbeiten]

Steuert, wie Cmdlets mit Fehlern umgehen:

Wert Verhalten Verwendung
Continue Fehler anzeigen, weiter (Standard) Normal
Stop Als Terminating Error behandeln Für Try-Catch
SilentlyContinue Fehler unterdrücken, weiter Optionale Operationen
Ignore Vollständig ignorieren Unwichtige Fehler
Inquire Benutzer fragen Interaktive Skripte
Suspend Workflow pausieren Nur Workflows
# Standard (Continue) - Fehler anzeigen
Get-Item "C:\GibtEsNicht.txt"
Write-Host "Läuft weiter"

# Stop - Für Try-Catch
try {
    Get-Item "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
    Write-Host "Gefangen!"
}

# SilentlyContinue - Fehler unterdrücken
$datei = Get-Item "C:\GibtEsNicht.txt" -ErrorAction SilentlyContinue
if ($null -eq $datei) {
    Write-Host "Datei nicht gefunden"
}

# Ignore - Auch $Error wird nicht befüllt
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Ignore

# Inquire - Benutzer fragen
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Inquire

$ErrorActionPreference

[Bearbeiten | Quelltext bearbeiten]

Globale Einstellung für ErrorAction:

# Standard-Wert anzeigen
$ErrorActionPreference  # Continue

# Temporär ändern
$ErrorActionPreference = "Stop"

# Alle Fehler werden zu Terminating Errors
try {
    Get-Item "C:\GibtEsNicht.txt"  # Keine -ErrorAction nötig!
} catch {
    Write-Host "Gefangen durch Preference!"
}

# Zurücksetzen
$ErrorActionPreference = "Continue"
💡
Tipp
Verwende -ErrorAction Stop punktuell statt $ErrorActionPreference global zu ändern!

Speichere Fehler in eigener Variable:

# Fehler in Variable sammeln
Get-ChildItem C:\Windows, C:\GibtEsNicht, C:\Temp -ErrorAction SilentlyContinue -ErrorVariable fehler

# Fehler analysieren
Write-Host "Anzahl Fehler: $($fehler.Count)"
foreach ($f in $fehler) {
    Write-Host "Fehler: $($f.Exception.Message)"
}

# Mit + anhängen statt überschreiben
Get-Item "C:\Fehler1.txt" -ErrorAction SilentlyContinue -ErrorVariable fehler
Get-Item "C:\Fehler2.txt" -ErrorAction SilentlyContinue -ErrorVariable +fehler
Write-Host "Gesamt: $($fehler.Count) Fehler"

Modul 6.4: Eigene Fehler werfen

[Bearbeiten | Quelltext bearbeiten]

Wirft einen Terminating Error:

function Divide-Number {
    param(
        [int]$zaehler,
        [int]$nenner
    )
    
    if ($nenner -eq 0) {
        throw "Division durch Null ist nicht erlaubt!"
    }
    
    return $zaehler / $nenner
}

try {
    Divide-Number -zaehler 10 -nenner 0
} catch {
    Write-Host "Fehler gefangen: $_" -ForegroundColor Red
}

Erzeugt Non-Terminating Error:

function Test-File {
    param([string]$path)
    
    if (-not (Test-Path $path)) {
        Write-Error "Datei nicht gefunden: $path"
        return $false
    }
    
    Write-Host "Datei existiert"
    return $true
}

# Non-Terminating - läuft weiter
Test-File "C:\GibtEsNicht.txt"
Write-Host "Skript läuft weiter"

# Mit ErrorAction Stop für Try-Catch
try {
    Test-File "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
    Write-Host "Gefangen!"
}

Eigene Exception-Objekte

[Bearbeiten | Quelltext bearbeiten]
function Connect-Database {
    param(
        [string]$server,
        [int]$timeout = 30
    )
    
    # Simuliere Verbindungsversuch
    $erfolg = $false
    
    if (-not $erfolg) {
        # Eigene Exception erstellen
        $exception = New-Object System.InvalidOperationException(
            "Verbindung zu $server fehlgeschlagen nach $timeout Sekunden"
        )
        
        $errorRecord = New-Object System.Management.Automation.ErrorRecord(
            $exception,
            "DatabaseConnectionFailed",
            [System.Management.Automation.ErrorCategory]::ConnectionError,
            $server
        )
        
        throw $errorRecord
    }
}

try {
    Connect-Database -server "SQL01" -timeout 10
} catch {
    Write-Host "Kategorie: $($_.CategoryInfo.Category)"
    Write-Host "ErrorID: $($_.FullyQualifiedErrorId)"
    Write-Host "Nachricht: $($_.Exception.Message)"
}

Throw vs. Write-Error - Wann was?

[Bearbeiten | Quelltext bearbeiten]
function Process-Data {
    param($data)
    
    # Kritischer Fehler - Funktion kann nicht fortfahren
    if ($null -eq $data) {
        throw "Daten dürfen nicht null sein!"
    }
    
    # Nicht-kritischer Fehler - Warnung, aber weiter
    if ($data.Length -eq 0) {
        Write-Error "Daten sind leer"
        # Könnte mit leeren Daten weiterarbeiten
    }
    
    # Verarbeitung...
}
ℹ️
Hinweis
Verwende throw für kritische Fehler, Write-Error für nicht-kritische Warnungen.

Modul 6.5: Trap-Anweisung

[Bearbeiten | Quelltext bearbeiten]

Trap ist eine ältere Fehlerbehandlung (vor Try-Catch). Funktioniert wie globaler Catch:

# Trap definieren
trap {
    Write-Host "Fehler gefangen in Trap: $_" -ForegroundColor Red
    continue  # Oder: break
}

# Code mit potentiellen Fehlern
Write-Host "Vor Fehler"
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Stop
Write-Host "Nach Fehler"  # Wird ausgeführt mit 'continue'
# Spezifische Traps
trap [System.IO.IOException] {
    Write-Host "IO-Fehler: $_" -ForegroundColor Yellow
    continue
}

trap [System.UnauthorizedAccessException] {
    Write-Host "Zugriff verweigert: $_" -ForegroundColor Red
    break
}

trap {
    Write-Host "Allgemeiner Fehler: $_"
    continue
}

# Code...
💡
Tipp
Bevorzuge Try-Catch gegenüber Trap für moderneren, besser lesbaren Code!

Modul 6.6: Debugging

[Bearbeiten | Quelltext bearbeiten]

Write-Verbose und Write-Debug

[Bearbeiten | Quelltext bearbeiten]
function Get-Data {
    [CmdletBinding()]
    param(
        [string]$name
    )
    
    Write-Verbose "Starte Datenabfrage für: $name"
    Write-Debug "Debug: Name-Länge = $($name.Length)"
    
    # Simuliere Verarbeitung
    Start-Sleep -Milliseconds 500
    
    Write-Verbose "Datenabfrage abgeschlossen"
    
    return "Daten für $name"
}

# Verbose-Ausgabe aktivieren
Get-Data -name "Test" -Verbose

# Debug-Ausgabe aktivieren (Prompt für Fortsetzung)
Get-Data -name "Test" -Debug

# Preference-Variablen
$VerbosePreference = "Continue"  # Verbose immer anzeigen
$DebugPreference = "Continue"    # Debug immer anzeigen

Erweiterte Debug-Funktionen:

# Trace einschalten - zeigt jede Zeile
Set-PSDebug -Trace 1

# Code ausführen
$a = 10
$b = 20
$c = $a + $b

# Trace ausschalten
Set-PSDebug -Trace 0

# Strict Mode - findet uninitialisierte Variablen
Set-PSDebug -Strict
$undef  # Fehler!

# Ausschalten
Set-PSDebug -Off

Empfohlene Alternative zu Set-PSDebug -Strict:

# Version 1.0 - Grundlegende Prüfungen
Set-StrictMode -Version 1.0

# Nicht initialisierte Variable
$test  # Fehler!

# Version 2.0 - Zusätzliche Prüfungen
Set-StrictMode -Version 2.0

# Nicht existierende Eigenschaft
$obj = New-Object PSObject
$obj.NichtVorhanden  # Fehler!

# Version Latest - Neueste Prüfungen
Set-StrictMode -Version Latest

# In Funktionen verwenden
function Test-StrictFunction {
    Set-StrictMode -Version Latest
    
    # Hier gelten strikte Regeln
    $var  # Fehler wenn nicht initialisiert
}
# Zeilen-Breakpoint
Set-PSBreakpoint -Script "C:\Scripts\Test.ps1" -Line 15

# Variable-Breakpoint - stoppt bei Änderung
Set-PSBreakpoint -Variable "count" -Mode Write

# Befehl-Breakpoint
Set-PSBreakpoint -Command "Get-Process"

# Alle Breakpoints anzeigen
Get-PSBreakpoint

# Breakpoint deaktivieren
Disable-PSBreakpoint -Id 1

# Breakpoint löschen
Remove-PSBreakpoint -Id 1

# Alle löschen
Get-PSBreakpoint | Remove-PSBreakpoint
💡
Tipp
Verwende die PowerShell ISE oder VS Code für grafisches Debugging mit Breakpoints!

Modul 6.7: Logging

[Bearbeiten | Quelltext bearbeiten]

Einfaches Datei-Logging

[Bearbeiten | Quelltext bearbeiten]
function Write-Log {
    param(
        [Parameter(Mandatory=$true)]
        [string]$nachricht,
        
        [ValidateSet("INFO", "WARNING", "ERROR", "DEBUG")]
        [string]$level = "INFO",
        
        [string]$logDatei = "C:\Logs\script.log"
    )
    
    # Zeitstempel
    $zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    
    # Log-Eintrag
    $eintrag = "[$zeitstempel] [$level] $nachricht"
    
    # In Datei schreiben
    Add-Content -Path $logDatei -Value $eintrag
    
    # Auch in Konsole (optional, mit Farbe)
    $farbe = switch ($level) {
        "INFO"    { "Green" }
        "WARNING" { "Yellow" }
        "ERROR"   { "Red" }
        "DEBUG"   { "Cyan" }
    }
    
    Write-Host $eintrag -ForegroundColor $farbe
}

# Verwendung
Write-Log "Skript gestartet"
Write-Log "Verarbeite Daten..." -level "INFO"
Write-Log "Warnung: Datei nicht gefunden" -level "WARNING"
Write-Log "Kritischer Fehler!" -level "ERROR"

Erweiterte Log-Funktion

[Bearbeiten | Quelltext bearbeiten]
function Write-EnhancedLog {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$nachricht,
        
        [ValidateSet("INFO", "WARNING", "ERROR", "DEBUG", "SUCCESS")]
        [string]$level = "INFO",
        
        [string]$logDatei = "C:\Logs\enhanced.log",
        
        [switch]$console,
        
        [int]$maxSizeMB = 10
    )
    
    # Log-Ordner erstellen
    $logDir = Split-Path $logDatei -Parent
    if (-not (Test-Path $logDir)) {
        New-Item -Path $logDir -ItemType Directory -Force | Out-Null
    }
    
    # Log-Rotation wenn zu groß
    if (Test-Path $logDatei) {
        $groesse = (Get-Item $logDatei).Length / 1MB
        if ($groesse -gt $maxSizeMB) {
            $archiv = "$logDatei.$(Get-Date -Format 'yyyyMMdd_HHmmss').old"
            Move-Item -Path $logDatei -Destination $archiv
            Write-Verbose "Log rotiert: $archiv"
        }
    }
    
    # Erweiterte Info sammeln
    $caller = (Get-PSCallStack)[1]
    $funktion = if ($caller.Command) { $caller.Command } else { "Main" }
    
    # Log-Eintrag mit mehr Details
    $zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss.fff"
    $eintrag = "[$zeitstempel] [$level] [$funktion] $nachricht"
    
    # Schreiben
    try {
        Add-Content -Path $logDatei -Value $eintrag -ErrorAction Stop
    } catch {
        Write-Warning "Konnte nicht in Log-Datei schreiben: $_"
    }
    
    # Konsolen-Ausgabe
    if ($console -or $level -in @("ERROR", "WARNING")) {
        $farbe = switch ($level) {
            "INFO"    { "White" }
            "SUCCESS" { "Green" }
            "WARNING" { "Yellow" }
            "ERROR"   { "Red" }
            "DEBUG"   { "Cyan" }
        }
        Write-Host $eintrag -ForegroundColor $farbe
    }
    
    # Bei ERROR auch Write-Error aufrufen
    if ($level -eq "ERROR") {
        Write-Error $nachricht
    }
}

# Verwendung
Write-EnhancedLog "Anwendung gestartet" -level "SUCCESS" -console
Write-EnhancedLog "Debug-Information" -level "DEBUG"
Write-EnhancedLog "Etwas ist schief gelaufen" -level "ERROR" -console

Start-Transcript

[Bearbeiten | Quelltext bearbeiten]

PowerShell's eingebautes Session-Logging:

# Transcript starten
Start-Transcript -Path "C:\Logs\session_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"

# Alle Befehle und Ausgaben werden aufgezeichnet
Get-Process | Select-Object -First 5
Write-Host "Test-Ausgabe"
1..10 | ForEach-Object { $_ * 2 }

# Transcript stoppen
Stop-Transcript

# In Skripts verwenden
function Invoke-WithTranscript {
    param($scriptBlock)
    
    $transcriptPath = "C:\Logs\transcript_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"
    Start-Transcript -Path $transcriptPath
    
    try {
        & $scriptBlock
    } finally {
        Stop-Transcript
    }
}

Praktische Übungen

[Bearbeiten | Quelltext bearbeiten]

Übung 1: Robuste Datei-Verarbeitung

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Erstelle eine Funktion, die:

  1. Eine Datei liest
  2. Try-Catch für Fehlerbehandlung verwendet
  3. Verschiedene Fehlertypen unterschiedlich behandelt
  4. Logging implementiert
  5. Finally für Cleanup verwendet

Lösung anzeigen

function Read-FileRobust {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$pfad,
        
        [switch]$logging
    )
    
    $stream = $null
    $erfolg = $false
    
    try {
        # Logging
        if ($logging) {
            Write-Log "Starte Datei-Lesen: $pfad" -level "INFO"
        }
        
        # Datei existiert?
        if (-not (Test-Path $pfad)) {
            throw [System.IO.FileNotFoundException]::new("Datei nicht gefunden: $pfad")
        }
        
        # Lese-Berechtigung?
        try {
            $acl = Get-Acl $pfad -ErrorAction Stop
        } catch [System.UnauthorizedAccessException] {
            throw [System.UnauthorizedAccessException]::new("Keine Berechtigung für: $pfad")
        }
        
        # Datei öffnen
        Write-Verbose "Öffne Datei: $pfad"
        $stream = [System.IO.File]::OpenText($pfad)
        
        # Inhalt lesen
        $inhalt = $stream.ReadToEnd()
        
        Write-Verbose "Gelesen: $($inhalt.Length) Zeichen"
        
        if ($logging) {
            Write-Log "Datei erfolgreich gelesen: $($inhalt.Length) Zeichen" -level "SUCCESS"
        }
        
        $erfolg = $true
        return $inhalt
        
    } catch [System.IO.FileNotFoundException] {
        $fehlerMsg = "Datei nicht gefunden: $pfad"
        Write-Host $fehlerMsg -ForegroundColor Red
        
        if ($logging) {
            Write-Log $fehlerMsg -level "ERROR"
        }
        
        return $null
        
    } catch [System.UnauthorizedAccessException] {
        $fehlerMsg = "Zugriff verweigert: $pfad"
        Write-Host $fehlerMsg -ForegroundColor Red
        
        if ($logging) {
            Write-Log $fehlerMsg -level "ERROR"
        }
        
        return $null
        
    } catch [System.IO.IOException] {
        $fehlerMsg = "IO-Fehler beim Lesen von $pfad : $($_.Exception.Message)"
        Write-Host $fehlerMsg -ForegroundColor Red
        
        if ($logging) {
            Write-Log $fehlerMsg -level "ERROR"
        }
        
        return $null
        
    } catch {
        $fehlerMsg = "Unerwarteter Fehler: $($_.Exception.GetType().Name) - $($_.Exception.Message)"
        Write-Host $fehlerMsg -ForegroundColor Red
        
        if ($logging) {
            Write-Log $fehlerMsg -level "ERROR"
        }
        
        return $null
        
    } finally {
        # Aufräumen - wird immer ausgeführt
        if ($null -ne $stream) {
            $stream.Close()
            $stream.Dispose()
            Write-Verbose "Datei-Stream geschlossen"
        }
        
        if ($logging) {
            $status = if ($erfolg) { "erfolgreich" } else { "mit Fehler" }
            Write-Log "Datei-Operation beendet: $status" -level "INFO"
        }
    }
}

# Test
Read-FileRobust -pfad "C:\test.txt" -Verbose -logging
Read-FileRobust -pfad "C:\GibtEsNicht.txt" -logging

Übung 2: Retry-Logik

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Implementiere eine Funktion, die:

  1. Einen Befehl mehrfach versucht
  2. Bei Fehler automatisch wiederholt
  3. Wartezeit zwischen Versuchen hat
  4. Exponentielles Backoff unterstützt
  5. Nach max. Versuchen aufgibt

Lösung anzeigen

function Invoke-WithRetry {
    <#
    .SYNOPSIS
        Führt einen Befehl mit Retry-Logik aus.
    
    .DESCRIPTION
        Versucht einen Befehl mehrfach auszuführen.
        Bei Fehler wird automatisch wiederholt mit
        konfigurierbarer Wartezeit.
    
    .PARAMETER scriptBlock
        Der auszuführende Code-Block.
    
    .PARAMETER maxRetries
        Maximale Anzahl an Versuchen (Standard: 3).
    
    .PARAMETER retryDelaySeconds
        Wartezeit zwischen Versuchen in Sekunden (Standard: 2).
    
    .PARAMETER exponentialBackoff
        Verdoppelt Wartezeit nach jedem Versuch.
    
    .EXAMPLE
        Invoke-WithRetry -scriptBlock {
            Invoke-WebRequest "https://example.com/api"
        } -maxRetries 5
    #>
    
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [scriptblock]$scriptBlock,
        
        [ValidateRange(1, 100)]
        [int]$maxRetries = 3,
        
        [ValidateRange(1, 3600)]
        [int]$retryDelaySeconds = 2,
        
        [switch]$exponentialBackoff
    )
    
    $versuch = 0
$versuch = 0
    $erfolg = $false
    $letzterFehler = $null
    
    while ($versuch -lt $maxRetries -and -not $erfolg) {
        $versuch++
        
        try {
            Write-Verbose "Versuch $versuch von $maxRetries..."
            
            # Scriptblock ausführen
            $ergebnis = & $scriptBlock
            
            # Erfolg!
            $erfolg = $true
            Write-Host "✓ Erfolgreich im Versuch $versuch" -ForegroundColor Green
            return $ergebnis
            
        } catch {
            $letzterFehler = $_
            Write-Warning "Versuch $versuch fehlgeschlagen: $($_.Exception.Message)"
            
            # Wenn nicht letzter Versuch, warten
            if ($versuch -lt $maxRetries) {
                # Wartezeit berechnen
                if ($exponentialBackoff) {
                    $wartezeit = $retryDelaySeconds * [math]::Pow(2, $versuch - 1)
                } else {
                    $wartezeit = $retryDelaySeconds
                }
                
                Write-Host "Warte $wartezeit Sekunden vor nächstem Versuch..." -ForegroundColor Yellow
                Start-Sleep -Seconds $wartezeit
            }
        }
    }
    
    # Alle Versuche fehlgeschlagen
    Write-Error "Alle $maxRetries Versuche fehlgeschlagen!"
    throw $letzterFehler
}

# Test 1: Erfolgreicher Aufruf nach mehreren Versuchen
$zaehler = 0
Invoke-WithRetry -scriptBlock {
    $script:zaehler++
    if ($zaehler -lt 3) {
        throw "Simulierter Fehler"
    }
    Write-Host "Erfolgreich!"
    return "Daten"
} -maxRetries 5 -Verbose

# Test 2: Mit Exponential Backoff
Invoke-WithRetry -scriptBlock {
    Invoke-WebRequest "https://httpstat.us/503" -ErrorAction Stop
} -maxRetries 4 -retryDelaySeconds 1 -exponentialBackoff -Verbose

Übung 3: Umfassende Fehlerbehandlung in Skript

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Erstelle ein vollständiges Skript mit:

  1. Parameter-Validierung
  2. Try-Catch-Finally Struktur
  3. Unterschiedlichen Fehlerbehandlungen
  4. Logging in Datei
  5. Sauberes Cleanup
  6. Exit-Codes für Automatisierung

Lösung anzeigen

<#
.SYNOPSIS
    Datei-Backup-Skript mit umfassender Fehlerbehandlung.

.DESCRIPTION
    Erstellt Backups von Dateien mit vollständiger Fehlerbehandlung,
    Logging und robuster Ausführung.
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [ValidateScript({Test-Path $_ -PathType Container})]
    [string]$quellOrdner,
    
    [Parameter(Mandatory=$true)]
    [string]$zielOrdner,
    
    [string]$logDatei = "C:\Logs\backup.log"
)

# Strikte Fehlerprüfung
Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

# Exit-Codes
$EXIT_SUCCESS = 0
$EXIT_ERROR_GENERAL = 1
$EXIT_ERROR_QUELLE = 2
$EXIT_ERROR_ZIEL = 3
$EXIT_ERROR_COPY = 4

# Logging-Funktion
function Write-BackupLog {
    param(
        [string]$nachricht,
        [ValidateSet("INFO", "SUCCESS", "WARNING", "ERROR")]
        [string]$level = "INFO"
    )
    
    $zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $eintrag = "[$zeitstempel] [$level] $nachricht"
    
    # In Datei
    try {
        Add-Content -Path $logDatei -Value $eintrag -ErrorAction Stop
    } catch {
        Write-Warning "Konnte nicht in Log schreiben: $_"
    }
    
    # In Konsole
    $farbe = switch ($level) {
        "INFO"    { "White" }
        "SUCCESS" { "Green" }
        "WARNING" { "Yellow" }
        "ERROR"   { "Red" }
    }
    Write-Host $eintrag -ForegroundColor $farbe
}

# Hauptlogik
try {
    Write-BackupLog "=== Backup-Skript gestartet ===" -level "INFO"
    Write-BackupLog "Quelle: $quellOrdner" -level "INFO"
    Write-BackupLog "Ziel: $zielOrdner" -level "INFO"
    
    # Log-Ordner erstellen
    $logDir = Split-Path $logDatei -Parent
    if (-not (Test-Path $logDir)) {
        try {
            New-Item -Path $logDir -ItemType Directory -Force | Out-Null
            Write-BackupLog "Log-Verzeichnis erstellt: $logDir" -level "INFO"
        } catch {
            Write-Error "Konnte Log-Verzeichnis nicht erstellen: $_"
            exit $EXIT_ERROR_GENERAL
        }
    }
    
    # Quelle prüfen
    Write-BackupLog "Prüfe Quell-Ordner..." -level "INFO"
    if (-not (Test-Path $quellOrdner -PathType Container)) {
        Write-BackupLog "Quell-Ordner existiert nicht!" -level "ERROR"
        exit $EXIT_ERROR_QUELLE
    }
    
    # Dateien in Quelle
    $dateien = Get-ChildItem -Path $quellOrdner -File -Recurse -ErrorAction Stop
    $dateiAnzahl = $dateien.Count
    
    if ($dateiAnzahl -eq 0) {
        Write-BackupLog "Keine Dateien zum Sichern gefunden" -level "WARNING"
        exit $EXIT_SUCCESS
    }
    
    Write-BackupLog "Gefunden: $dateiAnzahl Datei(en)" -level "INFO"
    
    # Ziel-Ordner erstellen
    Write-BackupLog "Erstelle Ziel-Ordner..." -level "INFO"
    try {
        if (-not (Test-Path $zielOrdner)) {
            New-Item -Path $zielOrdner -ItemType Directory -Force -ErrorAction Stop | Out-Null
            Write-BackupLog "Ziel-Ordner erstellt: $zielOrdner" -level "SUCCESS"
        }
    } catch {
        Write-BackupLog "Konnte Ziel-Ordner nicht erstellen: $($_.Exception.Message)" -level "ERROR"
        exit $EXIT_ERROR_ZIEL
    }
    
    # Backup durchführen
    Write-BackupLog "Starte Kopiervorgang..." -level "INFO"
    
    $erfolgreich = 0
    $fehlgeschlagen = 0
    $fehlerListe = @()
    
    foreach ($datei in $dateien) {
        try {
            # Relativer Pfad
            $relativerPfad = $datei.FullName.Substring($quellOrdner.Length).TrimStart('\')
            $zielPfad = Join-Path $zielOrdner $relativerPfad
            $zielDir = Split-Path $zielPfad -Parent
            
            # Ziel-Unterordner erstellen
            if (-not (Test-Path $zielDir)) {
                New-Item -Path $zielDir -ItemType Directory -Force -ErrorAction Stop | Out-Null
            }
            
            # Datei kopieren
            Copy-Item -Path $datei.FullName -Destination $zielPfad -Force -ErrorAction Stop
            
            $erfolgreich++
            Write-Verbose "Kopiert: $relativerPfad"
            
        } catch [System.UnauthorizedAccessException] {
            $fehlgeschlagen++
            $fehlerMsg = "Zugriff verweigert: $($datei.FullName)"
            $fehlerListe += $fehlerMsg
            Write-BackupLog $fehlerMsg -level "WARNING"
            
        } catch [System.IO.IOException] {
            $fehlgeschlagen++
            $fehlerMsg = "IO-Fehler bei: $($datei.FullName) - $($_.Exception.Message)"
            $fehlerListe += $fehlerMsg
            Write-BackupLog $fehlerMsg -level "WARNING"
            
        } catch {
            $fehlgeschlagen++
            $fehlerMsg = "Fehler bei: $($datei.FullName) - $($_.Exception.Message)"
            $fehlerListe += $fehlerMsg
            Write-BackupLog $fehlerMsg -level "WARNING"
        }
    }
    
    # Zusammenfassung
    Write-BackupLog "" -level "INFO"
    Write-BackupLog "=== Backup abgeschlossen ===" -level "INFO"
    Write-BackupLog "Erfolgreich: $erfolgreich" -level "SUCCESS"
    
    if ($fehlgeschlagen -gt 0) {
        Write-BackupLog "Fehlgeschlagen: $fehlgeschlagen" -level "WARNING"
        Write-BackupLog "" -level "INFO"
        Write-BackupLog "Fehler-Details:" -level "WARNING"
        foreach ($fehler in $fehlerListe) {
            Write-BackupLog "  - $fehler" -level "WARNING"
        }
    }
    
    # Exit-Code basierend auf Ergebnis
    if ($fehlgeschlagen -eq 0) {
        Write-BackupLog "Status: Vollständig erfolgreich" -level "SUCCESS"
        exit $EXIT_SUCCESS
    } elseif ($erfolgreich -gt 0) {
        Write-BackupLog "Status: Teilweise erfolgreich" -level "WARNING"
        exit $EXIT_ERROR_COPY
    } else {
        Write-BackupLog "Status: Vollständig fehlgeschlagen" -level "ERROR"
        exit $EXIT_ERROR_COPY
    }
    
} catch {
    # Kritischer, unerwarteter Fehler
    $fehlerMsg = "Kritischer Fehler: $($_.Exception.Message)"
    Write-BackupLog $fehlerMsg -level "ERROR"
    Write-BackupLog "Stack Trace: $($_.ScriptStackTrace)" -level "ERROR"
    
    exit $EXIT_ERROR_GENERAL
    
} finally {
    # Cleanup und finale Aktionen
    Write-BackupLog "Skript beendet um $(Get-Date -Format 'HH:mm:ss')" -level "INFO"
    Write-BackupLog "" -level "INFO"
}

Übung 4: Error-Report Generator

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Erstelle eine Funktion, die:

  1. Alle Fehler aus $Error analysiert
  2. Fehler nach Typ gruppiert
  3. Statistiken erstellt
  4. HTML-Report generiert
  5. Optional Fehler-Verlauf löscht

Lösung anzeigen

function Export-ErrorReport {
    <#
    .SYNOPSIS
        Erstellt einen detaillierten Fehler-Report.
    
    .DESCRIPTION
        Analysiert alle Fehler in $Error und erstellt
        einen umfassenden HTML-Report mit Statistiken.
    
    .PARAMETER outputPath
        Pfad für den HTML-Report.
    
    .PARAMETER clearErrors
        Löscht $Error nach Export.
    
    .PARAMETER maxErrors
        Maximale Anzahl zu analysierender Fehler.
    
    .EXAMPLE
        Export-ErrorReport -outputPath "C:\Reports\errors.html"
    #>
    
    [CmdletBinding()]
    param(
        [string]$outputPath = ".\error_report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html",
        
        [switch]$clearErrors,
        
        [int]$maxErrors = 100
    )
    
    Write-Host "`n=== Fehler-Report Generator ===" -ForegroundColor Cyan
    
    # Prüfen ob Fehler vorhanden
    if ($Error.Count -eq 0) {
        Write-Host "Keine Fehler zum Analysieren gefunden." -ForegroundColor Green
        return
    }
    
    Write-Host "Analysiere $($Error.Count) Fehler..." -ForegroundColor Yellow
    
    # Fehler begrenzen
    $zuAnalysieren = if ($Error.Count -gt $maxErrors) {
        Write-Warning "Analysiere nur die neuesten $maxErrors Fehler"
        $Error | Select-Object -First $maxErrors
    } else {
        $Error
    }
    
    # Fehler-Objekte erstellen
    $fehlerListe = @()
    $index = 1
    
    foreach ($err in $zuAnalysieren) {
        $fehlerListe += [PSCustomObject]@{
            Nr = $index++
            Typ = $err.Exception.GetType().Name
            Nachricht = $err.Exception.Message
            Kategorie = $err.CategoryInfo.Category
            Befehl = $err.InvocationInfo.MyCommand.Name
            Zeile = $err.InvocationInfo.ScriptLineNumber
            Skript = $err.InvocationInfo.ScriptName
            Zeit = $err.TimeGenerated
        }
    }
    
    # Statistiken
    $stats = @{
        Gesamt = $fehlerListe.Count
        NachTyp = $fehlerListe | Group-Object Typ | Sort-Object Count -Descending
        NachKategorie = $fehlerListe | Group-Object Kategorie | Sort-Object Count -Descending
        NachBefehl = $fehlerListe | Group-Object Befehl | Sort-Object Count -Descending | Select-Object -First 10
        HaeufigsteFehler = $fehlerListe | Group-Object Nachricht | Sort-Object Count -Descending | Select-Object -First 5
    }
    
    # HTML generieren
    $htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>PowerShell Fehler-Report</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            margin: 20px;
            background-color: #f5f5f5;
        }
        .container {
            max-width: 1400px;
            margin: 0 auto;
            background-color: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        h1 {
            color: #d9534f;
            border-bottom: 3px solid #d9534f;
            padding-bottom: 10px;
        }
        h2 {
            color: #337ab7;
            margin-top: 30px;
            border-bottom: 2px solid #337ab7;
            padding-bottom: 5px;
        }
        .stats {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 15px;
            margin: 20px 0;
        }
        .stat-box {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 20px;
            border-radius: 8px;
            text-align: center;
        }
        .stat-box h3 {
            margin: 0;
            font-size: 36px;
            font-weight: bold;
        }
        .stat-box p {
            margin: 5px 0 0 0;
            opacity: 0.9;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin: 15px 0;
            background-color: white;
        }
        th {
            background-color: #337ab7;
            color: white;
            padding: 12px;
            text-align: left;
            font-weight: 600;
        }
        td {
            border: 1px solid #ddd;
            padding: 10px;
        }
        tr:nth-child(even) {
            background-color: #f9f9f9;
        }
        tr:hover {
            background-color: #f0f0f0;
        }
        .error-msg {
            color: #d9534f;
            font-family: 'Courier New', monospace;
        }
        .meta-info {
            background-color: #f8f9fa;
            padding: 15px;
            border-radius: 5px;
            margin: 20px 0;
        }
        .chart {
            margin: 20px 0;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>🔴 PowerShell Fehler-Report</h1>
        
        <div class="meta-info">
            <strong>Erstellt:</strong> $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')<br>
            <strong>Computer:</strong> $env:COMPUTERNAME<br>
            <strong>Benutzer:</strong> $env:USERNAME<br>
            <strong>PowerShell Version:</strong> $($PSVersionTable.PSVersion)
        </div>
        
        <h2>📊 Übersicht</h2>
        <div class="stats">
            <div class="stat-box">
                <h3>$($stats.Gesamt)</h3>
                <p>Fehler gesamt</p>
            </div>
            <div class="stat-box">
                <h3>$($stats.NachTyp.Count)</h3>
                <p>Fehlertypen</p>
            </div>
            <div class="stat-box">
                <h3>$($stats.NachKategorie.Count)</h3>
                <p>Kategorien</p>
            </div>
        </div>
        
        <h2>📈 Fehler nach Typ</h2>
        $($stats.NachTyp | Select-Object Name, Count | ConvertTo-Html -Fragment)
        
        <h2>📋 Fehler nach Kategorie</h2>
        $($stats.NachKategorie | Select-Object Name, Count | ConvertTo-Html -Fragment)
        
        <h2>⚡ Top Befehle mit Fehlern</h2>
        $($stats.NachBefehl | Select-Object Name, Count | ConvertTo-Html -Fragment)
        
        <h2>🔥 Häufigste Fehler-Nachrichten</h2>
        $($stats.HaeufigsteFehler | Select-Object Name, Count | ConvertTo-Html -Fragment)
        
        <h2>📝 Detaillierte Fehler-Liste</h2>
        $($fehlerListe | Select-Object Nr, Typ, Nachricht, Kategorie, Befehl, Zeile | ConvertTo-Html -Fragment)
        
    </div>
</body>
</html>
"@
    
    # In Datei schreiben
    try {
        $htmlContent | Out-File -FilePath $outputPath -Encoding UTF8 -ErrorAction Stop
        Write-Host "✓ Report erstellt: $outputPath" -ForegroundColor Green
        
        # Datei öffnen
        Invoke-Item $outputPath
        
    } catch {
        Write-Error "Konnte Report nicht schreiben: $_"
        return
    }
    
    # Fehler löschen
    if ($clearErrors) {
        $Error.Clear()
        Write-Host "✓ Fehler-Verlauf gelöscht" -ForegroundColor Green
    }
    
    # Zusammenfassung
    Write-Host "`n=== Zusammenfassung ===" -ForegroundColor Cyan
    Write-Host "Analysierte Fehler: $($stats.Gesamt)"
    Write-Host "Häufigster Typ: $($stats.NachTyp[0].Name) ($($stats.NachTyp[0].Count)x)"
    Write-Host "Report-Pfad: $outputPath"
}

# Test: Einige Fehler erzeugen und dann Report erstellen
try { Get-Item "C:\GibtEsNicht1.txt" -ErrorAction Stop } catch {}
try { [int]"keine zahl" } catch {}
try { 1/0 } catch {}

# Report erstellen
Export-ErrorReport -outputPath "C:\Reports\error_report.html" -Verbose

Fehlerbehandlungs-Entscheidungsbaum

[Bearbeiten | Quelltext bearbeiten]
Fehlerbehandlung nötig?
├─ Kritischer Fehler (muss stoppen)?
│  ├─ Ja → throw verwenden
│  └─ Nein → Write-Error verwenden
│
├─ Cmdlet-Fehler abfangen?
│  ├─ Ja → Try-Catch mit -ErrorAction Stop
│  └─ Nein → ErrorAction SilentlyContinue
│
├─ Cleanup nötig?
│  ├─ Ja → Finally-Block verwenden
│  └─ Nein → Nur Try-Catch
│
├─ Instabile Operation?
│  ├─ Ja → Retry-Logik implementieren
│  └─ Nein → Normale Fehlerbehandlung
│
└─ Produktions-Skript?
   ├─ Ja → Logging + Try-Catch + Finally
   └─ Nein → Einfaches Try-Catch reicht

DO:

  • Verwende Try-Catch für kritische Operationen
  • Implementiere Finally für Cleanup (Dateien schließen, Verbindungen trennen)
  • Logge Fehler in Produktions-Skripten
  • Verwende spezifische Catch-Blöcke für verschiedene Fehlertypen
  • Gib aussagekräftige Fehlermeldungen
  • Nutze -ErrorAction Stop für Cmdlets in Try-Catch
  • Implementiere Retry-Logik für Netzwerk-Operationen
  • Verwende Set-StrictMode für robusteren Code

DON'T:

  • Keine leeren Catch-Blöcke (Fehler verschlucken)
  • Nicht alle Fehler gleich behandeln
  • Keine generischen Fehlermeldungen ("Fehler aufgetreten")
  • Nicht zu viele verschachtelte Try-Catch
  • Keine kritischen Fehler mit Write-Error (verwende throw)
  • Nicht Finally vergessen bei Ressourcen-Cleanup
  • Keine Fehler loggen ohne Kontext-Information

Cheat Sheet - Fehlerbehandlung

[Bearbeiten | Quelltext bearbeiten]
# TRY-CATCH-FINALLY
try {
    Get-Content "datei.txt" -ErrorAction Stop
} catch [System.IO.FileNotFoundException] {
    Write-Host "Datei nicht gefunden"
} catch {
    Write-Host "Anderer Fehler: $_"
} finally {
    Write-Host "Cleanup"
}

# ERRORACTION
-ErrorAction Stop           # Für Try-Catch
-ErrorAction SilentlyContinue  # Fehler unterdrücken
-ErrorAction Ignore        # Komplett ignorieren

# EIGENE FEHLER
throw "Kritischer Fehler!"
Write-Error "Warnung"

# FEHLER-VARIABLEN
$Error[0]                  # Letzter Fehler
$Error.Clear()             # Leeren
$?                         # Erfolg?
$LASTEXITCODE             # Exit-Code

# LOGGING
Write-Verbose "Info" -Verbose
Write-Debug "Debug" -Debug
Start-Transcript "log.txt"

# DEBUGGING
Set-PSBreakpoint -Line 10
Set-StrictMode -Version Latest
$DebugPreference = "Continue"

# RETRY-PATTERN
$versuche = 0
while ($versuche -lt 3) {
    try {
        # Operation
        break
    } catch {
        $versuche++
        Start-Sleep 2
    }
}

Nächste Schritte

[Bearbeiten | Quelltext bearbeiten]

Im nächsten Kurs lernst du:

  • Mit dem Dateisystem arbeiten
  • Dateien und Ordner verwalten
  • Inhalte lesen und schreiben
  • Pfade manipulieren
  • Datei-Operationen automatisieren

Zusätzliche Ressourcen

[Bearbeiten | Quelltext bearbeiten]

Häufige Fehlertypen

[Bearbeiten | Quelltext bearbeiten]
Exception Bedeutung Häufige Ursache
FileNotFoundException Datei nicht gefunden Falscher Pfad
UnauthorizedAccessException Zugriff verweigert Fehlende Rechte
IOException Ein-/Ausgabefehler Datei in Verwendung
ArgumentException Ungültiges Argument Falsche Parameter
FormatException Formatfehler Typkonvertierung fehlgeschlagen
InvalidOperationException Ungültige Operation Falscher Zustand
NullReferenceException Null-Referenz Variable ist $null
✓
Erfolg
Glückwunsch! Du hast Kurs 6 abgeschlossen und kannst jetzt robuste, produktionsreife Skripte schreiben!