A Windows PowerShell egy parancsértelmező környezet, amely támogatja a Microsoft .NET keretrendszerre épülő objektumorientált szkriptelést. Lényege a PowerShell cmdlet, egy könnyű parancs, amely egy adott műveletet hajt végre, és eközben egy .NET objektumot ad vissza. A PowerShell segítségével a cmdletekkel számos rendszerhez férhet hozzá, és számos feladatot végezhet el ezeken a rendszereken. A cmdletek önmagukban azonban nem mindig elegendőek bizonyos műveletek végrehajtásához. Ezekhez a műveletekhez gyakran saját objektumokat kell létrehozni a .NET osztályok alapján. A .NET objektumok egyik típusa, amelyet létrehozhat, az egyéni objektum. Az egyéni objektum lehetővé teszi az objektumhoz rendelt adatok típusainak és az általa végrehajtott műveleteknek a meghatározását. Miután megértette, hogyan kell egyéni objektumot létrehozni, egy olyan hatékony eszközzel rendelkezik a parancsfájlok létrehozásához, amellyel bővítheti a PowerShell amúgy is jelentős hatókörét.
Megjegyezzük, hogy a .NET keretrendszer és az objektumorientált programozás olyan összetett témák, amelyek messze túlmutatnak az itt tárgyalt témakörön. A PowerShell objektumorientált jellegének teljes körű kiaknázásához segíthet, ha legalább alapszintű ismeretekkel rendelkezünk ezekről a fogalmakról. A .NET keretrendszerről bővebben az MSDN “A .NET keretrendszer áttekintése” című cikkében olvashat. Az objektumorientált programozás bevezetéséhez lásd az MSDN “Objektumorientált programozás (C# és Visual Basic)” című cikkét.”
Egyéni objektum létrehozása
Egyéni objektum létrehozásához a PowerShellben először a New-Object cmdletet kell használnia a kezdeti objektum létrehozásához. Ezzel a cmdlet segítségével .NET- vagy COM-objektumokat hozhat létre osztályok választékából. Az egyéni objektum a .NET objektumok egy speciális típusa, amely az Object vagy a PSObject .NET osztályon alapul. A kezdeti objektum létrehozásakor nincs különbség a kettő között. A PSObject osztályt azonban általában előnyben részesítik, mivel az Object osztályon alapuló objektumhoz tulajdonságok hozzáadásakor problémák merülhetnek fel, ezért használjuk a PSObjectet.
A PSObject osztályon alapuló objektum létrehozásához a New-Object cmdletet kell használni a -TypeName paraméterrel, és a PSObject osztályt kell megadni a paraméter értékeként, például így:
$system = New-Object -TypeName PSObject
A parancs futtatásakor a parancs létrehoz egy PSCustomObject objektumot, amelyet a $system változóhoz rendel. Leggyakrabban az objektumot egy változóhoz akarja hozzárendelni, hogy könnyen dolgozhasson az objektum tagjaival. A tagok azok az összetevők, amelyek egy objektumot alkotnak, például tulajdonságok, metódusok, alias tulajdonságok és tagkészletek.
A PowerShellben az objektumokkal való munka során a két tagtípus, amelyet valószínűleg használni fog, a tulajdonságok és a metódusok. A tulajdonság az objektum egy adott aspektusát írja le. Például a FileInfo .NET osztály egyik tagja a Length tulajdonság, amely a fájl méretét adja meg bájtokban. Ha az osztály alapján létrehoz egy FileInfo objektumot, akkor a Length tulajdonság segítségével elérheti az objektumhoz tartozó fájl méretét. Egy metódus az objektummal kapcsolatos műveletet hajt végre. A FileInfo osztály például tartalmazza a Delete metódust is, amellyel törölheti az objektum által reprezentált fájlt.
Az objektum tagjainak könnyű azonosítása megkönnyíti az objektummal való munkát. Az objektumot alkotó tagok listájának lekérdezéséhez használhatja a Get-Member parancsikont. Például a $system változóhoz rendelt új objektum tagjainak megtekintéséhez a $system változót a Get-Member cmdletbe vezetheti:
$system | Get-Member
Amint az 1. ábrán látható, a létrehozott objektum a System.Management.Automation.PSCustomObject osztályon alapul, amely csak kevés tagot tartalmaz, amelyek mindegyike metódus. De éppen ezért hívják egyéni objektumnak – a saját tagjaink hozzáadásával testre szabhatjuk.
Mielőtt megmutatnám, hogyan adhatunk hozzá tagokat, hadd tegyem hozzá, hogy sok .NET osztályhoz hasonlóan a PSCustomObject osztály is számos különböző típusú rejtett tagot tartalmaz, például memberset és codeproperty. Ezeket a tagokat a Get-Member cmdlet hívásakor a -Force paraméter megadásával tekintheti meg. Bár a rejtett tagok tárgyalása itt meghaladja a keretet, valamikor hasznosnak találhatja a PSCustomObject osztály és más .NET osztályok számára elérhető rejtett tagok felfedezését, hogy teljes mértékben kihasználhassa a PowerShell-objektumok előnyeit.
Tulajdonságok hozzáadása az egyéni objektumhoz
Egy egyéni objektum csak annyira hasznos, mint az objektumhoz tartozó tagok. Egy egyéni objektumhoz több különböző típusú tagot adhat hozzá. Ebben a példában a NoteProperty és a ScriptMethod tagokat adjuk hozzá. A NoteProperty tag hasonló a hagyományos tulajdonságokhoz, a ScriptMethod tag pedig a hagyományos metódusokhoz. Egy egyéni objektumhoz nem adhat hozzá hagyományos tulajdonságot vagy metódust, ezért fogja használni a NoteProperty és a ScriptMethod tagokat. (Az egyéni objektumok támogatott tagjairól a PowerShell TechNet “Add-Member” című témakörében olvashat.)
Kezdjük azzal, hogy hozzáadunk néhány NoteProperty tagot a $system objektumhoz. A tagok hozzáadásához használhatjuk az Add-Member cmdletet a tulajdonságok nevének és értékeinek meghatározásához. Tegyük fel például, hogy a PowerShellbe épített Windows Management Instrumentation (WMI) képességek segítségével lekérdezett adatokon alapuló jegyzettulajdonságokat szeretnénk hozzáadni. (A WMI infrastruktúrát biztosít a Windows operációs rendszerek adatainak és műveleteinek kezeléséhez). A WMI objektummodell számos osztályt tartalmaz, amelyek a kezelési műveletek széles skáláját támogatják. A Win32_OperatingSystem osztály például olyan információkhoz biztosít hozzáférést, mint a számítógépre telepített operációs rendszer neve és az operációs rendszerre alkalmazott legújabb szervizcsomag.
A WMI-objektum létrehozásához használja a Get-WmiObject parancsot, és adja meg a kívánt osztályt. Például egy Win32_OperatingSystem WMI-objektum létrehozásához és a $os változóhoz rendeléséhez a következő kódot használja:
$os = Get-WmiObject Win32_OperatingSystem
Ez esetben a helyi számítógépről kér rendszerinformációkat, de a WMI szépsége abban rejlik, hogy távoli Windows-számítógépeket is képes elérni és kezelni.
Ezután a $os változóval elérheti az objektum által visszaadott információkat. Egy objektum ilyen módon történő hozzárendelése egy változóhoz zárolja az adatokat az adott időpontban. Ha például a $os változó létrehozása után új szervizcsomagot alkalmaznak az operációs rendszerre, az objektum CSDVersion tulajdonsága nem fogja tükrözni a változást, mivel az objektumot az eredeti adatok alapján hozták létre.
A $os változó definiálása után két Add-Member parancsot kell megadni. Mindegyik parancs négy paramétert vesz fel:
- -InputObject. Az -InputObject paramétert az új jegyzettulajdonságokat fogadó objektum azonosítására használjuk. Ebben az esetben a $system objektumot kell megadni.
- -MemberType. A -MemberType paraméter a létrehozandó tag típusát jelöli, ezért meg kell adnia a NoteProperty.
- -Name paramétert. A -Name paraméterrel adja meg az új tag nevét. Ebben a példában nevezzük el az első tagot OperatingSystemnek, a második tagot pedig ServicePack.
- -Value-nak. Ez a paraméter a tag értékét adja meg. Az első jegyzettulajdonsághoz meg kell adnunk a $os.Caption-t, hogy visszaadja az operációs rendszer nevét. A második megjegyzés tulajdonsághoz meg kell adnia a $os.CSDVersion-t, hogy visszaadja az operációs rendszerre alkalmazott legújabb szervizcsomagot.
Íme, így néz ki a két Add-Member parancs:
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Figyeljük meg, hogy minden Add-Member parancsot két sorra bontottam. Mindkét első sor végén egy hátsó pipa (`) szerepel, hogy a PowerShell processzor tudja, hogy a következő sorban folytassa a teljes parancsot.
Az Add-Member parancsok futtatása után meghívhatja a $system változót, hogy megtekinthesse annak tartalmát:
$system
A 2. ábrán egy mintaeredmény látható.
A $system változóval egyes tagokat is meghívhat. Egyszerűen adja meg a változó nevét, amelyet egy pont, majd a tag neve követ. A következő parancs például visszaadja az OperatingSystem jegyzettulajdonság aktuális értékét:
$system.OperatingSystem
Az egyéni objektum létrehozásának egyik előnye, hogy lehetővé teszi a különböző forrásokból származó adatokon alapuló jegyzettulajdonságok, valamint egy olyan jegyzettulajdonság létrehozását, amelynek értéke egy adott karakterlánc. Nézzük meg például az 1. listában található kódot, amely három új jegyzettulajdonságot ad a $system objektumhoz.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
A legtöbb elemet az 1. listában az előző példában láttuk. Figyeljük meg azonban, hogy a kód létrehozza a Win32_PhysicalMemory osztály egy példányát, amely a $mem változóhoz van rendelve, és a Win32_DiskDrive osztály egy példányát, amely a $disk változóhoz van rendelve. A hozzáadott jegyzettulajdonságok közül kettő ezeket az új WMI-objektumokat használja adatforrásként.
Az első Add-Member parancs a $mem.Capacity tulajdonságból kér le adatokat, amely a memória kapacitását adja meg a célrendszeren. Ebben az esetben azonban a -Value paraméter egy kicsit összetettebb, mint az előző példában láttuk. Először is, a parancs megadja a “{0:N2}” értéket, amelyet a -f követ, ami egy .NET konstrukció a kiadott szám formázására. Alapvetően ez azt határozza meg, hogy a számot két tizedesvesszővel adja vissza. A formázási utasításokat egy rövid kifejezés követi ($mem.Capacity/1GB), amely a Capacity értéket 1GB-tal osztja. A Capacity érték a memória méretét adja meg bájtokban. A PowerShell segítségével a bájtok egyszerűen átkonvertálhatók gigabájtokra, egyszerűen elosztva 1GB-tal. Végül a parancs a kimenetre felcímkézi a ‘ GB’ karakterláncot (a szóközzel együtt), és az egészet zárójelbe teszi.
A második Add-Member parancs ugyanezt a logikát követi, hogy visszaadja a számítógép merevlemezének méretét. A $disk.Size tulajdonság segítségével adja vissza a méretet bájtban, majd átalakítja gigabájtra.
A harmadik Add-Member parancs hozzáad egy Owner nevű jegyzettulajdonságot, és hozzárendeli a janetp string értéket. Ebben az esetben a “tulajdonos” bármit jelenthet – az elsődleges felhasználót, az utolsó felhasználót, a rendszergazdát, vagy bármilyen más jelentést, amit a tulajdonságnak tulajdonítunk. Csak azért vettem ide, hogy bemutassam, hogy hozzáadhatunk egy olyan jegyzettulajdonságot, amelynek értéke egy egyszerű karakterlánc.
Azt követően, hogy a három tagot hozzáadtuk az egyéni objektumhoz, ismét meghívhatjuk a $system változót. Ez a 3. ábrán látható eredményekhez hasonló eredményeket fog visszaadni.
Most egyetlen objektummal rendelkezik, amely három különböző WMI-objektumból származó adatokat tartalmaz. Az objektum tartalmazza a Tulajdonos tulajdonságot is, amely egy karakterlánc értékén alapul. Ezt a jegyzett tulajdonságot ugyanúgy hívhatja meg, mint bármely más tagot:
$system.Owner
Amint az várható volt, a parancs a janetp értéket adja vissza. Ezt az értéket azonban megváltoztathatja egy másikra, ha új értéket rendel a tulajdonsághoz, például így:
$system.Owner = "rogert"
Ez esetben a Tulajdonos jegyzet tulajdonsághoz a rogert értéket rendelte. Ha most meghívja ezt a jegyzettulajdonságot, az az új értéket fogja visszaadni.
Mint a PowerShellben elvégezhető számos feladathoz hasonlóan, egy egyéni objektumhoz is többféleképpen lehet tagot hozzáadni. A PowerShell 3.0 például lehetővé teszi egy hash-tábla létrehozását, és a hash átadását a New-Object parancsnak. A 2. felsorolásban szereplő kód ugyanazt az öt jegyzettulajdonságot hozza létre, de a tagok nevének és értékeinek átadásához hash-táblát használ.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Ez a kód először létrehoz egy hash-táblát, amely öt tulajdonság/érték párt határoz meg, amelyek mindegyike megfelel a jegyzettulajdonságoknak. Amint a kód mutatja, a tulajdonság/érték párokat pontosvesszővel kell elválasztani. Az öt tulajdonság/értékpárt szintén zárójelek közé kell zárni, és a nyitó zárójelet az at (@) szimbólummal kell megelőzni. Végül a hash-táblát az $info változóhoz kell hozzárendelni.
A hash-tábla definiálása után a kód a New-Object cmdlet segítségével létrehoz egy objektumot a PSObject osztály alapján, és hozzárendeli a $system változóhoz. Csakhogy ezúttal a parancs tartalmazza a -Property paramétert, amely az $info változót veszi fel értékként.
Végül a kód meghívja a $system változót, amely a 4. ábrán látható eredményt adja vissza. Figyeljük meg, hogy a tulajdonságok milyen sorrendben kerültek hozzá az objektumhoz. Az egyik probléma a hash-tábla használatával a jegyzettulajdonságok hozzáadásához az, hogy nem tudjuk szabályozni a sorrendjüket. A sorrend vezérléséhez az Add-Member cmdletet kell használnia az egyes tagok hozzáadásához.
Módszerek hozzáadása az egyéni objektumhoz
Most, miután láttuk, milyen egyszerű a tulajdonságok hozzáadása, értékeik elérése és megváltoztatása, térjünk át a módszerekre. Ezek egy kicsit bonyolultabbak, mert a metódusoknak valamit csinálniuk kell, és ezt a valamit a metódus értékének részeként kell definiálni.
A 3. listában szereplő kód például létrehoz egy metódust, amely lekérdezi az aktuális dátumot és időt, és eredeti formátumban és koordinált világidő (UTC) értékként is visszaadja.
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
A kód olvashatósága érdekében a metódus értékét egy változóhoz (pl. $method) rendelheti. Ez az érték tartalmazza a dátum- és időinformáció visszaadásához szükséges kifejezéseket. Az értéket azonban szkriptblokkként kell definiálnia ahhoz, hogy átadhassa az Add-Member parancsnak. Ehhez az érték tartalmát csavart zárójelek közé kell zárni. A PowerShell ezután az értéket a jelenlegi formájában ScriptBlock objektumként hozzárendeli a változóhoz.
A 3. listában a módszer értéke két kifejezést tartalmaz. Az első kifejezés az aktuális dátumot és időt adja vissza, a második kifejezés pedig az UTC-verziót. Az első kifejezést a Get-Date cmdlet segítségével kezdi az aktuális dátum és idő lekérdezésével, amelyet a $a változóhoz rendel. Vegye figyelembe, hogy a Get-Date cmdlet hívásakor a -Format paramétert is meg kell adnia, az F értékkel együtt. Ez azt mondja a PowerShellnek, hogy az időbélyeget teljes dátum- és időformátumban jelenítse meg, mint például 2013. augusztus 19., hétfő, 12:28:25 PM. Ezután hozzáadja a “Local: ” (a szóközzel együtt) a változó értékéhez, hogy ezzel a címkével együtt az aktuális dátumot és időt is visszaadja.
A második kifejezésben ismét a Get-Date cmdlet-tel kezdjük az aktuális dátum és idő visszaadását, amelyet a $b változóhoz rendelünk. Ezután a változó ToUniversalTime módszerével visszaadja a dátumot és az időt UTC-értékként, majd megadja a DateTime tulajdonságot a megfelelő formátum visszaadása érdekében.
Ha ezen a ponton meghívná a $method változót, az a két kifejezést karakterláncokként adná vissza, úgy, ahogy beírta őket. Mivel a változó értékét szkriptblokkként definiálta, a parancsok nem kerülnek feldolgozásra, amikor a $method változóhoz rendeljük őket. Ehelyett a $method változó ScriptBlock objektumként jön létre, amiről a GetType metódus segítségével meggyőződhet, ha megnézi a változó típusát:
$method.GetType()
A szkriptblokkal való munkához a $method változó definiálása után a $system objektum tagjaként kell hozzáadni a metódust. Ehhez létrehoz egy Add-Member parancsot, amely típusként a ScriptMethod, névként a GetUTC, értékként pedig a $method változót adja meg.
A 3. felsorolásban szereplő kód futtatása után a $system változóval ugyanúgy hívhatja a GetUTC metódust, mint ahogyan a tulajdonságokat hívta:
$system.GetUTC()
Megjegyezzük azonban, hogy a scriptmetódus hívásakor a zárójeleket ugyanúgy be kell tennie, mint bármely más metódus esetében, még akkor is, ha nem ad át argumentumokat. A metódusnak most az 5. ábrán láthatóhoz hasonló eredményeket kell visszaadnia, de a dátummal és az időponttal együtt, amikor a metódust meghívta.
A való életben valószínűleg olyan metódusokat akar majd létrehozni, amelyek több ütősek. A $system objektum például beépítheti a WMI-kezelési feladatokat a szkript metódusaiba. Ha ezt teszi, akkor teljes mértékben tesztelnie kell a metódust, hogy megbizonyosodjon arról, hogy a parancsok pontosan azt teszik, amit tenniük kell. A PowerShell és a WMI egyaránt nagy teljesítményű eszközök, ezért a Windows-számítógépek kezelése során körültekintően kell használni őket.
Egyéni objektumok hozzáadása egy tömbhöz
Az egyéni objektumok nem korlátozódnak az önálló objektumokra, amelyeket egyszer használunk, majd félredobunk. Ezeket az objektumokat hozzáadhatja egy objektumtömbhöz, majd a tömbön keresztül hozzáférhet az objektumokhoz. Tegyük fel például, hogy több számítógépről lekérdezett információt szeretne manipulálni. Ez az információ tartalmazhat részleteket a rendszereken rendelkezésre álló memóriáról és logikai meghajtókról. Szeretné, ha ezekkel a részletekkel értelmes módon tudna dolgozni a PowerShellben. A PowerShell objektumorientált jellege miatt az adatok objektumokba helyezése gyakran a legegyszerűbb módja az adatokkal való munkának.
Nézzünk egy példát arra, hogyan lehet ezt megtenni. E megbeszélés szempontjából lényegtelen, hogy milyen megközelítéssel gyűjtöttük össze a különböző számítógépekre vonatkozó információkat. Beállíthat például egy foreach-hurkot a PowerShellben, amely a WMI segítségével lekérdezi az információkat a különböző munkaállomásokról. Az alkalmazott módszertől függetlenül a rövidség kedvéért tegyük fel, hogy az információkat egy vesszővel elválasztott szövegfájlba gyűjtötte, amely a 6. ábrán látható adatokat tartalmazza.
A szövegfájl tartalmaz egy fejléc sort és egy sort az egyes rendszerek logikai meghajtói számára. Az első adatsor például a ws01 számítógép C logikai meghajtójának adatait tartalmazza. A logikai meghajtó kapacitása 500 GB, a szabad hely 225 GB. A rendszer 4 GB memóriával is rendelkezik. A második sor azt jelzi, hogy ugyanezen a számítógépen található a D logikai meghajtó is, amelynek kapacitása megegyezik a C meghajtóéval, de 320 GB szabad tárhellyel rendelkezik.
A cél az, hogy minden adatsort saját egyéni objektummá alakítsunk, majd ezeket az objektumokat egy tömbhöz adjuk hozzá. Ezután a tömbben lévő objektumokkal úgy végezhetünk műveleteket, hogy az adatokat más PowerShell-parancsokhoz továbbítjuk. A 4. felsorolásban szereplő kód definiál egy üres tömböt, importálja az adatokat a szövegfájlból, majd egy foreach ciklus segítségével létrehozza az objektumokat és hozzáadja őket a tömbhöz.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Amint látható, az első lépés az üres tömb létrehozása (@()) és hozzárendelése a $SystemInfo változóhoz. Végül az egyéni objektumokat hozzáadja ehhez a tömbhöz.
A következő lépésben az Import-CSV cmdlet segítségével importálja az adatokat a $SourceData változóba. Ebben a gyakorlatban a szöveges fájl neve SourceData.txt, és a C:\DataFiles mappába mentjük. Az Import-CSV cmdlet minden sort saját objektumként hív le, és elmenti a $SourceData változóba. Ezen a ponton használhatná ezt a változót az adatok eléréséhez, de az objektumban szereplő tagok felett nem rendelkezne, és nem tudna tagokat hozzáadni.
A következő lépés tehát egy foreach ciklus létrehozása, amely lehetővé teszi, hogy a szövegfájl minden egyes sorához létrehozzon egy saját objektumot. A foreach feltétel ($source in $SourceData) azt adja meg, hogy a $SourceData minden egyes sora a $source változóhoz legyen rendelve, ahogy a kód a foreach cikluson keresztül iterál. A foreach szkriptblokkban definiált logika (szögletes zárójelben) ezután minden sor esetében egyszer fog lefutni, és minden egyes iteráció során egy másik $source objektumot fog alkalmazni. (A foreach ciklus létrehozásával kapcsolatos további információkért lásd a PowerShell TechNet about_ForEach témakörét.)
Nézzük meg közelebbről a foreach szkriptblokkot. Az első parancs létrehozza a kezdeti objektumot, és elmenti azt a $system változóba, ahogy azt a korábbi példákban láttuk. Ezután a $system változót átvezetjük egy Add-Member parancshoz, hogy létrehozzuk az első jegyzet tulajdonságot. Ez egy kicsit más formátum, mint amit korábban használtunk. Ahelyett, hogy az -InputObject paramétert adnánk meg az Add-Member parancsban, egyszerűen a $system változót vezetjük a parancshoz. Ezzel ugyanazt az eredményt éri el, amit az Add-Member parancsok korábbi példáiban látott. Ezt a megközelítést itt csak azért választottam, hogy bemutassak még egy módot, amellyel a PowerShell lehetővé teszi a tagok hozzáadását.
Az Add-Member parancs értékéhez a $source változót használja a Computer tulajdonság meghívására, amely megfelel a forrásadatok Computer mezőjének. A második Add-Member parancs ugyanígy működik, azzal a különbséggel, hogy az adatokat a DeviceID tulajdonságból hívja le. Vegyük észre, hogy a Memory tulajdonság nem szerepel. Egyéni objektum létrehozásakor elhagyhat bizonyos tulajdonságokat, vagy más sorrendben is elhelyezheti őket.
A harmadik Add-Member parancs nagyjából ugyanúgy működik, mint az első kettő, kivéve, hogy a DriveSize tulajdonságot hívja le. Mivel előfordulhat, hogy nem karakterláncként, hanem numerikus értékként szeretne dolgozni ezzel az adattal, a parancs kifejezetten számmá alakítja az adatot. Ezt úgy érjük el, hogy a tulajdonság neve előtt aint adattípust jelöljük, majd a teljes tulajdonságkifejezést zárójelbe tesszük.
A negyedik Add-Member parancs egy kicsit másképp működik. Létrehoz egy számított tagot, amely a FreeSpace értéket kivonja a DriveSize értékből, hogy meghatározza a felhasznált hely mennyiségét. Ismét a tulajdonság nevét előzi meg, és az egész kifejezést zárójelbe zárja. A számított tulajdonságok létrehozásának lehetősége az egyik fő oka annak, hogy miért érdemes egyéni objektumokat létrehozni.
Az utolsó Add-Member parancs ugyanúgy működik, mint a harmadik, azzal a különbséggel, hogy a FreeSpace tulajdonságból kér adatokat.
A foreach szkriptblokk utolsó parancsa hozzáadja az aktuális $system objektumot a $SystemInfo tömbhöz. Vegyük észre, hogy a += operátorral biztosítjuk, hogy a ciklus minden egyes iterációjánál új $system objektum kerül hozzáadásra, anélkül, hogy bármit is felülírnánk.
A 4. listában szereplő kód futtatása után meghívhatjuk a változót, hogy megnézzük a tartalmát. A 7. ábra a $SystemInfo tömbben most tárolt adatok részleges listáját mutatja.
Közelebbről a tömb első hét objektumának adatait mutatja, ami megfelel az eredeti szöveges fájl első hét adatsorának. Minden egyes csoportosítás a $SystemInfo tömbhöz hozzáadott objektumok egyikét képviseli. Ellenőrizheti, hogy objektumtömböt hozott létre, ha a GetType metódussal lekérdezi a változó típusát:
$SystemInfo.GetType()
Ha ez a parancs System.Array BaseType-t ad vissza, akkor a $SystemInfo változó valóban egy objektumtömb, amely képes egyéni objektumok tárolására. Ezt követően ezt a változót használhatja az adatok manipulálására, ahogyan csak jónak látja. Például átvezetheti a változót egy Sort-Object parancsba, hogy a FreeSpace-értékek alapján csökkenő sorrendbe rendezze az adatokat:
$SystemInfo | Sort FreeSpace -Descending
Ez esetben a parancs a Sort alias használatával hivatkozik a Sort-Object cmdletre, és tartalmazza a FreeSpace tulajdonságot és a -Descending paramétert. Amint a 8. ábrán látható, az objektumok most a FreeSpace-értékek szerint kerülnek felsorolásra, a legnagyobb szabad helyű objektumokkal az első helyen. Ez ismét csak egy részleges lista.
Az adatokat több oszlop alapján is rendezhetjük. Például rendezheti az adatokat először a Computer tulajdonság, majd a FreeSpace tulajdonság alapján, csökkenő sorrendben:
$SystemInfo | Sort Computer, FreeSpace -Descending
Amint az várható volt, az eredmények már sokkal másabbak, ahogy a 9. ábra mutatja.
Az oszlopok ilyen módon történő rendezésének egyik következménye, hogy a Computer értékek és a FreeSpace értékek is csökkenő sorrendbe kerülnek. A Sort-Object cmdlet nem teszi lehetővé, hogy az egyik oszlopot egyszerűen növekvő, a másikat pedig csökkenő sorrendbe rendezzük. Ha megadja a -Descending paramétert, akkor az összes adat ebben a sorrendben lesz rendezve. Ezt a korlátozást azonban megkerülheti, ha minden egyes tulajdonsághoz olyan kifejezéseket hoz létre, amelyek megadják az értékek rendezésének módját. A következő parancs például először a Computer tulajdonság szerint sorolja növekvő sorrendben, majd a FreeSpace tulajdonság szerint csökkenő sorrendben:
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
Az első Sort-Object kifejezés az Expression tulajdonságot Computer-re, a Descending tulajdonságot pedig $false-ra állítja. A második kifejezés az Expression tulajdonságot FreeSpace-re, a Descending tulajdonságot pedig $true-ra állítja. (A $true és $false változók beépített rendszerváltozók, amelyek az 1 és 0 igaz és hamis bóluszi értékeket adják.) Ezután minden kifejezést csavart zárójelek közé kell zárnia, és minden nyitó zárójel előtt az at (@) szimbólumot kell használnia. Most az adatok a kívánt sorrendbe lesznek rendezve, ahogy a 10. ábrán látható.
Ez talán túlzásnak tűnik a rendezés témájában, de rámutat a tömbben lévő objektumokkal való munka rugalmasságára. És természetesen nem korlátozódik a Sort-Object cmdletre. A következő parancs például a $SystemInfo változót a Where-Object cmdletbe továbbítja:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
Ez esetben a parancs a Where alias használatával hivatkozik a Where-Object cmdletre. Ezenkívül meghatározza, hogy a DriveSize értéknek 250-nél nagyobbnak kell lennie ahhoz, hogy szerepeljen az eredményekben. (A PowerShellben a -gt a nagyobb, mint operátort jelöli.) Az ezeknek a feltételeknek megfelelő eredmények a Sort-Object cmdletbe kerülnek átvezetésre, hogy az adatok a megfelelő sorrendben jelenjenek meg.
A rendezett adatokat akár egy Select-Object parancsba is átvezetheti, például így:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Ez a parancs a Select-Object cmdletet használja (amelyre a Select alias hivatkozik), hogy csak az eredményhalmaz első öt sorát adja vissza. Mint látható, miután egyéni objektumokat adunk a $SystemInfo tömbhöz, számos lehetőségünk van az objektumokkal való munkára.
A legtöbbet hozzuk ki az egyéni objektumokból
A legtöbb esetben az egyéni objektumok létrehozása a PowerShellben meglehetősen egyszerű folyamat. Ha valamilyen összetettséggel jár, az általában a jegyzettulajdonságokhoz vagy szkriptmódszerekhez definiált értékkifejezésekből adódik. A példákban szereplő kifejezések viszonylag egyszerűek a PowerShellben létrehozható kifejezéstípusokhoz képest. Ennek ellenére az itt látottaknak meg kell adniuk az egyéni objektumok létrehozásához szükséges alapokat. Ha hatékonyan használja őket, a PowerShell-skriptek hatékony összetevői lehetnek, akár egyedi objektumokat hoz létre, akár egy tömbhöz adja őket, akár más módon használja őket. Létrehozhat például egyéni objektumokat a PowerShell-profilján belül, hogy azok minden új munkamenet indításakor rendelkezésre álljanak. Az, hogy az egyéni objektumokat hogyan használja a parancsfájljaiban, csak Önön múlik. Csak tudnia kell, hogy az egyéni objektum egy hatékony, rugalmas eszköz, amely számos szkriptkészítési igényt kielégíthet.
A Windows PowerShellben az egyéni objektumok létrehozásával kapcsolatos további információkért lásd Bill Stewart “Creating Custom Objects in Windows PowerShell.”