Den Textausgang vu Kommandoen an der PowerShell Dolmetscherfenster ass just e Wee fir Informatioun an enger Form ze weisen, déi fir mënschlech Perceptioun gëeegent ass. Eigentlech Mëttwoch fir mat Objeten ze schaffen: cmdlets a Funktiounen kréien se als Input an , an déi Variabel Zorte sinn interaktiv an Scripten baséiert op .NET Klassen. Am véierten Artikel vun der Serie wäerte mir d'Aarbecht mat Objeten méi detailléiert studéieren.
Beschreiwung:
Objekter an PowerShell
Loosst eis drun erënneren datt en Objet eng Sammlung vun Datefelder ass (Eegeschafte, Eventer, etc.) a Methoden fir se ze veraarbecht (Methoden). Seng Struktur gëtt vun engem Typ spezifizéiert, deen normalerweis op Klassen baséiert, déi an der vereenegt .NET Core Plattform benotzt ginn. Et ass och méiglech mat COM, CIM (WMI) an ADSI Objeten ze schaffen. Eegeschaften a Methode si gebraucht fir verschidden Handlungen op Daten auszeféieren; Zousätzlech, an PowerShell kënnen Objeten als Argumenter u Funktiounen an cmdlets weiderginn, hir Wäerter un Variabelen zougewisen ginn, an et gëtt och (Fuerder oder Pipeline). All Kommando an der Pipeline passéiert säin Output un deen nächsten am Tour, Objet fir Objet. Fir d'Veraarbechtung kënnt Dir kompiléiert cmdlets benotzen oder Är eege erstellen verschidde Manipulatioune mat Objeten an der Pipeline auszeféieren: Filteren, Sortéieren, Gruppéieren a souguer hir Struktur änneren. D'Transmissioun vun Donnéeën an dëser Form huet e seriöse Virdeel: d'Empfangsteam brauch net de Byte Stream (Text) ze analyséieren, all déi néideg Informatioun gëtt einfach erëmfonnt andeems Dir déi entspriechend Eegeschaften a Methoden rufft.
Kuckt d'Struktur vun Objeten
Zum Beispill, loosst eis de Get-Process cmdlet lafen, deen Iech erlaabt Informatiounen iwwer d'Prozesser am System ze kréien:
Et wäert e puer formatéiert Textdaten weisen, déi keng Ahnung iwwer d'Eegeschafte vun de zréckginn Objeten an hir Methoden ginn. Fir d'Ausgab ze feinjustéieren, musse mir léieren wéi d'Struktur vun Objeten ënnersicht gëtt, an de Get-Member cmdlet hëlleft eis mat dësem:
Get-Process | Get-Member
Hei gesi mer schonn d'Art an d'Struktur, a mat der Hëllef vun zousätzleche Parameteren kënne mir zum Beispill nëmmen d'Eegeschafte vum Objet weisen, deen am Input abegraff ass:
Get-Process | Get-Member -MemberType PropertyDëst Wësse wäert gebraucht ginn fir Administratiounsproblemer interaktiv ze léisen oder Är eege Skripte ze schreiwen: zum Beispill fir Informatiounen iwwer hängt Prozesser mat der Reaktiounseigenschaft ze kréien.
Filteren Objeten
PowerShell erlaabt datt Objekter déi e bestëmmte Bedingung erfëllen duerch eng Pipeline passéiert ginn:
Where-Object { блок сценария }D'Resultat vun der Ausféierung vum Skriptblock bannent de Klammeren muss e boolesche Wäert sinn. Wann et wouer ass ($true), gëtt den Objet, deen an de Where-Object cmdlet Input ass, laanscht d'Pipeline passéiert, soss ($false) gëtt et geläscht. Zum Beispill, loosst eis eng Lëscht vun gestoppt Windows Server Servicer weisen, d.h. déi, deenen hir Status Eegeschafte op "Stopped" gesat ass:
Get-Service | Where-Object {$_.Status -eq "Stopped"}
Hei gesi mir nach eng Kéier eng textuell Representatioun, awer wann Dir wëllt d'Art an d'intern Struktur vun den Objeten, déi duerch d'Pipeline passéieren, verstoen, ass et net schwéier:
Get-Service | Where-Object {$_.Status -eq "Stopped"} | Get-Member
Zortéieren Objeten
Beim Pipelineveraarbechtung vun Objeten ass et dacks e Besoin fir se ze sortéieren. De Sort-Object cmdlet gëtt d'Nimm vun den Eegeschaften (Sortéierungsschlësselen) iwwerginn a gëtt Objeten zréck, déi no hire Wäerter bestallt sinn. Et ass einfach d'Output vu lafende Prozesser no CPU Zäit ze sortéieren (Cpu Eegeschafte):
Get-Process | Sort-Object –Property cpuDen -Property Parameter kann ausgeliwwert ginn wann Dir de Sort-Object cmdlet rufft; et gëtt als Standard benotzt. Fir ëmgedréint Sortéierung benotzt den -Descending Parameter:
Get-Process | Sort-Object cpu -Descending
Auswiel vun Objeten an hir Deeler
De Select-Object cmdlet erlaabt Iech eng spezifesch Unzuel vun Objeten um Ufank oder Enn vun enger Pipeline mat den -First oder -Last Parameteren ze wielen. Mat senger Hëllef kënnt Dir eenzel Objeten oder bestëmmte Properties auswielen, an och nei Objeten op Basis vun hinnen erstellen. Loosst eis kucken wéi de cmdlet funktionnéiert mat einfache Beispiller.
De folgende Kommando weist Informatioun iwwer déi 10 Prozesser déi de maximale Betrag vum RAM verbrauchen (WS Property):
Get-Process | Sort-Object WS -Descending | Select-Object -First 10
Dir kënnt nëmme bestëmmte Eegeschafte vun Objeten auswielen, déi duerch d'Pipeline passéieren an nei erstellen op Basis vun hinnen:
Get-Process | Select-Object ProcessName, Id -First 1Als Resultat vun der Operatioun vun der Pipeline kréie mir en neien Objet, d'Struktur vun deem wäert ënnerscheeden vun der Struktur zréck vum Get-Process cmdlet. Loosst eis dëst mat Get-Member verifizéieren:
Get-Process | Select-Object ProcessName, Id -First 1 | Get-Member
Notéiert datt Select-Object en eenzegen Objet (-First 1) zréckkënnt, deen nëmmen zwee vun de Felder huet, déi mir spezifizéiert hunn: hir Wäerter goufen aus dem éischten Objet kopéiert, deen duerch de Get-Process cmdlet an d'Pipeline passéiert ass. Ee vun de Weeër fir Objekter an PowerShell Scripten ze kreéieren baséiert op d'Benotzung vu Select-Object:
$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType()
Mat Select-Object kënnt Dir berechent Eegeschafte fir Objeten addéieren, déi als representéiert musse ginn . An dësem Fall entsprécht de Wäert vu sengem éischte Schlëssel dem Numm vun der Immobilie, an de Wäert vum zweete Schlëssel entsprécht dem Wäert vun der Immobilie fir dat aktuellt Pipeline-Element:
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}}
Loosst eis d'Struktur vun Objeten kucken, déi duerch de Fërderband passéieren:
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} | Get-Member
ForEach-Object, Group-Object a Mooss-Object
Et ginn aner cmdlets fir mat Objeten ze schaffen. Als Beispill, loosst eis iwwer déi dräi nëtzlechst schwätzen:
ForEach-Objet erlaabt Iech PowerShell Code fir all Objet an der Pipeline auszeféieren:
ForEach-Object { блок сценария }Group-Objet gruppéiert Objekter no Eegeschafte Wäert:
Group-Object PropertyNameWann Dir et mam -NoElement Parameter leeft, kënnt Dir d'Zuel vun den Elementer an de Gruppen erausfannen.
Mooss-Objet aggregéiert verschidde Resuméparameter duerch Objektfeldwäerter an der Pipeline (berechent d'Zomm, an fënnt och de Minimum, Maximum oder Duerchschnëttswäert):
Measure-Object -Property PropertyName -Minimum -Maximum -Average -SumTypesch ginn déi diskutéiert cmdlets interaktiv benotzt, a ginn dacks a Skripte erstallt. mat Start-, Prozess- an Endblocken.
NET an COM Objekter erstellen (New-Object)
Et gi vill Software Komponente mat .NET Core an COM Schnëttplazen datt fir System Administrateuren nëtzlech sinn. Mat der Klass System.Diagnostics.EventLog kënnt Dir Systemprotokoller direkt vu Windows PowerShell verwalten. Loosst eis e Beispill kucken fir eng Instanz vun dëser Klass ze kreéieren mam New-Object cmdlet mam -TypeName Parameter:
New-Object -TypeName System.Diagnostics.EventLog
Well mir net e spezifeschen Eventprotokoll uginn hunn, enthält déi resultéierend Instanz vun der Klass keng Daten. Fir dëst z'änneren, musst Dir eng speziell Konstruktormethod nennen während senger Schafung mam -ArgumentList Parameter. Wa mir Zougang zum Applikatiounsprotokoll kréien, sollte mir d'String "Applikatioun" als Argument un de Konstruktor passéieren:
$AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application
$AppLog
Maacht weg datt mir d'Ausgab vum Kommando an der $AppLog Variabel gespäichert hunn. Och wann Pipelines allgemeng am interaktiven Modus benotzt ginn, erfuerdert d'Schreiwen vun Scripten dacks eng Referenz op en Objet z'erhalen. Zousätzlech sinn d'Kär .NET Core Klassen am System Nummraum enthale: PowerShell sicht par défaut no spezifizéierten Typen dran, also schreift Diagnostics.EventLog amplaz System.Diagnostics.EventLog ganz korrekt.
Fir mam Log ze schaffen, kënnt Dir déi entspriechend Methoden benotzen:
$AppLog | Get-Member -MemberType Method
Loosst eis soen datt et duerch d'Clear () Method geläscht gëtt wann et Zougangsrechter gëtt:
$AppLog.Clear()Den New-Object cmdlet gëtt och benotzt fir mat COM Komponenten ze schaffen. Et gi ganz vill vun hinnen - vun de Bibliothéiken, déi mam Windows Skriptserver geliwwert ginn, bis ActiveX Uwendungen, wéi Internet Explorer. Fir e COM-Objet ze kreéieren, musst Dir den -ComObject-Parameter mat dem programmateschen ProgId vun der gewënschter Klass setzen:
New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObjectFir Är eege Objekter mat enger arbiträrer Struktur ze kreéieren, benotzt New-Object schéngt ze archaesch a ëmständlech; Dëse cmdlet gëtt benotzt fir mat Softwarekomponenten extern zu PowerShell ze schaffen. An zukünfteg Artikelen wäert dëst Thema méi am Detail diskutéiert ginn. Nieft .NET an COM Objete wäerte mir och CIM (WMI) an ADSI Objete Entdeckung.
Opruff statesch Methoden
E puer .NET Core Klassen kënnen net instantiéiert ginn, dorënner System.Environment a System.Math. Si sinn an enthalen nëmmen statesch Eegeschaften a Methoden. Dëst si wesentlech Referenzbibliothéiken déi benotzt ginn ouni Objekter ze kreéieren. Dir kënnt op eng statesch Klass duerch e wuertwiertlech referenzéieren andeems Dir den Typnumm a véiereckege Klammeren ëmschléit. Wéi och ëmmer, wa mir d'Struktur vum Objet mat Get-Member kucken, gesi mir den Typ System.RuntimeType amplaz System.Environment:
[System.Environment] | Get-Member
Fir nëmmen statesch Memberen ze gesinn, rufft Get-Member mam -Static Parameter un (notéiert den Objekttyp):
[System.Environment] | Get-Member -Static
Fir Zougang zu statesch Eegeschaften a Methoden ze benotzen, benotzt zwee konsekutiv Colonen amplaz vun enger Period no der wuertwiertlech:
[System.Environment]::OSVersionOr
$test=[System.Math]::Sqrt(25)
$test
$test.GetType()
Typ PSCustomObject
Ënnert de villen Datentypen, déi an PowerShell verfügbar sinn, ass et derwäert PSCustomObject ze ernimmen, entworf fir Objete mat enger arbiträrer Struktur ze späicheren. Esou en Objet erstellen mat dem New-Object cmdlet gëtt als klassesch ugesinn, awer ëmständlech an al Manéier:
$object = New-Object –TypeName PSCustomObject -Property @{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'}
Loosst eis d'Struktur vum Objet kucken:
$object | Get-Member
Vun PowerShell 3.0 un, ass eng aner Syntax verfügbar:
$object = [PSCustomObject]@{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'
}
Dir kënnt Zougang zu den Donnéeën op eng vun den gläichwäertege Weeër kréien:
$object.Name
$object.'Name'
$value = 'Name'
$object.$value
Hei ass e Beispill fir en existent hashable an en Objet ze konvertéieren:
$hash = @{'Name'='Ivan Danko'; 'City'='Moscow'; 'Country'='Russia'}
$hash.GetType()
$object = [pscustomobject]$hash
$object.GetType()
Ee vun den Nodeeler vun Objeten vun dëser Zort ass, datt d'Uerdnung vun hiren Eegeschaften änneren kann. Fir dëst ze vermeiden, musst Dir den Attribut [bestallt] benotzen:
$object = [PSCustomObject][ordered]@{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'
}
Et ginn aner Optiounen fir en Objet ze kreéieren: uewen hu mir de cmdlet benotzt . Alles wat bleift ass erauszefannen Elementer ze addéieren an ze läschen. Dëst fir den Objet aus dem virege Beispill ze maachen ass ganz einfach:
$object | Add-Member –MemberType NoteProperty –Name Age –Value 33
$object | Get-Member
Den Add-Member cmdlet erlaabt Iech net nëmmen Eegeschaften ze addéieren, awer och Methoden fir e virdru erstallt $Objet mat der Konstruktioun "-MemberType ScriptMethod":
$ScriptBlock = {
# код
}
$object | Add-Member -Name "MyMethod" -MemberType ScriptMethod -Value $ScriptBlock
$object | Get-Member
Maacht weg datt mir d'$ScriptBlock Variabel vum Typ ScriptBlock benotzt hunn fir de Code fir déi nei Method ze späicheren.
Fir Eegeschaften ze läschen, benotzt déi entspriechend Method:
$object.psobject.properties.remove('Name')
Schafen Är eege Klassen
PowerShell 5.0 huet d'Fäegkeet agefouert ze definéieren benotzt d'Syntaxcharakteristik vun objektorientéierte Programméierungssproochen. D'Servicewuert Klass ass dofir geduecht, duerno sollt Dir den Numm vun der Klass uginn a säi Kierper a Bedreiwer Klammern beschreiwen:
class MyClass
{
# тело класса
}
Dëst ass e richtegen .NET Core Typ, mat engem Kierper deen seng Eegeschaften, Methoden an aner Elementer beschreift. Loosst eis e Beispill kucken fir déi einfachst Klass ze definéieren:
class MyClass
{
[string]$Name
[string]$City
[string]$Country
}
Fir en Objet (Klasseinstanz) ze kreéieren, benotzt den cmdlet , oder e wuertwiertlech Typ [MyClass] an nei (Standardkonstruktor):
$object = New-Object -TypeName MyClassoder
$object = [MyClass]::new()Loosst eis d'Struktur vum Objet analyséieren:
$object | Get-Member
Vergiesst net iwwer Ëmfang: Dir kënnt net op en Typnumm als String bezeechnen oder en Typ wuertwiertlech ausserhalb vum Skript oder Modul benotzen an deem d'Klass definéiert ass. An dësem Fall kënnen d'Funktioune Klassinstanzen (Objeten) zréckginn, déi ausserhalb vum Modul oder dem Skript zougänglech sinn.
Nodeems Dir den Objet erstallt hutt, fëllt seng Eegeschaften aus:
$object.Name = 'Ivan Danko'
$object.City = 'Moscow'
$object.Country = 'Russia'
$object
Notéiert datt d'Klassbeschreiwung net nëmmen d'Eegeschaftstypen spezifizéiert, awer och hir Standardwäerter:
class Example
{
[string]$Name = 'John Doe'
}
D'Beschreiwung vun enger Klassmethod gläicht d'Beschreiwung vun enger Funktioun, awer ouni d'Funktiounswuert ze benotzen. Wéi an enger Funktioun ginn d'Parameteren op Methoden iwwerginn wann néideg:
class MyClass
{
[string]$Name
[string]$City
[string]$Country
#описание метода
Smile([bool]$param1)
{
If($param1) {
Write-Host ':)'
}
}
}
Elo kann de Vertrieder vun eiser Klass laachen:
$object = [MyClass]::new()
$object.Smile($true)
Methode kënnen iwwerlaascht ginn; Zousätzlech huet eng Klass , wéi och Konstrukteuren deenen hir Nimm mam Numm vun der Klass selwer zesummefalen. Eng Klass definéiert an engem Skript oder PowerShell Modul kann als Basis fir eng aner déngen - dat ass wéi d'Ierfschaft ëmgesat gëtt. An dësem Fall ass et erlaabt bestehend .NET Klassen als Basis ze benotzen:
class MyClass2 : MyClass
{
#тело нового класса, базовым для которого является MyClass
}
[MyClass2]::new().Smile($true)
Eis Beschreiwung fir mat Objekter an PowerShell ze schaffen ass kaum ustrengend. An de folgende Publikatiounen wäerte mir probéieren et mat praktesche Beispiller ze verdéiwen: de fënneften Artikel an der Serie wäert d'Problemer vun der Integratioun vun PowerShell mat Drëtt-Partei Software Komponenten gewidmet ginn. Fréier Deeler kënnen op de Linken hei ënnen fonnt ginn.
Source: will.com