🥇Ano ang Windows PowerShell at saan ito ginagamit? Bahagi 4: Paggawa gamit ang mga bagay, sariling mga klase

Ang text output ng mga command sa PowerShell interpreter window ay isang paraan lamang upang ipakita ang impormasyon sa isang form na angkop para sa perception ng tao. Actually Miyerkules nakatuon upang gumana sa mga bagay: tumatanggap ang mga cmdlet at function bilang input at bumalik sa labasan, at ang mga variable na uri na magagamit sa interactive at sa mga script ay batay sa .NET na mga klase. Sa ika-apat na artikulo ng serye, pag-aaralan natin ang pagtatrabaho sa mga bagay nang mas detalyado.

Talaan ng nilalaman:

Mga bagay sa PowerShell
Pagtingin sa istruktura ng mga bagay
Pag-filter ng mga bagay
Pag-uuri ng mga bagay
Pagpili ng mga bagay at mga bahagi nito
ForEach-Object, Group-Object at Measure-Object
Paglikha ng .NET at COM na mga bagay (Bagong-Bagay)
Pagtawag ng mga static na pamamaraan
I-type ang PSCustomObject
Paglikha ng Iyong Sariling Mga Klase

Mga bagay sa PowerShell

Alalahanin natin na ang isang bagay ay isang koleksyon ng mga patlang ng data (mga katangian, kaganapan, atbp.) at mga pamamaraan para sa pagproseso ng mga ito (mga pamamaraan). Ang istraktura nito ay tinukoy ng isang uri, na karaniwang batay sa mga klase na ginagamit sa pinag-isang .NET Core platform. Posible rin na magtrabaho sa mga bagay na COM, CIM (WMI) at ADSI. Ang mga katangian at pamamaraan ay kinakailangan upang maisagawa ang iba't ibang mga aksyon sa data; bilang karagdagan, sa PowerShell, ang mga bagay ay maaaring maipasa bilang mga argumento sa mga function at cmdlet, itinalaga ang kanilang mga halaga sa mga variable, at mayroon ding mekanismo ng komposisyon ng command (conveyor o pipeline). Ang bawat utos sa pipeline ay nagpapasa ng output nito sa susunod na isa naman, bagay sa bagay. Para sa pagproseso, maaari kang gumamit ng mga pinagsama-samang cmdlet o lumikha ng iyong sarili advanced na mga tampokupang magsagawa ng iba't ibang mga manipulasyon sa mga bagay sa pipeline: pag-filter, pag-uuri, pagpapangkat, at kahit na pagbabago ng kanilang istraktura. Ang paglilipat ng data sa form na ito ay may malubhang kalamangan: ang tumatanggap na koponan ay hindi kailangang i-parse ang stream ng mga byte (teksto), ang lahat ng kinakailangang impormasyon ay madaling makuha sa pamamagitan ng pagtawag sa naaangkop na mga katangian at pamamaraan.

Pagtingin sa istruktura ng mga bagay

Halimbawa, patakbuhin natin ang Get-Process cmdlet, na nagbibigay-daan sa iyong makakuha ng impormasyon tungkol sa mga prosesong tumatakbo sa system:

Magpapakita ito ng ilang naka-format na data ng teksto na hindi nagbibigay ng anumang ideya tungkol sa mga katangian ng ibinalik na mga bagay at ang kanilang mga pamamaraan. Upang maayos ang output, kailangan nating matutunan kung paano suriin ang istraktura ng mga bagay, at ang Get-Member cmdlet ay makakatulong sa atin dito:

Get-Process | Get-Member

Dito nakikita na natin ang uri at istraktura, at sa tulong ng mga karagdagang parameter maaari nating, halimbawa, ipakita lamang ang mga katangian ng bagay na kasama sa input:

Get-Process | Get-Member -MemberType Property

Kakailanganin ang kaalamang ito upang malutas ang mga problema sa pangangasiwa sa interactive na paraan o para magsulat ng sarili mong mga script: halimbawa, para makakuha ng impormasyon tungkol sa mga prosesong nakabitin gamit ang Responding property.

Pag-filter ng mga bagay

Pinapayagan ng PowerShell ang mga bagay na nakakatugon sa isang partikular na kundisyon na maipasa sa isang pipeline:

Where-Object { блок сценария }

Ang resulta ng pagpapatupad ng script block sa loob ng mga panaklong ay dapat na isang boolean na halaga. Kung ito ay totoo ($true), ang object na na-input sa Where-Object cmdlet ay ipapasa sa pipeline, kung hindi ($false) ito ay tatanggalin. Halimbawa, magpakita tayo ng listahan ng mga nahintong serbisyo ng Windows Server, i.e. ang mga may Status na ari-arian ay nakatakda sa "Nahinto":

Get-Service | Where-Object {$_.Status -eq "Stopped"}

Dito muli nating nakikita ang isang representasyong tekstuwal, ngunit kung nais mong maunawaan ang uri at panloob na istraktura ng mga bagay na dumadaan sa pipeline hindi ito mahirap:

Get-Service | Where-Object {$_.Status -eq "Stopped"} | Get-Member

Pag-uuri ng mga bagay

Kapag ang pagpoproseso ng pipeline ng mga bagay, madalas na kailangang ayusin ang mga ito. Ang Sort-Object cmdlet ay ipinapasa ang mga pangalan ng mga katangian (sorting keys) at ibinabalik ang mga bagay na inayos ayon sa kanilang mga halaga. Madaling pag-uri-uriin ang output ng mga prosesong tumatakbo ayon sa oras na ginugol ng CPU (cpu property):

Get-Process | Sort-Object –Property cpu

Maaaring tanggalin ang -Property parameter kapag tinatawag ang Sort-Object cmdlet; ginagamit ito bilang default. Para sa reverse sorting, gamitin ang -Descending parameter:

Get-Process | Sort-Object cpu -Descending

Pagpili ng mga bagay at mga bahagi nito

Ang Select-Object cmdlet ay nagpapahintulot sa iyo na pumili ng isang tiyak na bilang ng mga bagay sa simula o dulo ng isang pipeline gamit ang -First o -Last na mga parameter. Sa tulong nito, maaari kang pumili ng mga solong bagay o ilang mga katangian, at lumikha din ng mga bagong bagay batay sa mga ito. Tingnan natin kung paano gumagana ang cmdlet gamit ang mga simpleng halimbawa.

Ang sumusunod na utos ay nagpapakita ng impormasyon tungkol sa 10 proseso na kumukonsumo ng maximum na halaga ng RAM (WS property):

Get-Process | Sort-Object WS -Descending | Select-Object -First 10

Maaari kang pumili lamang ng ilang mga katangian ng mga bagay na dumadaan sa pipeline at lumikha ng mga bago batay sa mga ito:

Get-Process | Select-Object ProcessName, Id -First 1

Bilang resulta ng pagpapatakbo ng pipeline, makakatanggap kami ng isang bagong bagay, na ang istraktura ay mag-iiba mula sa istraktura na ibinalik ng Get-Process cmdlet. I-verify natin ito gamit ang Get-Member:

Get-Process | Select-Object ProcessName, Id -First 1 | Get-Member

Tandaan na ang Select-Object ay nagbabalik ng isang object (-First 1) na mayroon lamang dalawa sa mga field na aming tinukoy: ang kanilang mga value ay kinopya mula sa unang object na ipinasa sa pipeline ng Get-Process cmdlet. Ang isa sa mga paraan upang lumikha ng mga bagay sa mga script ng PowerShell ay batay sa paggamit ng Select-Object:

$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType()

Gamit ang Select-Object, maaari kang magdagdag ng mga computed properties sa mga object na kailangang irepresenta bilang mga hash table. Sa kasong ito, ang halaga ng unang key nito ay tumutugma sa pangalan ng property, at ang halaga ng pangalawang key ay tumutugma sa value ng property para sa kasalukuyang elemento ng pipeline:

Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}}

Tingnan natin ang istraktura ng mga bagay na dumadaan sa conveyor:

Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} | Get-Member

ForEach-Object, Group-Object at Measure-Object

Mayroong iba pang mga cmdlet para sa pagtatrabaho sa mga bagay. Bilang halimbawa, pag-usapan natin ang tatlong pinakakapaki-pakinabang:

Para sa Bawat-Bagay nagbibigay-daan sa iyo na patakbuhin ang PowerShell code para sa bawat bagay sa pipeline:

ForEach-Object { блок сценария }

Pangkat-Bagay pangkatin ang mga bagay ayon sa halaga ng ari-arian:

Group-Object PropertyName

Kung patakbuhin mo ito gamit ang -NoElement parameter, maaari mong malaman ang bilang ng mga elemento sa mga pangkat.

Sukatin-Bagay pinagsama-sama ang iba't ibang mga parameter ng buod sa pamamagitan ng mga halaga ng field ng object sa pipeline (kinakalkula ang kabuuan, at hinahanap din ang minimum, maximum o average na halaga):

Measure-Object -Property PropertyName -Minimum -Maximum -Average -Sum

Karaniwan, ang mga cmdlet na tinalakay ay ginagamit nang interactive, at kadalasang ginagawa sa mga script. функции na may Start, Process at End blocks.

Paglikha ng .NET at COM na mga bagay (Bagong-Bagay)

Maraming mga bahagi ng software na may mga interface ng .NET Core at COM na kapaki-pakinabang sa mga administrator ng system. Gamit ang klase ng System.Diagnostics.EventLog, maaari mong pamahalaan ang mga log ng system nang direkta mula sa Windows PowerShell. Tingnan natin ang isang halimbawa ng paglikha ng isang instance ng klase na ito gamit ang New-Object cmdlet na may parameter na -TypeName:

New-Object -TypeName System.Diagnostics.EventLog

Dahil hindi kami tumukoy ng partikular na log ng kaganapan, ang resultang instance ng klase ay walang data. Upang baguhin ito, kailangan mong tumawag ng isang espesyal na paraan ng constructor sa panahon ng paglikha nito gamit ang parameter na -ArgumentList. Kung gusto nating ma-access ang log ng application, dapat nating ipasa ang string na "Application" bilang argumento sa constructor:

$AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application
$AppLog

Pakitandaan na na-save namin ang output ng command sa $AppLog variable. Bagama't ang mga pipeline ay karaniwang ginagamit sa interactive na mode, ang pagsulat ng mga script ay kadalasang nangangailangan ng pagpapanatili ng isang reference sa isang bagay. Bukod pa rito, ang mga pangunahing klase ng .NET Core ay nasa namespace ng System: Ang PowerShell bilang default ay naghahanap ng mga tinukoy na uri dito, kaya ang pagsulat ng Diagnostics.EventLog sa halip na System.Diagnostics.EventLog ay medyo tama.

Upang magtrabaho kasama ang log, maaari mong gamitin ang mga naaangkop na pamamaraan:

$AppLog | Get-Member -MemberType Method

Sabihin nating na-clear ito ng Clear() na paraan kung may mga karapatan sa pag-access:

$AppLog.Clear()

Ginagamit din ang New-Object cmdlet upang gumana sa mga bahagi ng COM. Marami sa kanila - mula sa mga aklatan na ibinigay kasama ng Windows script server hanggang sa mga aplikasyon ng ActiveX, tulad ng Internet Explorer. Upang lumikha ng COM object, kailangan mong itakda ang -ComObject parameter na may programmatic ProgId ng nais na klase:

New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObject

Upang lumikha ng iyong sariling mga bagay na may isang arbitrary na istraktura, ang paggamit ng New-Object ay mukhang masyadong archaic at masalimuot; ang cmdlet na ito ay ginagamit upang gumana sa mga bahagi ng software na panlabas sa PowerShell. Sa mga susunod na artikulo ang isyung ito ay tatalakayin nang mas detalyado. Bilang karagdagan sa mga bagay na .NET at COM, tutuklasin din namin ang mga bagay na CIM (WMI) at ADSI.

Pagtawag ng mga static na pamamaraan

Ang ilang .NET Core na klase ay hindi maaaring i-instantiate, kabilang ang System.Environment at System.Math. Sila ay static at naglalaman lamang ng mga static na katangian at pamamaraan. Ang mga ito ay mahalagang mga reference na aklatan na ginagamit nang hindi gumagawa ng mga bagay. Maaari kang sumangguni sa isang static na klase sa pamamagitan ng literal sa pamamagitan ng paglalagay ng pangalan ng uri sa mga square bracket. Gayunpaman, kung titingnan natin ang istraktura ng bagay gamit ang Get-Member, makikita natin ang uri na System.RuntimeType sa halip na System.Environment:

[System.Environment] | Get-Member

Upang tingnan lamang ang mga static na miyembro, tawagan ang Get-Member na may parameter na -Static (tandaan ang uri ng bagay):

[System.Environment] | Get-Member -Static

Upang ma-access ang mga static na katangian at pamamaraan, gumamit ng dalawang magkasunod na colon sa halip na isang tuldok pagkatapos ng literal:

[System.Environment]::OSVersion

O kaya

$test=[System.Math]::Sqrt(25) 
$test
$test.GetType()

I-type ang PSCustomObject

Kabilang sa maraming uri ng data na magagamit sa PowerShell, sulit na banggitin ang PSCustomObject, na idinisenyo para sa pag-iimbak ng mga bagay na may di-makatwirang istraktura. Ang paglikha ng naturang bagay gamit ang New-Object cmdlet ay itinuturing na isang klasiko, ngunit masalimuot at hindi napapanahong paraan:

$object = New-Object  –TypeName PSCustomObject -Property @{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'}

Tingnan natin ang istraktura ng bagay:

$object | Get-Member

Simula sa PowerShell 3.0, available ang isa pang syntax:

$object = [PSCustomObject]@{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'
}

Maaari mong ma-access ang data sa isa sa mga katumbas na paraan:

$object.Name

$object.'Name'

$value = 'Name'
$object.$value

Narito ang isang halimbawa ng pag-convert ng isang umiiral na hashtable sa isang bagay:

$hash = @{'Name'='Ivan Danko'; 'City'='Moscow'; 'Country'='Russia'}
$hash.GetType()
$object = [pscustomobject]$hash
$object.GetType()

Ang isa sa mga disadvantages ng mga bagay ng ganitong uri ay ang pagkakasunud-sunod ng kanilang mga katangian ay maaaring magbago. Upang maiwasan ito, dapat mong gamitin ang attribute na [ordered]:

$object = [PSCustomObject][ordered]@{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'
}

Mayroong iba pang mga pagpipilian para sa paglikha ng isang bagay: sa itaas ay tiningnan namin ang paggamit ng cmdlet Piliin-Bagay. Ang natitira na lang ay upang malaman ang pagdaragdag at pag-alis ng mga elemento. Ang paggawa nito para sa bagay mula sa nakaraang halimbawa ay medyo simple:

$object | Add-Member –MemberType NoteProperty –Name Age  –Value 33
$object | Get-Member

Ang Add-Member cmdlet ay nagbibigay-daan sa iyo na magdagdag hindi lamang ng mga katangian, kundi pati na rin ng mga pamamaraan sa isang dati nang nilikhang $object sa pamamagitan ng paggamit ng "-MemberType ScriptMethod" na construct:

$ScriptBlock = {
    # код 
}
$object | Add-Member -Name "MyMethod" -MemberType ScriptMethod -Value $ScriptBlock
$object | Get-Member

Pakitandaan na ginamit namin ang $ScriptBlock variable ng uri ng ScriptBlock upang iimbak ang code para sa bagong paraan.

Upang alisin ang mga katangian, gamitin ang kaukulang pamamaraan:

$object.psobject.properties.remove('Name')

Paglikha ng Iyong Sariling Mga Klase

Ipinakilala ng PowerShell 5.0 ang kakayahang tumukoy mga marka gamit ang syntax na katangian ng object-oriented programming language. Ang salitang serbisyo na Klase ay inilaan para dito, pagkatapos nito ay dapat mong tukuyin ang pangalan ng klase at ilarawan ang katawan nito sa mga bracket ng operator:

class MyClass
{
    # тело класса
}

Ito ay isang tunay na uri ng .NET Core, na may katawan na naglalarawan sa mga katangian, pamamaraan, at iba pang elemento nito. Tingnan natin ang isang halimbawa ng pagtukoy sa pinakasimpleng klase:

class MyClass 
{
     [string]$Name
     [string]$City
     [string]$Country
}

Upang lumikha ng isang bagay (halimbawa ng klase), gamitin ang cmdlet Bagong-Bagay, o literal na uri ng [MyClass] at pseudostatic na pamamaraan bago (default na tagabuo):

$object = New-Object -TypeName MyClass

$object = [MyClass]::new()

Suriin natin ang istraktura ng bagay:

$object | Get-Member

Huwag kalimutan ang tungkol sa saklaw: hindi ka maaaring sumangguni sa isang pangalan ng uri bilang isang string o gumamit ng literal na uri sa labas ng script o module kung saan tinukoy ang klase. Sa kasong ito, maaaring ibalik ng mga function ang mga instance ng klase (mga bagay) na maa-access sa labas ng module o script.

Pagkatapos likhain ang bagay, punan ang mga katangian nito:

$object.Name = 'Ivan Danko'
$object.City = 'Moscow'
$object.Country = 'Russia'
$object

Tandaan na ang paglalarawan ng klase ay tumutukoy hindi lamang sa mga uri ng property, kundi pati na rin sa kanilang mga default na halaga:

class Example
{
     [string]$Name = 'John Doe'
}

Ang paglalarawan ng isang paraan ng klase ay kahawig ng paglalarawan ng isang function, ngunit hindi gumagamit ng function na salita. Tulad ng sa isang function, ang mga parameter ay ipinapasa sa mga pamamaraan kung kinakailangan:

class MyClass 
{
     [string]$Name
     [string]$City
     [string]$Country
     
     #описание метода
     Smile([bool]$param1)
     {
         If($param1) {
            Write-Host ':)'
         }
     }
}

Ngayon ang kinatawan ng aming klase ay maaaring ngumiti:

$object = [MyClass]::new()
$object.Smile($true)

Maaaring ma-overload ang mga pamamaraan; bilang karagdagan, mayroon ang isang klase mga static na katangian at pamamaraan, pati na rin ang mga konstruktor na ang mga pangalan ay tumutugma sa pangalan ng klase mismo. Ang isang klase na tinukoy sa isang script o PowerShell module ay maaaring magsilbing base para sa isa pa - ito ay kung paano ipinapatupad ang mana. Sa kasong ito, pinapayagang gumamit ng mga kasalukuyang .NET na klase bilang mga base:

class MyClass2 : MyClass
{
      #тело нового класса, базовым для которого является MyClass
}
[MyClass2]::new().Smile($true)

Ang aming paglalarawan ng pagtatrabaho sa mga bagay sa PowerShell ay halos hindi kumpleto. Sa mga sumusunod na publikasyon, susubukan naming palalimin ito gamit ang mga praktikal na halimbawa: ang ikalimang artikulo sa serye ay ilalaan sa mga isyu ng pagsasama ng PowerShell sa mga bahagi ng software ng third-party. Ang mga nakaraang bahagi ay matatagpuan sa mga link sa ibaba.

Bahagi 1: Mga Pangunahing Feature ng Windows PowerShell
Bahagi 2: Panimula sa Windows PowerShell Programming Language
Bahagi 3: pagpasa ng mga parameter sa mga script at function, paggawa ng mga cmdlet

Pinagmulan: www.habr.com

Ano ang Windows PowerShell at para saan ito ginagamit? Bahagi 4: Paggawa gamit ang mga bagay, sariling mga klase