Die textuelle Ausgabe von Befehlen im PowerShell-Interpreter ist lediglich eine Methode zur Darstellung von Informationen in einer für Menschen verständlichen Form. Tatsächlich basiert die Umgebung auf der Arbeit mit Objekten: Cmdlets und Funktionen erhalten diese als Eingabe und geben sie als Ausgabe zurück. Objekte in PowerShell
Inhaltsverzeichnis:
Struktur von Objekten anzeigen
Wir erinnern daran, dass ein Objekt eine Ansammlung von Datenfeldern (Eigenschaften, Ereignisse usw.) und deren Verarbeitungsmethoden (Methoden) darstellt. Die Struktur wird durch den Typ definiert, der in der Regel auf den in der einheitlichen Plattform .NET Core verwendeten Klassen basiert. Außerdem besteht die Möglichkeit, mit COM-, CIM (WMI) und ADSI-Objekten zu arbeiten. Eigenschaften und Methoden sind notwendig, um verschiedene Aktionen auf den Daten auszuführen. Darüber hinaus können in PowerShell Objekte als Argumente an Funktionen und Cmdlets übergeben und ihre Werte Variablen zugewiesen werden, und es gibt auch (Pipeline). Jeder Befehl in der Pipeline überträgt seine Ausgabe nacheinander an den nächsten — Objekt für Objekt. Für die Verarbeitung können kompilierte Cmdlets verwendet oder eigene , um verschiedene Manipulationen mit Objekten in der Pipeline durchzuführen: Filtern, Sortieren, Gruppieren und sogar deren Struktur zu ändern. Die Datenübertragung in diesem Format hat einen erheblichen Vorteil: Das empfangende Team muss keinen syntaktischen Parser für den Byte-Stream (Text) verwenden, sämtliche benötigten Informationen können leicht durch den Zugriff auf die entsprechenden Eigenschaften und Methoden extrahiert werden.
Objekte filtern
Um ein Beispiel zu geben, führen wir das Cmdlet Get-Process aus, das Informationen über die aktiven Prozesse im System bereitstellt:
Es wird formatierte Textdaten auf dem Bildschirm ausgeben, die keinen Überblick über die Eigenschaften und Methoden der zurückgegebenen Objekte bieten. Um die Ausgabe detailliert zu analysieren, müssen wir lernen, die Struktur der Objekte zu untersuchen, und hierbei hilft uns das Cmdlet Get-Member:
Get-Process | Get-Member 
Hier sehen wir bereits den Typ und die Struktur, und mit zusätzlichen Parametern können wir beispielsweise nur die Eigenschaften des übergebenen Objekts anzeigen:
Get-Process | Get-Member -MemberType PropertyDieses Wissen wird benötigt, um Aufgaben der Administration im interaktiven Modus zu lösen oder um eigene Skripte zu schreiben: zum Beispiel, um Informationen über festgefahrene Prozesse anhand der Eigenschaft 'Responding' zu erhalten.
Objekte sortieren
PowerShell ermöglicht es, Objekte, die bestimmten Kriterien entsprechen, durch die Pipeline zu leiten:
Where-Object { Skriptblock }Das Ergebnis der Ausführung des Skriptblocks in geschweiften Klammern muss ein logischer Wert sein. Ist dieser wahr ($true), wird das Objekt, das an das Where-Object-Cmdlet übergeben wird, weitergegeben, andernfalls (Wert $false) wird es entfernt. Zum Beispiel geben wir eine Liste der gestoppten Windows Server-Dienste aus, d. h. solche, bei denen die Eigenschaft 'Status' den Wert 'Stopped' hat:
Get-Service | Where-Object {$_.Status -eq "Stopped"} 
Hier sehen wir erneut eine textuelle Darstellung, aber es ist nicht schwer zu verstehen, welchen Typ und innere Struktur die durch die Pipeline geleiteten Objekte haben:
Get-Service | Where-Object {$_.Status -eq "Stopped"} | Get-Member 
Objekte und ihre Teile auswählen
Bei der Verarbeitung von Objekten im Datenstrom ist oft eine Sortierung nötig. Dem Cmdlet Sort-Object werden die Namen der Sortierschlüssel übergeben, und es gibt die Objekte zurück, die nach ihren Werten sortiert sind. Der Output der laufenden Prozesse kann leicht nach der verbrauchten CPU-Zeit (Eigenschaft cpu) sortiert werden:
Get-Process | Sort-Object –Property cpuDer Parameter -Property kann beim Aufruf des Cmdlets Sort-Object weggelassen werden — er wird standardmäßig verwendet. Für eine umgekehrte Sortierung wird der Parameter -Descending verwendet:
Get-Process | Sort-Object cpu -Descending 
ForEach-Object, Group-Object und Measure-Object
Das Cmdlet Select-Object ermöglicht es, eine bestimmte Anzahl von Objekten am Anfang oder am Ende des Datenstroms mit den Parametern -First oder -Last auszuwählen. Damit können einzelne Objekte oder bestimmte Eigenschaften ausgewählt und daraus neue Objekte erstellt werden. Lassen Sie uns die Funktionsweise des Cmdlets anhand einfacher Beispiele erklären.
Der folgende Befehl gibt Informationen über die 10 Prozesse aus, die den größten Anteil des Arbeitsspeichers verbrauchen (Eigenschaft WS):
Get-Process | Sort-Object WS -Descending | Select-Object -First 10 
Es ist möglich, nur bestimmte Eigenschaften der durch den Datenstrom fließenden Objekte auszuwählen und daraus neue zu erstellen:
Get-Process | Select-Object ProcessName, Id -First 1Das Ergebnis der Pipeline wird ein neues Objekt sein, dessen Struktur sich von der Struktur des von Get-Process zurückgegebenen Objekts unterscheidet. Lassen Sie uns dies mit Get-Member überprüfen:
Get-Process | Select-Object ProcessName, Id -First 1 | Get-Member 
Beachten Sie, dass Select-Object ein einzelnes Objekt zurückgibt (-First 1), das nur zwei von uns angegebenen Felder hat: deren Werte wurden vom ersten in die Pipeline übergebenen Objekt des Get-Process Cmdlets übernommen. Eine der Methoden zur Erstellung von Objekten in PowerShell-Skripten basiert auf der Nutzung von Select-Object:
$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType() 
Mit Select-Object können berechnete Eigenschaften zu Objekten hinzugefügt werden, die in der Form präsentiert werden müssen . Dabei entspricht der Wert des ersten Schlüssels dem Namen der Eigenschaft, und der Wert des zweiten Schlüssels ist der Wert der Eigenschaft für das aktuelle Element in der Pipeline:
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} 
Schauen wir uns die Struktur der durch die Pipeline übergebenen Objekte an:
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} | Get-Member 
Erstellung von .NET- und COM-Objekten (New-Object)
Es gibt auch andere Cmdlets zur Arbeit mit Objekten. Hier sind drei der nützlichsten:
ForEach-Object erlaubt es, Code in PowerShell für jedes Objekt in der Pipeline auszuführen:
ForEach-Object { Skriptblock }Group-Object gruppiert Objekte nach dem Wert eines Attributs:
Group-Object PropertyNameWenn Sie es mit der Option -NoElement ausführen, können Sie die Anzahl der Elemente in den Gruppen erfahren.
Measure-Object aggregiert verschiedene Zusammenfassungsparameter basierend auf den Werten der Felder der Objekte in der Pipeline (berechnet die Summe und findet die minimalen, maximalen oder durchschnittlichen Werte):
Measure-Object -Property PropertyName -Minimum -Maximum -Average -SumDie besprochenen Cmdlets werden normalerweise interaktiv verwendet, während in Skripten oft Blöcke wie Begin, Process und End erstellt werden.
Aufruf statischer Methoden
Es gibt zahlreiche Softwarekomponenten mit .NET Core- und COM-Schnittstellen, die für Systemadministratoren nützlich sind. Mit der Klasse System.Diagnostics.EventLog kann man die Systemprotokolle direkt aus Windows PowerShell verwalten. Lassen Sie uns ein Beispiel zur Erstellung einer Instanz dieser Klasse mit dem Cmdlet New-Object und dem Parameter -TypeName durchgehen:
New-Object -TypeName System.Diagnostics.EventLog 
Da wir kein spezifisches Ereignisprotokoll angegeben haben, enthält die erhaltene Klasseninstanz keine Daten. Um dies zu ändern, muss während der Erstellung eine spezielle Konstruktormethode mit dem Parameter -ArgumentList aufgerufen werden. Wenn wir auf das Anwendungsprotokoll zugreifen möchten, sollte der Konstruktor den String "Application" als Argument übergeben bekommen:
$AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application
$AppLog 
Bitte beachten Sie: Die Ausgabe des Befehls haben wir in der Variablen $AppLog gespeichert. Während im interaktiven Modus normalerweise Pipes verwendet werden, erfordert das Schreiben von Skripten häufig die Speicherung einer Referenz auf das Objekt. Außerdem sind die grundlegenden Klassen von .NET Core im Namensraum System enthalten: PowerShell sucht standardmäßig nach den angegebenen Typen darin, daher ist es völlig korrekt, Diagnostics.EventLog anstelle von System.Diagnostics.EventLog zu schreiben.
Für die Arbeit mit dem Protokoll können die entsprechenden Methoden aufgerufen werden:
$AppLog | Get-Member -MemberType Method 
Angenommen, es wird mit der Methode Clear() gelöscht, sofern die Zugriffsrechte vorhanden sind:
$AppLog.Clear()Das Cmdlet New-Object wird auch zur Arbeit mit COM-Komponenten verwendet. Es gibt viele davon – von den mit dem Windows-Server gelieferten Skriptbibliotheken bis hin zu ActiveX-Anwendungen, wie zum Beispiel Internet Explorer. Um ein COM-Objekt zu erstellen, muss der Parameter -ComObject mit der Programmkennung ProgId der gewünschten Klasse angegeben werden:
New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObjectFür die Erstellung eigener Objekte mit beliebiger Struktur wirkt die Verwendung von New-Object veraltet und umständlich; dieses Cmdlet wird zur Arbeit mit externen Softwarekomponenten außerhalb von PowerShell verwendet. In den nächsten Artikeln werden wir dieses Thema detaillierter behandeln. Neben .NET- und COM-Objekten werden wir auch CIM-Objekte (WMI) und ADSI-Objekte untersuchen.
Typ PSCustomObject
Instanzen einiger Klassen des .NET Core können nicht erstellt werden: Dazu gehören System.Environment und System.Math. Sie sind Sie enthalten ausschließlich statische Eigenschaften und Methoden. Im Grunde handelt es sich um Referenzbibliotheken, die ohne Objekterstellung verwendet werden. Ein statischer Klassenzugriff kann über einen Literal erfolgen, wobei der Typname in eckige Klammern eingeschlossen wird. Wenn wir die Struktur des Objekts mit Get-Member betrachten, sehen wir den Typ System.RuntimeType anstelle von System.Environment:
[System.Environment] | Get-Member 
Um nur die statischen Elemente anzuzeigen, muss Get-Member mit dem Parameter -Static aufgerufen werden (beachten Sie den Objekttyp):
[System.Environment] | Get-Member -Static 
Für den Zugriff auf statische Eigenschaften und Methoden werden zwei aufeinanderfolgende Doppelpunkte anstelle eines Punktes nach dem Literal verwendet:
[System.Environment]::OSVersionOder
$test=[System.Math]::Sqrt(25)
$test
$test.GetType() 
Eigene Klassen erstellen
Unter den zahlreichen in PowerShell verfügbaren Datentypen ist PSCustomObject besonders hervorzuheben, da es für die Speicherung von Objekten mit beliebiger Struktur entwickelt wurde. Die Erstellung eines solchen Objekts mit dem Cmdlet New-Object gilt als klassischer, aber umständlicher und veralteter Ansatz:
$object = New-Object –TypeName PSCustomObject -Property @{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'}
Betrachten wir die Struktur des Objekts:
$object | Get-Member 
Ab PowerShell 3.0 steht auch eine andere Syntax zur Verfügung:
$object = [PSCustomObject]@{Name = 'Ivan Danko';
City = 'Moskau';
Country = 'Russland'
}
Auf die Daten kann auf eine der folgenden gleichwertigen Arten zugegriffen werden:
$object.Name
$object.'Name'
$value = 'Name'
$object.$value
Nehmen wir ein Beispiel für die Umwandlung einer bestehenden Hashtabelle in ein Objekt:
$hash = @{'Name'='Ivan Danko'; 'City'='Moskau'; 'Country'='Russland'}
$hash.GetType()
$object = [pscustomobject]$hash
$object.GetType()
Ein Nachteil dieser Objekte ist, dass die Reihenfolge ihrer Eigenschaften sich ändern kann. Um dies zu vermeiden, sollte man das Attribut [ordered] verwenden:
$object = [PSCustomObject][ordered]@{Name = 'Ivan Danko';
City = 'Moskau';
Country = 'Russland'
}
Es gibt auch andere Möglichkeiten, ein Objekt zu erstellen: Wir haben oben die Verwendung des Cmdlets besprochen. Nun bleibt uns, das Hinzufügen und Entfernen von Elementen zu klären. Das ist für das vorherige Beispielobjekt recht einfach:
$object | Add-Member –MemberType NoteProperty –Name Age –Value 33
$object | Get-Member
Das Cmdlet Add-Member ermöglicht es, dem zuvor erstellten Objekt $object nicht nur Eigenschaften, sondern auch Methoden hinzuzufügen, indem man die Konstruktion "-MemberType ScriptMethod:" verwendet.
$ScriptBlock = {
# Code
}
$object | Add-Member -Name "MyMethod" -MemberType ScriptMethod -Value $ScriptBlock
$object | Get-Member
Bitte beachten Sie: Wir haben die Variable $ScriptBlock vom Typ ScriptBlock verwendet, um den Code der neuen Methode zu speichern.
Zum Entfernen von Eigenschaften verwenden Sie die entsprechende Methode:
$object.psobject.properties.remove('Name')
Erstellung eigener Klassen
In PowerShell 5.0 wurde die Möglichkeit eingeführt, mit einer dem objektorientierten Programmierstil entsprechenden Syntax zu definieren. Dafür gibt es das Schlüsselwort Class, gefolgt vom Klassennamen und der Beschreibung des Klassenkörpers in geschweiften Klammern:
class MyClass
{
# Klassenkörper
}
Dies ist ein echter .NET Core-Typ, dessen Eigenschaften, Methoden und andere Elemente im Körper beschrieben werden. Hier ist ein Beispiel für die Definition einer einfachen Klasse:
class MyClass
{
[string]$Name
[string]$City
[string]$Country
}
Um ein Objekt (eine Instanz der Klasse) zu erstellen, verwenden Sie das Cmdlet , oder den Literatortyp [MyClass] und new (Standardkonstruktor):
$object = New-Object -TypeName MyClassoder
$object = [MyClass]::new()Analysieren wir die Struktur des Objekts:
$object | Get-Member 
Denken Sie daran, dass die Sichtbarkeit wichtig ist: Es ist nicht möglich, auf den Typnamen als String zu verweisen oder den Typliteral außerhalb des Skripts oder Moduls zu verwenden, in dem die Klasse definiert ist. Allerdings können Funktionen Instanzen der Klasse (Objekte) zurückgeben, die außerhalb des Moduls oder Skripts verfügbar sind.
Nachdem wir ein Objekt erstellt haben, fügen wir dessen Eigenschaften hinzu:
$object.Name = 'Ivan Danko'
$object.City = 'Moskau'
$object.Country = 'Russland'
$object
Es ist wichtig zu beachten, dass in der Klassendefinition nicht nur die Typen der Eigenschaften, sondern auch deren Standardwerte festgelegt werden:
class Example
{
[string]$Name = 'John Doe'
}
Die Beschreibung einer Klassenmethode ähnelt der Beschreibung einer Funktion, jedoch ohne das Schlüsselwort function zu verwenden. Wie bei einer Funktion können auch bei Methoden bei Bedarf Parameter übergeben werden:
class MyClass
{
[string]$Name
[string]$City
[string]$Country
#Beschreibung der Methode
Smile([bool]$param1)
{
If($param1) {
Write-Host ':)'
}
}
}
Jetzt kann unser Klassenvertreter lächeln:
$object = [MyClass]::new()
$object.Smile($true)
Methoden können überladen werden; außerdem kann eine Klasse , sowie Konstruktoren, deren Namen mit dem Namen der Klasse übereinstimmen. Eine im PowerShell-Skript oder -Modul definierte Klasse kann als Basisklasse für eine andere dienen – so wird die Vererbung realisiert. Dabei können bereits vorhandene .NET-Klassen als Basis verwendet werden.
class MyClass2 : MyClass
{
#Der Körper der neuen Klasse, die MyClass als Basisklasse hat
}
[MyClass2]::new().Smile($true)
Unsere Beschreibung der Arbeit mit Objekten in PowerShell kann nicht als umfassend bezeichnet werden. In den kommenden Veröffentlichungen werden wir sie anhand praktischer Beispiele vertiefen: Der fünfte Artikel der Reihe wird sich mit Fragen zur Integration von PowerShell mit Drittanbieter-Softwarekomponenten befassen. Frühere Teile finden Sie über die Links unten.
Quelle: habr.com
