Zum Inhalt springen

Powershell - Die Pipeline und Objektverarbeitung

Aus Gerhards Wiki
Version vom 31. Oktober 2025, 19:54 Uhr von Gerhard (Diskussion | Beiträge)
(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)

Modul 2.1: Das Pipeline-Prinzip

Was ist die Pipeline?

Die Pipeline ist das Herzstück von PowerShell. Sie verbindet Cmdlets mit dem Pipe-Symbol (|) und übergibt Objekte von einem Cmdlet zum nächsten.

Wichtig: PowerShell übergibt keine Text-Strings wie CMD oder Bash, sondern vollständige .NET-Objekte mit Eigenschaften und Methoden!

Einfaches Pipeline-Beispiel

# Prozesse abrufen und nach CPU sortieren
Get-Process | Sort-Object CPU

Was passiert hier?

  1. Get-Process erstellt Process-Objekte
  2. | übergibt diese Objekte
  3. Sort-Object sortiert sie nach der CPU-Eigenschaft

Pipeline vs. Text

Traditionelle Shell (CMD/Bash) PowerShell
Übergibt Text-Zeilen Übergibt Objekte
Parsing mit grep, awk, sed Direkte Objekt-Manipulation
Unstrukturierte Daten Strukturierte Daten
Fehleranfällig bei Format-Änderungen Robust durch Objekt-Eigenschaften

Beispiel CMD vs. PowerShell:

# CMD/Bash - Text-basiert
dir | findstr ".txt"
# PowerShell - Objekt-basiert
Get-ChildItem | Where-Object Extension -eq ".txt"

Pipeline-Visualisierung

Get-Service | Where-Object Status -eq 'Running' | Sort-Object Name | Select-Object -First 5

Ablauf:

Get-Service
    ↓ (ServiceController-Objekte)
Where-Object Status -eq 'Running'
    ↓ (Gefilterte ServiceController-Objekte)
Sort-Object Name
    ↓ (Sortierte ServiceController-Objekte)
Select-Object -First 5
    ↓ (Top 5 ServiceController-Objekte)
Ausgabe
ℹ️
Hinweis
Jedes Cmdlet in der Pipeline arbeitet mit den vollständigen Objekten, nicht nur mit Text-Darstellungen.

Modul 2.2: Objekte untersuchen mit Get-Member

Was sind Objekte?

In PowerShell ist alles ein Objekt. Jedes Objekt hat:

  • Eigenschaften (Properties) - Daten/Attribute
  • Methoden (Methods) - Funktionen/Aktionen

Get-Member: Das Schweizer Taschenmesser

Get-Member (Alias: gm) zeigt dir alle Eigenschaften und Methoden eines Objekts:

# Struktur von Process-Objekten anzeigen
Get-Process | Get-Member

# Nur Eigenschaften
Get-Process | Get-Member -MemberType Property

# Nur Methoden
Get-Process | Get-Member -MemberType Method

Beispiel: Process-Objekt analysieren

Get-Process | Select-Object -First 1 | Get-Member

Ausgabe (Auszug):

TypeName: System.Diagnostics.Process

Name                    MemberType Definition
----                    ---------- ----------
Handles                 Property   int Handles {get;}
Id                      Property   int Id {get;}
ProcessName             Property   string ProcessName {get;}
StartTime               Property   datetime StartTime {get;}
Kill                    Method     void Kill()
Start                   Method     bool Start()

Eigenschaften verwenden

# Einzelne Eigenschaft abrufen
(Get-Process -Name "notepad").Id

# Mehrere Eigenschaften
Get-Process | Select-Object Name, Id, CPU

# Berechnete Eigenschaften
Get-Process | Select-Object Name, 
    @{Name="Memory(MB)"; Expression={$_.WorkingSet / 1MB}}

Methoden aufrufen

# String-Methoden
"Hallo Welt".ToUpper()           # HALLO WELT
"Hallo Welt".Replace("Welt", "PowerShell")  # Hallo PowerShell

# DateTime-Methoden
(Get-Date).AddDays(7)            # Datum in 7 Tagen
(Get-Date).DayOfWeek             # Wochentag

# Process-Methoden (Vorsicht!)
$prozess = Get-Process notepad
$prozess.Kill()                  # Beendet Notepad
⚠️
Warnung
Sei vorsichtig beim Aufrufen von Methoden wie Kill() - sie führen Aktionen aus!

Modul 2.3: Filtern mit Where-Object

Grundlegende Filterung

Where-Object (Alias: where, ?) filtert Objekte basierend auf Bedingungen:

# Dienste die laufen
Get-Service | Where-Object Status -eq 'Running'

# Prozesse mit mehr als 100 MB Arbeitsspeicher
Get-Process | Where-Object WorkingSet -gt 100MB

# Dateien größer als 1 MB
Get-ChildItem | Where-Object Length -gt 1MB

Vergleichsoperatoren

Operator Bedeutung Beispiel
-eq Gleich (equal) Where-Object Status -eq 'Running'
-ne Ungleich (not equal) Where-Object Name -ne 'System'
-gt Größer als (greater than) Where-Object CPU -gt 100
-ge Größer oder gleich Where-Object Length -ge 1MB
-lt Kleiner als (less than) Where-Object Id -lt 1000
-le Kleiner oder gleich Where-Object Priority -le 5
-like Wildcard-Vergleich Where-Object Name -like "*.txt"
-notlike Nicht wie Where-Object Name -notlike "test*"
-match Regex-Vergleich Where-Object Name -match "^[A-Z]"
-notmatch Nicht matchen Where-Object Extension -notmatch "\.tmp$"
-contains Array enthält Where-Object {$array -contains $_.Name}
-in Element in Array Where-Object Status -in @('Running','Stopped')

Script-Block-Syntax

Für komplexere Bedingungen verwendest du Script-Blocks mit $_ (aktuelles Pipeline-Objekt):

# Mehrere Bedingungen mit -and
Get-Process | Where-Object {$_.CPU -gt 10 -and $_.WorkingSet -gt 50MB}

# Alternative: -or
Get-Service | Where-Object {$_.Status -eq 'Running' -or $_.StartType -eq 'Automatic'}

# Negation mit -not oder !
Get-ChildItem | Where-Object {-not $_.PSIsContainer}  # Nur Dateien

# Komplexe Bedingung
Get-Process | Where-Object {
    $_.Name -like "chrome*" -and 
    $_.WorkingSet -gt 100MB -and 
    $_.Responding -eq $true
}

Vereinfachte Syntax (ab PowerShell 3.0)

# Kurz und lesbar
Get-Service | Where-Object Status -eq 'Running'

# Entspricht der Script-Block-Syntax
Get-Service | Where-Object {$_.Status -eq 'Running'}
💡
Tipp
Verwende die vereinfachte Syntax für einfache Bedingungen, Script-Blocks für komplexe Filter.

Modul 2.4: Auswählen mit Select-Object

Eigenschaften auswählen

Select-Object (Alias: select) wählt bestimmte Eigenschaften aus:

# Nur Name und CPU
Get-Process | Select-Object Name, CPU

# Erste 10 Ergebnisse
Get-Process | Select-Object -First 10

# Letzte 5 Ergebnisse
Get-Service | Select-Object -Last 5

# Alle außer ersten 3
Get-ChildItem | Select-Object -Skip 3

# Duplikate entfernen
Get-Process | Select-Object ProcessName -Unique

Berechnete Eigenschaften

Erstelle eigene Eigenschaften mit Hashtables:

# Memory in MB statt Bytes
Get-Process | Select-Object Name, 
    @{Name='MemoryMB'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}}

# Mehrere berechnete Eigenschaften
Get-Process | Select-Object Name,
    @{N='CPU(s)'; E={$_.CPU}},
    @{N='Memory(MB)'; E={[math]::Round($_.WS / 1MB, 2)}},
    @{N='Running'; E={if($_.Responding){"Ja"}else{"Nein"}}}
ℹ️
Hinweis
Name kann zu N und Expression zu E abgekürzt werden.

Eigenschaften erweitern

# Alle Eigenschaften anzeigen (auch versteckte)
Get-Process | Select-Object -Property *

# Bestimmte und alle anderen
Get-Process | Select-Object Name, Id, *

Modul 2.5: Sortieren mit Sort-Object

Grundlegendes Sortieren

Sort-Object (Alias: sort) sortiert Objekte:

# Nach Name sortieren (aufsteigend)
Get-Process | Sort-Object Name

# Absteigend sortieren
Get-Process | Sort-Object CPU -Descending

# Nach mehreren Eigenschaften
Get-Service | Sort-Object Status, Name

# Zahlen vs. Text
Get-ChildItem | Sort-Object Length -Descending

Erweiterte Sortierung

# Case-sensitive
Get-ChildItem | Sort-Object Name -CaseSensitive

# Eindeutige Werte
Get-Process | Sort-Object ProcessName -Unique

# Erst nach Status (absteigend), dann nach Name (aufsteigend)
Get-Service | Sort-Object @{Expression="Status"; Descending=$true}, 
                          @{Expression="Name"; Descending=$false}

Top-N-Pattern

Häufiges Muster: Sortieren und Top-N auswählen:

# Top 10 Prozesse nach CPU
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

# Top 5 größte Dateien
Get-ChildItem | Sort-Object Length -Descending | Select-Object -First 5 Name, Length

# Älteste 3 Dienste (nach StartTime)
Get-Service | Sort-Object StartTime | Select-Object -First 3

Modul 2.6: Messen mit Measure-Object

Statistiken berechnen

Measure-Object (Alias: measure) berechnet Statistiken:

# Anzahl der Prozesse
Get-Process | Measure-Object

# Summe aller CPU-Zeit
Get-Process | Measure-Object -Property CPU -Sum

# Durchschnittliche Dateigröße
Get-ChildItem | Measure-Object -Property Length -Average

# Alle Statistiken auf einmal
Get-Process | Measure-Object -Property WorkingSet -Sum -Average -Maximum -Minimum

Praktische Beispiele

# Anzahl laufender Dienste
(Get-Service | Where-Object Status -eq 'Running' | Measure-Object).Count

# Gesamtgröße aller Dateien in einem Ordner
$total = Get-ChildItem C:\Temp -Recurse | 
         Measure-Object -Property Length -Sum
"Gesamtgröße: $([math]::Round($total.Sum / 1GB, 2)) GB"

# Durchschnittliche CPU-Auslastung der Top-10-Prozesse
Get-Process | Sort-Object CPU -Descending | 
              Select-Object -First 10 | 
              Measure-Object -Property CPU -Average

Zeichen, Wörter, Zeilen zählen

# Wie Linux 'wc' (word count)
Get-Content text.txt | Measure-Object -Line -Word -Character

Modul 2.7: Ausgabe formatieren

Die Format-Cmdlets

PowerShell bietet verschiedene Format-Cmdlets für die Ausgabe:

Cmdlet Beschreibung Verwendung
Format-Table Tabellenformat Standard, übersichtlich für Listen
Format-List Listenformat Detailliert, eine Eigenschaft pro Zeile
Format-Wide Spaltenformat Nur eine Eigenschaft, mehrere Spalten
Format-Custom Benutzerdefiniert Selten verwendet
⚠️
Warnung
Format-Cmdlets sollten immer am Ende der Pipeline stehen, da sie Formatierungsobjekte zurückgeben, keine Daten-Objekte!

Format-Table (ft)

# Standard-Tabelle
Get-Process | Format-Table

# Bestimmte Spalten
Get-Process | Format-Table Name, CPU, WorkingSet

# AutoSize für bessere Darstellung
Get-Process | Format-Table Name, CPU, Id -AutoSize

# Mit Gruppierung
Get-Service | Format-Table -GroupBy Status

# Berechnete Spalten
Get-Process | Format-Table Name,
    @{Label="Memory(MB)"; Expression={$_.WS / 1MB}; FormatString="F2"; Alignment="Right"}

Format-List (fl)

# Alle Eigenschaften als Liste
Get-Process -Name "powershell" | Format-List *

# Bestimmte Eigenschaften
Get-Service -Name "wuauserv" | Format-List Name, Status, StartType, DisplayName

# Ideal für einzelne Objekte mit vielen Eigenschaften
Get-ComputerInfo | Format-List

Format-Wide (fw)

# Nur Namen in Spalten
Get-Process | Format-Wide Name

# Anzahl der Spalten festlegen
Get-Process | Format-Wide Name -Column 5

# Nützlich für Übersichten
Get-Command | Format-Wide Name -Column 4

Out-Cmdlets

Für Ausgabe-Umleitung gibt es Out-* Cmdlets:

# In Datei schreiben
Get-Process | Out-File prozesse.txt

# An Datei anhängen
Get-Service | Out-File dienste.txt -Append

# An Drucker
Get-Content dokument.txt | Out-Printer

# In GridView (GUI-Tabelle)
Get-Process | Out-GridView

# Ausgabe verwerfen
Get-Process | Out-Null
💡
Tipp
Out-GridView ist großartig für interaktive Daten-Exploration mit Filter- und Sortier-Funktionen!

Modul 2.8: Daten exportieren und importieren

CSV-Format

# Prozesse in CSV exportieren
Get-Process | Export-Csv prozesse.csv -NoTypeInformation

# CSV importieren
$prozesse = Import-Csv prozesse.csv

# Mit Delimiter
Get-Service | Export-Csv dienste.csv -Delimiter ";" -NoTypeInformation

# Encoding festlegen
Export-Csv daten.csv -Encoding UTF8

JSON-Format

# In JSON konvertieren
Get-Service | Select-Object -First 5 | ConvertTo-Json

# In Datei speichern
Get-Process | Select-Object Name, Id, CPU | ConvertTo-Json | Out-File prozesse.json

# JSON importieren
$daten = Get-Content prozesse.json | ConvertFrom-Json

# Mit Tiefe (für verschachtelte Objekte)
$komplexesDatenObjekt | ConvertTo-Json -Depth 5

XML-Format

# Nach XML exportieren
Get-Process | Export-Clixml prozesse.xml

# XML importieren (mit vollständiger Objekt-Wiederherstellung!)
$prozesse = Import-Clixml prozesse.xml

# ConvertTo-Xml für XML-String
Get-Service | ConvertTo-Xml -As String
ℹ️
Hinweis
Export-Clixml / Import-Clixml bewahren die vollständigen PowerShell-Objekte mit allen Eigenschaften und Methoden!

HTML-Format

# HTML-Bericht erstellen
Get-Process | ConvertTo-Html | Out-File bericht.html

# Mit Eigenschaften und Styling
Get-Service | Select-Object Name, Status, StartType |
    ConvertTo-Html -Title "Dienste-Bericht" -PreContent "<h1>Systemdienste</h1>" |
    Out-File dienste.html

# Im Browser öffnen
Invoke-Item dienste.html

Vergleich der Formate

Format Vorteile Nachteile Verwendung
CSV Einfach, Excel-kompatibel Nur flache Daten Tabellen, Reports
JSON Webstandard, lesbar Keine Methodeninfo APIs, Web-Anwendungen
XML (CliXml) Vollständige Objekte Größe, Komplexität PowerShell-zu-PowerShell
HTML Visuell, teilbar Nur Ansicht, nicht importierbar Berichte, Dokumentation

Praktische Übungen

Übung 1: Pipeline-Grundlagen

Aufgabe:

  1. Zeige alle laufenden Dienste an
  2. Sortiere sie alphabetisch nach Namen
  3. Zeige nur die ersten 10
  4. Exportiere das Ergebnis in eine CSV-Datei

Lösung anzeigen

Get-Service | 
    Where-Object Status -eq 'Running' | 
    Sort-Object Name | 
    Select-Object -First 10 |
    Export-Csv dienste_running.csv -NoTypeInformation

Übung 2: Objekte untersuchen

Aufgabe:

  1. Wähle einen beliebigen Prozess aus
  2. Untersuche seine Eigenschaften mit Get-Member
  3. Erstelle eine Ausgabe mit Name, ID und Arbeitsspeicher in MB (gerundet auf 2 Dezimalstellen)
  4. Sortiere nach Arbeitsspeicher absteigend

Lösung anzeigen

# Eigenschaften untersuchen
Get-Process | Select-Object -First 1 | Get-Member

# Formatierte Ausgabe
Get-Process | 
    Select-Object Name, Id,
        @{N='MemoryMB'; E={[math]::Round($_.WorkingSet / 1MB, 2)}} |
    Sort-Object MemoryMB -Descending

Übung 3: Komplexe Filterung

Aufgabe:

  1. Finde alle Dateien im Temp-Ordner, die größer als 10 MB sind
  2. Filtere nach .log und .tmp Dateien
  3. Sortiere nach Größe absteigend
  4. Zeige Name, Größe in MB und Änderungsdatum

Lösung anzeigen

Get-ChildItem $env:TEMP -Recurse -File -ErrorAction SilentlyContinue |
    Where-Object {$_.Length -gt 10MB -and ($_.Extension -eq '.log' -or $_.Extension -eq '.tmp')} |
    Sort-Object Length -Descending |
    Select-Object Name,
        @{N='SizeMB'; E={[math]::Round($_.Length / 1MB, 2)}},
        LastWriteTime

Übung 4: Statistiken erstellen

Aufgabe:

  1. Berechne die Gesamtanzahl aller Prozesse
  2. Finde den Prozess mit der höchsten CPU-Auslastung
  3. Berechne den durchschnittlichen Arbeitsspeicher aller Prozesse
  4. Erstelle einen formatierten Bericht als HTML

Lösung anzeigen

# Anzahl
$anzahl = (Get-Process | Measure-Object).Count

# Höchste CPU
$topCPU = Get-Process | Sort-Object CPU -Descending | Select-Object -First 1

# Durchschnittlicher Speicher
$avgMemory = Get-Process | Measure-Object -Property WorkingSet -Average

# Bericht erstellen
$bericht = [PSCustomObject]@{
    'Gesamte Prozesse' = $anzahl
    'Top CPU Prozess' = $topCPU.Name
    'Top CPU Wert' = [math]::Round($topCPU.CPU, 2)
    'Durchschn. RAM (MB)' = [math]::Round($avgMemory.Average / 1MB, 2)
}

$bericht | ConvertTo-Html -Title "Prozess-Statistiken" | Out-File stats.html
Invoke-Item stats.html

Übung 5: Daten-Export und -Import

Aufgabe:

  1. Exportiere alle gestoppten Dienste in eine JSON-Datei
  2. Importiere die Daten wieder
  3. Zeige die Anzahl der gestoppten Dienste an
  4. Erstelle eine formatierte Tabelle mit den ersten 5

Lösung anzeigen

# Exportieren
Get-Service | 
    Where-Object Status -eq 'Stopped' |
    Select-Object Name, DisplayName, Status |
    ConvertTo-Json | 
    Out-File gestoppt.json

# Importieren
$dienste = Get-Content gestoppt.json | ConvertFrom-Json

# Anzahl
Write-Host "Anzahl gestoppter Dienste: $($dienste.Count)"

# Tabelle
$dienste | Select-Object -First 5 | Format-Table -AutoSize

Übung 6: Fortgeschrittene Pipeline

Aufgabe: Erstelle ein Skript, das:

  1. Alle Dateien im Downloads-Ordner findet
  2. Nach Dateityp (Extension) gruppiert
  3. Für jeden Dateityp die Anzahl und Gesamtgröße berechnet
  4. Das Ergebnis sortiert nach Gesamtgröße
  5. Als CSV exportiert

Lösung anzeigen

Get-ChildItem ~\Downloads -File |
    Group-Object Extension |
    Select-Object @{N='Dateityp'; E={$_.Name}},
                  @{N='Anzahl'; E={$_.Count}},
                  @{N='GesamtgrößeMB'; E={[math]::Round(($_.Group | Measure-Object -Property Length -Sum).Sum / 1MB, 2)}} |
    Sort-Object GesamtgrößeMB -Descending |
    Export-Csv downloads_statistik.csv -NoTypeInformation

# Ergebnis auch anzeigen
Import-Csv downloads_statistik.csv | Format-Table -AutoSize

Zusammenfassung

In diesem Kurs hast du gelernt:

✓ Wie die PowerShell-Pipeline funktioniert und warum sie objektorientiert ist ✓ Objekte mit Get-Member zu untersuchen ✓ Daten mit Where-Object zu filtern ✓ Eigenschaften mit Select-Object auszuwählen ✓ Ergebnisse mit Sort-Object zu sortieren ✓ Statistiken mit Measure-Object zu berechnen ✓ Ausgaben mit Format-Cmdlets zu formatieren ✓ Daten in verschiedenen Formaten zu exportieren und importieren

Wichtige Cmdlets aus Kurs 2

Cmdlet Zweck Beispiel
Get-Member Objekte untersuchen Get-Member
Where-Object Filtern Where-Object Status -eq 'Running'
Select-Object Eigenschaften wählen Select-Object Name, CPU
Sort-Object Sortieren Sort-Object CPU -Descending
Measure-Object Statistiken Measure-Object -Sum -Average
Format-Table Tabelle Format-Table -AutoSize
Format-List Liste Format-List *
Export-Csv CSV exportieren Export-Csv daten.csv
ConvertTo-Json JSON erstellen ConvertTo-Json
Out-GridView GUI-Tabelle Out-GridView

Pipeline-Best-Practices

DO:

  • Verwende die Pipeline für Datenverarbeitung
  • Filtere so früh wie möglich (Where-Object am Anfang)
  • Format-Cmdlets immer am Ende
  • Verwende sinnvolle Variablennamen bei Zwischenspeicherung
  • Nutze Select-Object, um nur benötigte Eigenschaften zu behalten

DON'T:

  • Keine Format-Cmdlets in der Mitte der Pipeline
  • Nicht unnötig viele Objekte durch die gesamte Pipeline schicken
  • Nicht zu viele Pipe-Stufen ohne Zwischenvariablen (Lesbarkeit!)
  • Keine Formatierung vor dem Export

Nächste Schritte

Im nächsten Kurs lernst du:

  • Variablen richtig einsetzen
  • Mit verschiedenen Datentypen arbeiten
  • Arrays und Hashtables verwenden
  • Datenstrukturen effektiv nutzen

Zusätzliche Ressourcen

Cheat Sheet - Pipeline

# Grundmuster
Get-Command | Where-Object | Select-Object | Sort-Object | Format-Table

# Objekte untersuchen
Get-Process | Get-Member
Get-Service | Get-Member -MemberType Property

# Filtern
Where-Object Status -eq 'Running'
Where-Object {$_.CPU -gt 10 -and $_.Name -like "chrome*"}

# Auswählen
Select-Object Name, CPU
Select-Object -First 10
Select-Object @{N='Custom'; E={$_.Property * 2}}

# Sortieren
Sort-Object Name
Sort-Object CPU -Descending

# Messen
Measure-Object
Measure-Object -Property Length -Sum -Average

# Formatieren
Format-Table -AutoSize
Format-List *
Out-GridView

# Exportieren
Export-Csv daten.csv -NoTypeInformation
ConvertTo-Json | Out-File daten.json
Export-Clixml daten.xml

Häufige Patterns

# Top-N Pattern
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

# Gruppierung
Get-ChildItem | Group-Object Extension | Select-Object Name, Count

# Eindeutige Werte
Get-Process | Select-Object ProcessName -Unique

# Zählen
(Get-Service | Where-Object Status -eq 'Running').Count

# Summe berechnen
(Get-ChildItem | Measure-Object -Property Length -Sum).Sum / 1GB

# Eigenschaften hinzufügen
Get-Process | Select-Object *, @{N='MemMB'; E={$_.WS/1MB}}

Übungsaufgaben für zuhause

  1. Erstelle einen Bericht über alle Dienste auf deinem System (Status, StartType, Anzahl pro Status)
  2. Finde die 20 größten Dateien auf deinem System und speichere sie als HTML-Bericht
  3. Analysiere deine Prozesse: Erstelle Statistiken über CPU, RAM und Anzahl nach Prozessname
  4. Erstelle ein Skript, das alle .txt-Dateien in einem Ordner findet, die älter als 30 Tage sind und deren Gesamtgröße berechnet
  5. Experimentiere mit Out-GridView: Lade Prozesse hinein und nutze die Filter-Funktionen

Debugging-Tipps

Wenn deine Pipeline nicht funktioniert:

# Schritt für Schritt testen
Get-Service  # Funktioniert?
Get-Service | Where-Object Status -eq 'Running'  # Funktioniert?
Get-Service | Where-Object Status -eq 'Running' | Sort-Object Name  # Funktioniert?

# Objekt-Typ prüfen
Get-Service | Get-Member  # Was ist der TypeName?

# Zwischenergebnisse speichern
$dienste = Get-Service | Where-Object Status -eq 'Running'
$dienste | Sort-Object Name

# Eigenschaften prüfen
Get-Process | Select-Object -First 1 | Format-List *

Leistungs-Tipps

Langsam Schnell Grund
Get-ChildItem -Recurse dann Where-Object Get-ChildItem -Recurse -Filter Filter auf Server-Seite
ForEach-Object für einfache Filter Where-Object Optimiert für Filterung
Format-Table in Mitte der Pipeline Format-Table am Ende Formatierungsobjekte blockieren
Alle Eigenschaften durchschleifen Select-Object früh nutzen Weniger Daten = schneller

Praktische Beispiele

# 1. Speicherverbrauch-Alarm
Get-Process | 
    Where-Object WorkingSet -gt 500MB | 
    Sort-Object WorkingSet -Descending |
    Select-Object Name, @{N='RAM(GB)'; E={[math]::Round($_.WS/1GB, 2)}} |
    Format-Table -AutoSize

# 2. Dienst-Überwachung
Get-Service | 
    Where-Object {$_.Status -eq 'Stopped' -and $_.StartType -eq 'Automatic'} |
    Select-Object Name, DisplayName, Status |
    Export-Csv gestoppte_auto_dienste.csv -NoTypeInformation

# 3. Festplatten-Analyse
Get-ChildItem C:\ -Recurse -File -ErrorAction SilentlyContinue |
    Group-Object Extension |
    Select-Object @{N='Typ'; E={if($_.Name){"$($_.Name)"}else{"Kein"}}},
                  @{N='Anzahl'; E={$_.Count}},
                  @{N='Größe(GB)'; E={[math]::Round(($_.Group | Measure-Object Length -Sum).Sum/1GB, 2)}} |
    Sort-Object 'Größe(GB)' -Descending |
    Out-GridView -Title "Dateityp-Analyse"

# 4. Prozess-Monitor für bestimmte Anwendung
while($true) {
    Clear-Host
    Get-Process chrome -ErrorAction SilentlyContinue |
        Select-Object Name, Id, CPU, 
            @{N='RAM(MB)'; E={[math]::Round($_.WS/1MB, 2)}} |
        Format-Table -AutoSize
    Start-Sleep -Seconds 2
}

# 5. Event-Log Analyse
Get-EventLog -LogName System -EntryType Error -Newest 50 |
    Group-Object Source |
    Select-Object @{N='Fehlerquelle'; E={$_.Name}},
                  @{N='Anzahl'; E={$_.Count}} |
    Sort-Object Anzahl -Descending |
    Format-Table -AutoSize

# 6. Netzwerk-Verbindungen
Get-NetTCPConnection -State Established |
    Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State, 
        @{N='Prozess'; E={(Get-Process -Id $_.OwningProcess).ProcessName}} |
    Sort-Object Prozess |
    Format-Table -AutoSize

# 7. Aufräum-Bericht
$ordner = "$env:TEMP"
$vorher = (Get-ChildItem $ordner -Recurse -File | Measure-Object Length -Sum).Sum
Get-ChildItem $ordner -Recurse -File -Filter "*.tmp" | Remove-Item -Force
$nachher = (Get-ChildItem $ordner -Recurse -File | Measure-Object Length -Sum).Sum
$gespart = [math]::Round(($vorher - $nachher) / 1MB, 2)
Write-Host "Gespart: $gespart MB"

Interaktive Übung: Out-GridView

Probiere diese interaktiven Beispiele:

# 1. Prozesse filtern und auswählen
Get-Process | 
    Select-Object Name, Id, CPU, 
        @{N='RAM(MB)'; E={[math]::Round($_.WS/1MB)}} |
    Out-GridView -Title "Wähle Prozesse zum Beenden" -PassThru |
    Stop-Process -WhatIf  # -WhatIf für Simulation

# 2. Dienste interaktiv starten
Get-Service | 
    Where-Object Status -eq 'Stopped' |
    Out-GridView -Title "Wähle Dienste zum Starten" -PassThru |
    Start-Service -WhatIf

# 3. Dateien zum Löschen auswählen
Get-ChildItem C:\Temp -Recurse -File |
    Where-Object Length -gt 10MB |
    Select-Object Name, 
        @{N='Größe(MB)'; E={[math]::Round($_.Length/1MB, 2)}},
        LastWriteTime, FullName |
    Out-GridView -Title "Große Dateien - Zum Löschen auswählen" -PassThru |
    Remove-Item -WhatIf
💡
Tipp
-PassThru bei Out-GridView ermöglicht die Auswahl von Zeilen, die dann weitergeleitet werden!

Erweiterte Pipeline-Techniken

# ForEach-Object für Transformationen
Get-ChildItem *.txt | ForEach-Object {
    $neuerName = $_.Name -replace "alt", "neu"
    Rename-Item $_.FullName -NewName $neuerName -WhatIf
}

# Tee-Object - Pipeline aufteilen
Get-Process | 
    Tee-Object -FilePath prozesse.csv |
    Where-Object CPU -gt 10 |
    Format-Table

# Group-Object mit Berechnungen
Get-Process |
    Group-Object ProcessName |
    Select-Object Name,
        Count,
        @{N='TotalRAM(MB)'; E={[math]::Round(($_.Group | Measure-Object WS -Sum).Sum/1MB)}}

# Compare-Object - Unterschiede finden
$vorher = Get-Process | Select-Object Name
Start-Process notepad
Start-Sleep 2
$nachher = Get-Process | Select-Object Name
Compare-Object $vorher $nachher -Property Name

Fehler-Vermeidung

Häufige Fehler und Lösungen:

# FEHLER: Format-Table in der Mitte
Get-Process | Format-Table | Where-Object CPU -gt 10  # ❌ Funktioniert nicht!

# RICHTIG:
Get-Process | Where-Object CPU -gt 10 | Format-Table  # ✓

# FEHLER: Falsche Eigenschaft
Get-Process | Where-Object Memory -gt 100MB  # ❌ Eigenschaft existiert nicht

# RICHTIG: Erst mit Get-Member prüfen
Get-Process | Get-Member
Get-Process | Where-Object WorkingSet -gt 100MB  # ✓

# FEHLER: Vergleich ohne Operator
Get-Service | Where-Object Status 'Running'  # ❌ Fehlt -eq

# RICHTIG:
Get-Service | Where-Object Status -eq 'Running'  # ✓

# FEHLER: Methode statt Eigenschaft
Get-Date | Select-Object AddDays(7)  # ❌ Methoden müssen aufgerufen werden

# RICHTIG:
(Get-Date).AddDays(7)  # ✓
✓
Erfolg
Glückwunsch! Du hast Kurs 2 abgeschlossen und beherrschst jetzt die PowerShell-Pipeline!