about_Classes
Rövid leírás
Azt ismerteti, hogyan hozhat létre saját egyéni típusokat osztályok használatával.
Hosszú leírás
Az 5.0-s verziótól kezdve a PowerShell formális szintaxissal rendelkezik az osztályok és más felhasználó által definiált típusok definiálásához. Az osztályok hozzáadása lehetővé teszi a fejlesztők és az informatikai szakemberek számára, hogy szélesebb körű használati esetekhez használják a PowerShellt.
Az osztálydeklaráció egy terv, amellyel futtatáskor objektumpéldányokat hozhat létre. Osztály definiálásakor az osztály neve a típus neve. Ha például deklarál egy Eszköz nevű osztályt, és inicializál egy változót $dev egy új eszközpéldányba, $dev az eszköz típusú objektum vagy példány. Az eszköz minden példánya különböző értékekkel rendelkezhet a tulajdonságaiban.
Támogatott esetek
- Egyéni típusok definiálása a PowerShellben objektumorientált programozási szemantikával, például osztályok, tulajdonságok, metódusok, öröklés stb.
- A PowerShell-nyelv használatával definiálhatja a DSC-erőforrásokat és azok társított típusait.
- Egyéni attribútumok definiálása változók, paraméterek és egyéni típusdefiníciók díszítéséhez.
- Definiáljon egyéni kivételeket, amelyek a típusnevük alapján elkaphatók.
Syntax
Definíció szintaxisa
Az osztálydefiníciók a következő szintaxist használják:
class <class-name> [: [<base-class>][,<interface-list>]] {
[[<attribute>] [hidden] [static] <property-definition> ...]
[<class-name>([<constructor-argument-list>])
{<constructor-statement-list>} ...]
[[<attribute>] [hidden] [static] <method-definition> ...]
}
Példányosítás szintaxisa
Az osztály egy példányának példányosításához használja az alábbi szintaxisok egyikét:
[$<variable-name> =] New-Object -TypeName <class-name> [
[-ArgumentList] <constructor-argument-list>]
[$<variable-name> =] [<class-name>]::new([<constructor-argument-list>])
[$<variable-name> =] [<class-name>]@{[<class-property-hashtable>]}
Feljegyzés
A szintaxis használatakor kötelező [<class-name>]::new() az osztály neve körüli zárójelek használata. A zárójelek a PowerShell típusdefinícióját jelzik.
A kivonatoló szintaxis csak olyan osztályok esetében működik, amelyek alapértelmezett konstruktorával rendelkeznek, és nem várnak paramétereket. Létrehozza az osztály egy példányát az alapértelmezett konstruktorral, majd hozzárendeli a kulcs-érték párokat a példány tulajdonságaihoz. Ha a kivonatoló egyik kulcsa nem érvényes tulajdonságnév, a PowerShell hibát jelez.
Példák
1. példa – Minimális definíció
Ez a példa a használható osztály létrehozásához szükséges minimális szintaxist mutatja be.
class Device {
[string]$Brand
}
$dev = [Device]::new()
$dev.Brand = "Fabrikam, Inc."
$dev
Brand
-----
Fabrikam, Inc.
2. példa – Osztály példánytagokkal
Ez a példa több tulajdonsággal, konstruktorral és metódussal rendelkező könyvosztályt határoz meg. Minden definiált tag egy példánytag , nem statikus tag. A tulajdonságok és metódusok csak az osztály egy létrehozott példányán keresztül érhetők el.
class Book {
# Class properties
[string] $Title
[string] $Author
[string] $Synopsis
[string] $Publisher
[datetime] $PublishDate
[int] $PageCount
[string[]] $Tags
# Default constructor
Book() { $this.Init(@{}) }
# Convenience constructor from hashtable
Book([hashtable]$Properties) { $this.Init($Properties) }
# Common constructor for title and author
Book([string]$Title, [string]$Author) {
$this.Init(@{Title = $Title; Author = $Author })
}
# Shared initializer method
[void] Init([hashtable]$Properties) {
foreach ($Property in $Properties.Keys) {
$this.$Property = $Properties.$Property
}
}
# Method to calculate reading time as 2 minutes per page
[timespan] GetReadingTime() {
if ($this.PageCount -le 0) {
throw 'Unable to determine reading time from page count.'
}
$Minutes = $this.PageCount * 2
return [timespan]::new(0, $Minutes, 0)
}
# Method to calculate how long ago a book was published
[timespan] GetPublishedAge() {
if (
$null -eq $this.PublishDate -or
$this.PublishDate -eq [datetime]::MinValue
) { throw 'PublishDate not defined' }
return (Get-Date) - $this.PublishDate
}
# Method to return a string representation of the book
[string] ToString() {
return "$($this.Title) by $($this.Author) ($($this.PublishDate.Year))"
}
}
Az alábbi kódrészlet létrehozza az osztály egy példányát, és bemutatja, hogyan viselkedik. A Könyv osztály egy példányának létrehozása után a példa a könyvről szóló üzenet írásához használja a metódusokat és GetPublishedAge() a GetReadingTime() metódusokat.
$Book = [Book]::new(@{
Title = 'The Hobbit'
Author = 'J.R.R. Tolkien'
Publisher = 'George Allen & Unwin'
PublishDate = '1937-09-21'
PageCount = 310
Tags = @('Fantasy', 'Adventure')
})
$Book
$Time = $Book.GetReadingTime()
$Time = @($Time.Hours, 'hours and', $Time.Minutes, 'minutes') -join ' '
$Age = [Math]::Floor($Book.GetPublishedAge().TotalDays / 365.25)
"It takes $Time to read $Book,`nwhich was published $Age years ago."
Title : The Hobbit
Author : J.R.R. Tolkien
Synopsis :
Publisher : George Allen & Unwin
PublishDate : 9/21/1937 12:00:00 AM
PageCount : 310
Tags : {Fantasy, Adventure}
It takes 10 hours and 20 minutes to read The Hobbit by J.R.R. Tolkien (1937),
which was published 86 years ago.
3. példa – Osztály statikus tagokkal
A példában szereplő BookList osztály a 2. példában a Könyv osztályra épül. Bár a BookList osztály önmagában nem jelölhető meg statikusként, az implementáció csak a Könyvek statikus tulajdonságot és a tulajdonság kezelésére szolgáló statikus módszerek készletét határozza meg.
class BookList {
# Static property to hold the list of books
static [System.Collections.Generic.List[Book]] $Books
# Static method to initialize the list of books. Called in the other
# static methods to avoid needing to explicit initialize the value.
static [void] Initialize() { [BookList]::Initialize($false) }
static [bool] Initialize([bool]$force) {
if ([BookList]::Books.Count -gt 0 -and -not $force) {
return $false
}
[BookList]::Books = [System.Collections.Generic.List[Book]]::new()
return $true
}
# Ensure a book is valid for the list.
static [void] Validate([book]$Book) {
$Prefix = @(
'Book validation failed: Book must be defined with the Title,'
'Author, and PublishDate properties, but'
) -join ' '
if ($null -eq $Book) { throw "$Prefix was null" }
if ([string]::IsNullOrEmpty($Book.Title)) {
throw "$Prefix Title wasn't defined"
}
if ([string]::IsNullOrEmpty($Book.Author)) {
throw "$Prefix Author wasn't defined"
}
if ([datetime]::MinValue -eq $Book.PublishDate) {
throw "$Prefix PublishDate wasn't defined"
}
}
# Static methods to manage the list of books.
# Add a book if it's not already in the list.
static [void] Add([Book]$Book) {
[BookList]::Initialize()
[BookList]::Validate($Book)
if ([BookList]::Books.Contains($Book)) {
throw "Book '$Book' already in list"
}
$FindPredicate = {
param([Book]$b)
$b.Title -eq $Book.Title -and
$b.Author -eq $Book.Author -and
$b.PublishDate -eq $Book.PublishDate
}.GetNewClosure()
if ([BookList]::Books.Find($FindPredicate)) {
throw "Book '$Book' already in list"
}
[BookList]::Books.Add($Book)
}
# Clear the list of books.
static [void] Clear() {
[BookList]::Initialize()
[BookList]::Books.Clear()
}
# Find a specific book using a filtering scriptblock.
static [Book] Find([scriptblock]$Predicate) {
[BookList]::Initialize()
return [BookList]::Books.Find($Predicate)
}
# Find every book matching the filtering scriptblock.
static [Book[]] FindAll([scriptblock]$Predicate) {
[BookList]::Initialize()
return [BookList]::Books.FindAll($Predicate)
}
# Remove a specific book.
static [void] Remove([Book]$Book) {
[BookList]::Initialize()
[BookList]::Books.Remove($Book)
}
# Remove a book by property value.
static [void] RemoveBy([string]$Property, [string]$Value) {
[BookList]::Initialize()
$Index = [BookList]::Books.FindIndex({
param($b)
$b.$Property -eq $Value
}.GetNewClosure())
if ($Index -ge 0) {
[BookList]::Books.RemoveAt($Index)
}
}
}
A BookList definiálása után az előző példában szereplő könyv hozzáadható a listához.
$null -eq [BookList]::Books
[BookList]::Add($Book)
[BookList]::Books
True
Title : The Hobbit
Author : J.R.R. Tolkien
Synopsis :
Publisher : George Allen & Unwin
PublishDate : 9/21/1937 12:00:00 AM
PageCount : 310
Tags : {Fantasy, Adventure}
Az alábbi kódrészlet meghívja az osztály statikus metódusait.
[BookList]::Add([Book]::new(@{
Title = 'The Fellowship of the Ring'
Author = 'J.R.R. Tolkien'
Publisher = 'George Allen & Unwin'
PublishDate = '1954-07-29'
PageCount = 423
Tags = @('Fantasy', 'Adventure')
}))
[BookList]::Find({
param ($b)
$b.PublishDate -gt '1950-01-01'
}).Title
[BookList]::FindAll({
param($b)
$b.Author -match 'Tolkien'
}).Title
[BookList]::Remove($Book)
[BookList]::Books.Title
[BookList]::RemoveBy('Author', 'J.R.R. Tolkien')
"Titles: $([BookList]::Books.Title)"
[BookList]::Add($Book)
[BookList]::Add($Book)
The Fellowship of the Ring
The Hobbit
The Fellowship of the Ring
The Fellowship of the Ring
Titles:
Exception:
Line |
84 | throw "Book '$Book' already in list"
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Book 'The Hobbit by J.R.R. Tolkien (1937)' already in list
4. példa – Osztálydefiníció runspace affinitással és anélkül
A ShowRunspaceId() különböző szálazonosítók jelentésének metódusa [UnsafeClass] , de ugyanaz a futtatótér-azonosító. Végül a munkamenet állapota sérült, ami hibát okoz, például Global scope cannot be removed.
# Class definition with Runspace affinity (default behavior)
class UnsafeClass {
static [object] ShowRunspaceId($val) {
return [PSCustomObject]@{
ThreadId = [Threading.Thread]::CurrentThread.ManagedThreadId
RunspaceId = [runspace]::DefaultRunspace.Id
}
}
}
$unsafe = [UnsafeClass]::new()
while ($true) {
1..10 | ForEach-Object -Parallel {
Start-Sleep -ms 100
($using:unsafe)::ShowRunspaceId($_)
}
}
Feljegyzés
Ez a példa végtelen ciklusban fut. A végrehajtás leállításához írja be a Ctrl+C billentyűkombinációt.
A ShowRunspaceId() különböző szál- és runspace-azonosítók jelentésének [SafeClass] módja.
# Class definition with NoRunspaceAffinity attribute
[NoRunspaceAffinity()]
class SafeClass {
static [object] ShowRunspaceId($val) {
return [PSCustomObject]@{
ThreadId = [Threading.Thread]::CurrentThread.ManagedThreadId
RunspaceId = [runspace]::DefaultRunspace.Id
}
}
}
$safe = [SafeClass]::new()
while ($true) {
1..10 | ForEach-Object -Parallel {
Start-Sleep -ms 100
($using:safe)::ShowRunspaceId($_)
}
}
Feljegyzés
Ez a példa végtelen ciklusban fut. A végrehajtás leállításához írja be a Ctrl+C billentyűkombinációt.
Osztálytulajdonságok
A tulajdonságok az osztály hatókörében deklarált változók. A tulajdonság lehet bármilyen beépített típus vagy egy másik osztály példánya. Az osztályoknak nulla vagy több tulajdonságuk lehet. Az osztályok nem rendelkeznek maximális tulajdonságszámokkal.
További információ: about_Classes_Properties.
Osztálymódszerek
A metódusok határozzák meg az osztály által végrehajtható műveleteket. A metódusok olyan paramétereket is használhatnak, amelyek bemeneti adatokat adnak meg. A metódusok mindig meghatároznak egy kimeneti típust. Ha egy metódus nem ad vissza kimenetet, akkor a Void kimeneti típussal kell rendelkeznie. Ha egy metódus nem határoz meg explicit módon kimeneti típust, a metódus kimeneti típusa Üres.
További információ: about_Classes_Methods.
Osztálykonstruktorok
A konstruktorok lehetővé teszik az alapértelmezett értékek beállítását és az objektumlogika érvényesítését az osztály példányának létrehozásakor. A konstruktorok neve megegyezik az osztály nevével. A konstruktoroknak lehetnek paramétereik az új objektum adattagjainak inicializálásához.
További információ: about_Classes_Constructors.
Rejtett kulcsszó
A hidden kulcsszó elrejt egy osztálytagot. A tag továbbra is elérhető a felhasználó számára, és minden olyan hatókörben elérhető, amelyben az objektum elérhető.
A rejtett tagok elrejtve vannak a Get-Member parancsmag elől, és nem jeleníthetők meg tabulátorkimenet vagy IntelliSense használatával az osztálydefiníción kívül.
A hidden kulcsszó csak az osztálytagokra vonatkozik, maga az osztály nem.
A rejtett osztálytagok a következők:
- Nem szerepel az osztály alapértelmezett kimenetében.
- A parancsmag által
Get-Membervisszaadott osztálytagok listájában nem szerepel. A rejtett tagokGet-Membermegjelenítéséhez használja a Force paramétert. - A lapkizárás vagy az IntelliSense csak akkor jelenik meg, ha a befejezés a rejtett tagot meghatározó osztályban történik.
- Az osztály nyilvános tagjai. Ezek elérhetők, örökölhetők és módosíthatók. Egy tag elrejtése nem teszi privátsá. Csak az előző pontokban leírtak szerint rejti el a tagot.
Feljegyzés
Ha elrejti a metódus túlterhelését, a rendszer eltávolítja a metódust az IntelliSense-ből, a befejezési eredményeket és az alapértelmezett kimenetet Get-Member.
Ha elrejt egy konstruktort, a beállítás el lesz távolítva az new() IntelliSense-ből és a befejezési eredményekből.
A kulcsszóval kapcsolatos további információkért lásd : about_Hidden. További információ a rejtett tulajdonságokról: about_Classes_Properties. A rejtett módszerekkel kapcsolatos további információkért lásd a about_Classes_Methods. További információ a rejtett konstruktorokról: about_Classes_Constructors.
Statikus kulcsszó
A static kulcsszó egy olyan tulajdonságot vagy metódust határoz meg, amely az osztályban létezik, és nem igényel példányt.
A statikus tulajdonság mindig elérhető, az osztály példányosításától függetlenül. A statikus tulajdonság az osztály összes példányában meg van osztva. A statikus módszer mindig elérhető. Az összes statikus tulajdonság a munkamenet teljes időtartamára érvényes.
A static kulcsszó csak az osztálytagokra vonatkozik, maga az osztály nem.
További információ a statikus tulajdonságokról: about_Classes_Properties. A statikus módszerekkel kapcsolatos további információkért lásd: about_Classes_Methods. További információ a statikus konstruktorokról: about_Classes_Constructors.
Öröklés PowerShell-osztályokban
Az osztályokat egy meglévő osztályból származó új osztály létrehozásával bővítheti. A származtatott osztály örökli az alaposztály tulajdonságait és metódusait. Igény szerint hozzáadhatja vagy felülbírálhatja az alaposztálytagokat.
A PowerShell nem támogatja a többszörös öröklést. Az osztályok nem örökölhetnek közvetlenül több osztályból.
Az osztályok a szerződéseket meghatározó felületektől is örökölhetnek. Az interfésztől öröklő osztálynak implementálnia kell ezt a szerződést. Ha igen, az osztály használható, mint bármely más osztály, amely megvalósítja ezt a felületet.
Az alaposztálytól öröklő vagy interfészeket implementáló osztályok származtatásáról további információt a about_Classes_Inheritance talál.
NoRunspaceAffinity attribútum
A runspace a PowerShell által meghívott parancsok operációs környezete. Ez a környezet tartalmazza a jelenleg meglévő parancsokat és adatokat, valamint a jelenleg érvényes nyelvi korlátozásokat.
Alapértelmezés szerint egy PowerShell-osztály annak a runspace-nek a társához van kapcsolva, ahol létre van hozva. A PowerShell-osztály ForEach-Object -Parallel használata nem biztonságos.
Az osztály metódushívásai vissza lesznek rendezve ahhoz a futtató térhez , ahol létrejött, ami károsíthatja a runspace állapotát, vagy holtpontot okozhat.
NoRunspaceAffinity Az attribútum az osztálydefinícióhoz való hozzáadása biztosítja, hogy a PowerShell-osztály ne legyen egy adott runspace-hez kapcsolódva. A metódushívások , mind a példány, mind a statikus, a futó szál futtatóterét és a szál aktuális munkamenet-állapotát használják.
Az attribútum a PowerShell 7.4-ben lett hozzáadva.
Az attribútummal és anélkül rendelkező osztályok viselkedésbeli különbségének szemléltetéséért lásd a NoRunspaceAffinity 4. példát.
Osztályok exportálása típusgyorsítókkal
A PowerShell-modulok alapértelmezés szerint nem exportálják automatikusan a PowerShellben definiált osztályokat és számbavételeket. Az egyéni típusok nem érhetők el a modulon kívül utasítás meghívása using module nélkül.
Ha azonban egy modul típusgyorsítókat ad hozzá, ezek a típusgyorsítók azonnal elérhetők lesznek a munkamenetben, miután a felhasználók importálták a modult.
Feljegyzés
A típusgyorsítók munkamenethez való hozzáadása belső (nem nyilvános) API-t használ. Az API használata ütközéseket okozhat. Az alábbi minta hibát jelez, ha a modul importálásakor már létezik egy azonos nevű típusgyorsító. Emellett eltávolítja a típusgyorsítókat, amikor eltávolítja a modult a munkamenetből.
Ez a minta biztosítja, hogy a típusok elérhetők legyenek egy munkamenetben. Ez nem befolyásolja az IntelliSense-t vagy a befejezést, amikor szkriptfájlt hoz létre a VS Code-ban.
Ahhoz, hogy intelliSense és kiegészítési javaslatokat kapjon a VS Code egyéni típusaihoz, hozzá kell adnia egy utasítást using module a szkript tetejére.
Az alábbi minta bemutatja, hogyan regisztrálhat PowerShell-osztályokat és számbavételeket típusgyorsítókként egy modulban. Adja hozzá a kódrészletet a gyökérszkriptmodulhoz a típusdefiníciók után. Győződjön meg arról, hogy a $ExportableTypes változó tartalmazza azokat a típusokat, amelyeket elérhetővé szeretne tenni a felhasználók számára a modul importálásakor. A másik kód nem igényel szerkesztést.
# Define the types to export with type accelerators.
$ExportableTypes =@(
[DefinedTypeName]
)
# Get the internal TypeAccelerators class to use its static methods.
$TypeAcceleratorsClass = [psobject].Assembly.GetType(
'System.Management.Automation.TypeAccelerators'
)
# Ensure none of the types would clobber an existing type accelerator.
# If a type accelerator with the same name exists, throw an exception.
$ExistingTypeAccelerators = $TypeAcceleratorsClass::Get
foreach ($Type in $ExportableTypes) {
if ($Type.FullName -in $ExistingTypeAccelerators.Keys) {
$Message = @(
"Unable to register type accelerator '$($Type.FullName)'"
'Accelerator already exists.'
) -join ' - '
throw [System.Management.Automation.ErrorRecord]::new(
[System.InvalidOperationException]::new($Message),
'TypeAcceleratorAlreadyExists',
[System.Management.Automation.ErrorCategory]::InvalidOperation,
$Type.FullName
)
}
}
# Add type accelerators for every exportable type.
foreach ($Type in $ExportableTypes) {
$TypeAcceleratorsClass::Add($Type.FullName, $Type)
}
# Remove type accelerators when the module is removed.
$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
foreach($Type in $ExportableTypes) {
$TypeAcceleratorsClass::Remove($Type.FullName)
}
}.GetNewClosure()
Amikor a felhasználók importálják a modult, a munkamenet típusgyorsítóihoz hozzáadott típusok azonnal elérhetők lesznek az IntelliSense és a befejezés számára. A modul eltávolításakor a típusgyorsítók is.
Osztályok manuális importálása PowerShell-modulból
Import-Module és az #requires utasítás csak a modul által meghatározott modulfüggvényeket, aliasokat és változókat importálja. Az osztályok nincsenek importálva.
Ha egy modul osztályokat és számbavételeket határoz meg, de nem ad hozzá típusgyorsítókat ezekhez a típusokhoz, egy utasítással using module importálhatja őket.
Az using module utasítás osztályokat és számbavételeket importál egy szkriptmodul vagy bináris modul gyökérmoduljából (ModuleToProcess). Nem importálja következetesen a beágyazott modulokban vagy szkriptekben definiált osztályokban definiált osztályokat, amelyek pontforrásból vannak a gyökérmodulba. Definiálja azokat az osztályokat, amelyeket a modulon kívüli felhasználók számára közvetlenül a gyökérmodulban szeretne elérhetővé tenni.
Az utasítással kapcsolatos további információkért lásd: using about_Using.
Újonnan módosított kód betöltése a fejlesztés során
A szkriptmodul fejlesztése során gyakori, hogy módosítja a kódot, majd betölti a modul új verzióját a Force paraméterrelImport-Module. A modul újratöltése csak a gyökérmodul függvényeinek módosításához működik. Import-Module nem tölt be beágyazott modulokat. Emellett nem lehet betölteni a frissített osztályokat.
Ahhoz, hogy a legújabb verziót futtassa, új munkamenetet kell indítania.
A PowerShellben definiált és utasítással using importált osztályok és enumerálások nem távolíthatók el.
Egy másik gyakori fejlesztési gyakorlat a kód különböző fájlokra való elkülönítése. Ha egy másik modulban definiált osztályokat használó fájlban van függvény, az utasítással using module győződjön meg arról, hogy a függvények rendelkeznek a szükséges osztálydefiníciókkal.
A PSReference típus nem támogatott az osztálytagok számára
A [ref] típusgyorsító a PSReference osztály rövidítése. Az [ref] osztálytagok beírása csendesen meghiúsul. A paramétereket használó [ref] API-k nem használhatók az osztálytagokkal. A PSReference osztály a COM-objektumok támogatására lett tervezve. A COM-objektumok olyan esetek, amikor egy értéket hivatkozással kell megadni.
További információt a PSReference osztályban talál.
Korlátozások
Az alábbi listák a PowerShell-osztályok meghatározására vonatkozó korlátozásokat és a korlátozások kerülő megoldásait tartalmazzák, ha vannak ilyenek.
Általános korlátozások
Az osztálytagok nem használhatják a PSReference-t típusként.
Megkerülő megoldás: Nincs.
A PowerShell-osztályok nem távolíthatók el és nem tölthetők be újra egy munkamenetben.
Megkerülő megoldás: Új munkamenet indítása.
A modulban definiált PowerShell-osztályok nem lesznek automatikusan importálva.
Megkerülő megoldás: Adja hozzá a definiált típusokat a gyökérmodul típusgyorsítóinak listájához. Ez elérhetővé teszi a típusokat a modulimportáláskor.
A
hiddenkulcsszavak csakstaticaz osztálytagokra vonatkoznak, az osztálydefiníciókra nem.Megkerülő megoldás: Nincs.
A PowerShell-osztályok alapértelmezés szerint nem biztonságosak a futtatóterek párhuzamos végrehajtásában. Amikor metódusokat hív meg egy osztályon, a PowerShell visszaállítja a meghívásokat arra a runspace-be , ahol az osztály létre lett hozva, ami károsíthatja a runspace állapotát, vagy holtpontot okozhat.
Megkerülő megoldás: Adja hozzá az
NoRunspaceAffinityattribútumot az osztálydeklarációhoz.
Konstruktorokra vonatkozó korlátozások
A konstruktorláncolás nincs implementálva.
Megkerülő megoldás: Definiálja a rejtett
Init()metódusokat, és hívja meg őket a konstruktorokból.A konstruktorparaméterek nem használhatnak attribútumokat, beleértve az érvényesítési attribútumokat is.
Megkerülő megoldás: A konstruktor törzsében lévő paraméterek hozzárendelése az érvényesítési attribútummal.
A konstruktorparaméterek nem definiálhatnak alapértelmezett értékeket. A paraméterek mindig kötelezőek.
Megkerülő megoldás: Nincs.
Ha egy konstruktor túlterhelése rejtett, a konstruktor minden túlterhelése is rejtettként lesz kezelve.
Megkerülő megoldás: Nincs.
Metóduskorlátozások
A metódusparaméterek nem használhatnak attribútumokat, beleértve az érvényesítési attribútumokat is.
Megkerülő megoldás: Rendelje újra a metódus törzsének paramétereit az érvényesítési attribútummal, vagy határozza meg a metódust a statikus konstruktorban a
Update-TypeDataparancsmaggal.A metódusparaméterek nem definiálhatnak alapértelmezett értékeket. A paraméterek mindig kötelezőek.
Megkerülő megoldás: Adja meg a metódust a statikus konstruktorban a
Update-TypeDataparancsmaggal.A metódusok mindig nyilvánosak, még akkor is, ha rejtve vannak. Felül lehet őket bírálni, ha az osztály öröklődik.
Megkerülő megoldás: Nincs.
Ha egy metódus túlterhelése rejtett, a metódus minden túlterhelése is rejtettként lesz kezelve.
Megkerülő megoldás: Nincs.
Tulajdonságkorlátozások
A statikus tulajdonságok mindig változékonyak. A PowerShell-osztályok nem definiálhatnak nem módosítható statikus tulajdonságokat.
Megkerülő megoldás: Nincs.
A tulajdonságok nem használhatják a ValidateScript attribútumot, mert az osztálytulajdonság-attribútum argumentumainak állandóknak kell lenniük.
Megkerülő megoldás: Definiáljon egy osztályt, amely a ValidateArgumentsAttribute típustól örököl , és használja inkább ezt az attribútumot.
A közvetlenül deklarált tulajdonságok nem definiálhatnak egyéni getter- és setter-implementációkat.
Megkerülő megoldás: Definiáljon egy rejtett tulajdonságot, és definiálja
Update-TypeDataa látható getter és a setter logikát.A tulajdonságok nem használhatják az Alias attribútumot. Az attribútum csak paraméterekre, parancsmagokra és függvényekre vonatkozik.
Megkerülő megoldás: A parancsmaggal
Update-TypeDataaliasokat definiálhat az osztálykonstruktorokban.Amikor a parancsmaggal
ConvertTo-JsonJSON-ra konvertál egy PowerShell-osztályt, a kimeneti JSON tartalmazza az összes rejtett tulajdonságot és azok értékeit.Megkerülő megoldás: Nincs
Öröklési korlátozások
A PowerShell nem támogatja a szkriptkódban lévő interfészek meghatározását.
Megkerülő megoldás: Adja meg a C# felületeit, és hivatkozzon az illesztőket meghatározó szerelvényre.
A PowerShell-osztályok csak egy alaposztályból örökölhetnek.
Megkerülő megoldás: Az osztályöröklés tranzitív. A származtatott osztály örökölhet egy másik származtatott osztálytól, hogy lekérje az alaposztály tulajdonságait és metódusait.
Ha általános osztályból vagy interfészből örököl, az általános típusparamétert már meg kell határozni. Az osztály nem definiálhatja magát egy osztály vagy felület típusparamétereként.
Megkerülő megoldás: Ha általános alaposztályból vagy felületből szeretne származni, adja meg az egyéni típust egy másik
.psm1fájlban, és azusing moduleutasítással töltse be a típust. Nincs áthidaló megoldás arra, hogy egy egyéni típus típusparaméterként használja magát az általánostól való öröklődéskor.
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: