Freigeben über

about_Classes

  • Artikel

Kurze Beschreibung

Beschreibt, wie Sie Klassen verwenden können, um Ihre eigenen benutzerdefinierten Typen zu erstellen.

Lange Beschreibung

PowerShell 5.0 fügt eine formale Syntax hinzu, um Klassen und andere benutzerdefinierte Typen zu definieren. Durch das Hinzufügen von Klassen können Entwickler und IT-Experten PowerShell für eine breitere Palette von Anwendungsfällen nutzen. Es vereinfacht die Entwicklung von PowerShell-Artefakten und beschleunigt die Abdeckung von Verwaltungsoberflächen.

Eine Klassendeklaration ist eine Blaupause, die zum Erstellen von Instanzen von Objekten zur Laufzeit verwendet wird. Wenn Sie eine Klasse definieren, ist der Klassenname der Name des Typs. Wenn Sie beispielsweise eine Klasse mit dem Namen Device deklarieren und eine Variable $dev für eine neue instance von Device initialisieren, $dev handelt es sich um ein Objekt oder instance vom Typ Device. Jede instance von Device kann unterschiedliche Werte in ihren Eigenschaften aufweisen.

Unterstützte Szenarios

  • Definieren Sie benutzerdefinierte Typen in PowerShell mithilfe vertrauter objektorientierter Programmiersemantik wie Klassen, Eigenschaften, Methoden, Vererbung usw.
  • Debugtypen mithilfe der PowerShell-Sprache.
  • Generieren und Behandeln von Ausnahmen mithilfe formaler Mechanismen.
  • Definieren Sie DSC-Ressourcen und die zugehörigen Typen mithilfe der PowerShell-Sprache.

Syntax

Klassen werden mit der folgenden Syntax deklariert:

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> ...]
}

Klassen werden mit einer der folgenden Syntaxen instanziiert:

[$<variable-name> =] New-Object -TypeName <class-name> [
  [-ArgumentList] <constructor-argument-list>]

[$<variable-name> =] [<class-name>]::new([<constructor-argument-list>])

Hinweis

Bei Verwendung der [<class-name>]::new() Syntax sind Klammern um den Klassennamen obligatorisch. Die Klammern signalisieren eine Typdefinition für PowerShell.

Beispielsyntax und -verwendung

Dieses Beispiel zeigt die minimale Syntax, die zum Erstellen einer verwendbaren Klasse erforderlich ist.

class Device {
    [string]$Brand
}

$dev = [Device]::new()
$dev.Brand = "Microsoft"
$dev

Brand
-----
Microsoft

Klasseneigenschaften

Eigenschaften sind Variablen, die im Klassenbereich deklariert werden. Eine Eigenschaft kann von jedem integrierten Typ oder einem instance einer anderen Klasse sein. Klassen haben keine Einschränkung in bezug auf die Anzahl der Eigenschaften, über die sie verfügen.

Beispielklasse mit einfachen Eigenschaften

class Device {
    [string]$Brand
    [string]$Model
    [string]$VendorSku
}

$device = [Device]::new()
$device.Brand = "Microsoft"
$device.Model = "Surface Pro 4"
$device.VendorSku = "5072641000"

$device

Brand     Model         VendorSku
-----     -----         ---------
Microsoft Surface Pro 4 5072641000

Beispielkomplexe Typen in Klasseneigenschaften

In diesem Beispiel wird eine leere Rack-Klasse mithilfe der Device-Klasse definiert. Die folgenden Beispiele zeigen, wie Sie Dem Rack Geräte hinzufügen und mit einem vorinstallierten Rack beginnen.

class Device {
    [string]$Brand
    [string]$Model
    [string]$VendorSku
}

class Rack {
    [string]$Brand
    [string]$Model
    [string]$VendorSku
    [string]$AssetId
    [Device[]]$Devices = [Device[]]::new(8)

}

$rack = [Rack]::new()

$rack


Brand     :
Model     :
VendorSku :
AssetId   :
Devices   : {$null, $null, $null, $null...}

Klassenmethoden

Methoden definieren die Aktionen, die von einer Klasse ausgeführt werden können. Methoden können Parameter verwenden, die Eingabedaten bereitstellen. Methoden können eine Ausgabe zurückgeben. Von einer Methode zurückgegebene Daten können beliebiger definierter Datentyp sein.

Wenn Sie eine Methode für eine Klasse definieren, verweisen Sie mithilfe der automatischen Variablen auf das $this aktuelle Klassenobjekt. Dadurch können Sie auf Eigenschaften und andere Methoden zugreifen, die in der aktuellen Klasse definiert sind.

Einfache Beispielklasse mit Eigenschaften und Methoden

Erweitern der Rack-Klasse , um Geräte hinzuzufügen und daraus zu entfernen.

class Device {
    [string]$Brand
    [string]$Model
    [string]$VendorSku

    [string]ToString(){
        return ("{0}|{1}|{2}" -f $this.Brand, $this.Model, $this.VendorSku)
    }
}

class Rack {
    [int]$Slots = 8
    [string]$Brand
    [string]$Model
    [string]$VendorSku
    [string]$AssetId
    [Device[]]$Devices = [Device[]]::new($this.Slots)

    [void] AddDevice([Device]$dev, [int]$slot){
        ## Add argument validation logic here
        $this.Devices[$slot] = $dev
    }

    [void]RemoveDevice([int]$slot){
        ## Add argument validation logic here
        $this.Devices[$slot] = $null
    }

    [int[]] GetAvailableSlots(){
        [int]$i = 0
        return @($this.Devices.foreach{ if($_ -eq $null){$i}; $i++})
    }
}

$rack = [Rack]::new()

$surface = [Device]::new()
$surface.Brand = "Microsoft"
$surface.Model = "Surface Pro 4"
$surface.VendorSku = "5072641000"

$rack.AddDevice($surface, 2)

$rack
$rack.GetAvailableSlots()


Slots     : 8
Brand     :
Model     :
VendorSku :
AssetId   :
Devices   : {$null, $null, Microsoft|Surface Pro 4|5072641000, $null...}

0
1
3
4
5
6
7

Ausgabe in Klassenmethoden

Für Methoden sollte ein Rückgabetyp definiert sein. Wenn eine Methode keine Ausgabe zurückgibt, sollte der Ausgabetyp sein [void].

In Klassenmethoden werden keine Objekte an die Pipeline gesendet, mit Ausnahme der in der return -Anweisung erwähnten. Es gibt keine versehentliche Ausgabe der Pipeline aus dem Code.

Hinweis

Dies unterscheidet sich grundlegend von der Behandlung der Ausgabe durch PowerShell-Funktionen, bei der alles an die Pipeline geht.

Nicht beendende Fehler, die aus einer Klassenmethode in den Fehlerstream geschrieben wurden, werden nicht übergeben. Sie müssen verwenden throw , um einen Abbruchfehler anzuzeigen. Mit den Write-* Cmdlets können Sie weiterhin in die Ausgabedatenströme von PowerShell innerhalb einer Klassenmethode schreiben. Dies sollte jedoch vermieden werden, sodass die -Methode Objekte nur mit der return -Anweisung ausgibt.

Methodenausgabe

In diesem Beispiel wird keine versehentliche Ausgabe der Pipeline von Klassenmethoden veranschaulicht, mit Ausnahme der return -Anweisung.

class FunWithIntegers
{
    [int[]]$Integers = 0..10

    [int[]]GetOddIntegers(){
        return $this.Integers.Where({ ($_ % 2) })
    }

    [void] GetEvenIntegers(){
        # this following line doesn't go to the pipeline
        $this.Integers.Where({ ($_ % 2) -eq 0})
    }

    [string]SayHello(){
        # this following line doesn't go to the pipeline
        "Good Morning"

        # this line goes to the pipeline
        return "Hello World"
    }
}

$ints = [FunWithIntegers]::new()
$ints.GetOddIntegers()
$ints.GetEvenIntegers()
$ints.SayHello()

1
3
5
7
9
Hello World

Konstruktor

Mit Konstruktoren können Sie Standardwerte festlegen und die Objektlogik überprüfen, wenn Sie die instance der -Klasse erstellen. Konstruktoren haben denselben Namen wie die -Klasse. Konstruktoren verfügen möglicherweise über Argumente, um die Datenmember des neuen Objekts zu initialisieren.

Für die Klasse können null oder mehr Konstruktoren definiert sein. Wenn kein Konstruktor definiert ist, erhält die Klasse einen standardparameterlosen Konstruktor. Dieser Konstruktor initialisiert alle Member mit ihren Standardwerten. Objekttypen und Zeichenfolgen erhalten NULL-Werte. Wenn Sie den Konstruktor definieren, wird kein standardparameterloser Konstruktor erstellt. Create einen parameterlosen Konstruktor, falls erforderlich.

Grundlegende Syntax des Konstruktors

In diesem Beispiel wird die Device-Klasse mit Eigenschaften und einem Konstruktor definiert. Um diese Klasse zu verwenden, muss der Benutzer Werte für die im Konstruktor aufgeführten Parameter bereitstellen.

class Device {
    [string]$Brand
    [string]$Model
    [string]$VendorSku

    Device(
        [string]$b,
        [string]$m,
        [string]$vsk
    ){
        $this.Brand = $b
        $this.Model = $m
        $this.VendorSku = $vsk
    }
}

[Device]$surface = [Device]::new("Microsoft", "Surface Pro 4", "5072641000")

$surface

Brand     Model         VendorSku
-----     -----         ---------
Microsoft Surface Pro 4 5072641000

Beispiel mit mehreren Konstruktoren

In diesem Beispiel wird die Device-Klasse mit Eigenschaften, einem Standardkonstruktor und einem Konstruktor zum Initialisieren des instance definiert.

Der Standardkonstruktor legt die Marke auf Undefined fest und belässt model und vendor-sku mit NULL-Werten.

class Device {
    [string]$Brand
    [string]$Model
    [string]$VendorSku

    Device(){
        $this.Brand = 'Undefined'
    }

    Device(
        [string]$b,
        [string]$m,
        [string]$vsk
    ){
        $this.Brand = $b
        $this.Model = $m
        $this.VendorSku = $vsk
    }
}

[Device]$somedevice = [Device]::new()
[Device]$surface = [Device]::new("Microsoft", "Surface Pro 4", "5072641000")

$somedevice
$surface

Brand       Model           VendorSku
-----       -----           ---------
Undefined
Microsoft   Surface Pro 4   5072641000

Ausgeblendetes Attribut

Das hidden Attribut blendet eine Eigenschaft oder Methode aus. Die Eigenschaft oder Methode ist weiterhin für den Benutzer zugänglich und in allen Bereichen verfügbar, in denen das Objekt verfügbar ist. Ausgeblendete Member sind im Get-Member Cmdlet ausgeblendet und können nicht mithilfe der Registerkarten-Vervollständigung oder IntelliSense außerhalb der Klassendefinition angezeigt werden.

Weitere Informationen finden Sie unter About_hidden.

Beispiel für ausgeblendete Attribute

Wenn ein Rack-Objekt erstellt wird, ist die Anzahl der Slots für Geräte ein fester Wert, der zu keinem Zeitpunkt geändert werden sollte. Dieser Wert ist zur Erstellungszeit bekannt.

Die Verwendung des ausgeblendeten Attributs ermöglicht es dem Entwickler, die Anzahl der Slots ausgeblendet zu halten, und verhindert unbeabsichtigte Änderungen der Größe des Racks.

class Device {
    [string]$Brand
    [string]$Model
}

class Rack {
    [int] hidden $Slots = 8
    [string]$Brand
    [string]$Model
    [Device[]]$Devices = [Device[]]::new($this.Slots)

    Rack ([string]$b, [string]$m, [int]$capacity){
        ## argument validation here

        $this.Brand = $b
        $this.Model = $m
        $this.Slots = $capacity

        ## reset rack size to new capacity
        $this.Devices = [Device[]]::new($this.Slots)
    }
}

[Rack]$r1 = [Rack]::new("Microsoft", "Surface Pro 4", 16)

$r1
$r1.Devices.Length
$r1.Slots

Brand     Model         Devices
-----     -----         -------
Microsoft Surface Pro 4 {$null, $null, $null, $null...}
16
16

Beachten Sie , dass die Slots-Eigenschaft in der $r1 Ausgabe nicht angezeigt wird. Die Größe wurde jedoch vom Konstruktor geändert.

Statisches Attribut

Das static Attribut definiert eine Eigenschaft oder Methode, die in der -Klasse vorhanden ist und keine instance benötigt.

Eine statische Eigenschaft ist unabhängig von der Klasseninstanziierung immer verfügbar. Eine statische Eigenschaft wird für alle Instanzen der -Klasse freigegeben. Eine statische Methode ist immer verfügbar. Alle statischen Eigenschaften werden für die gesamte Sitzungsspanne aktiv.

Beispiel für statische Attribute und Methoden

Angenommen, die hier instanziierten Racks sind in Ihrem Rechenzentrum vorhanden. Sie möchten also die Racks in Ihrem Code nachverfolgen.

class Device {
    [string]$Brand
    [string]$Model
}

class Rack {
    hidden [int] $Slots = 8
    static [Rack[]]$InstalledRacks = @()
    [string]$Brand
    [string]$Model
    [string]$AssetId
    [Device[]]$Devices = [Device[]]::new($this.Slots)

    Rack ([string]$b, [string]$m, [string]$id, [int]$capacity){
        ## argument validation here

        $this.Brand = $b
        $this.Model = $m
        $this.AssetId = $id
        $this.Slots = $capacity

        ## reset rack size to new capacity
        $this.Devices = [Device[]]::new($this.Slots)

        ## add rack to installed racks
        [Rack]::InstalledRacks += $this
    }

    static [void]PowerOffRacks(){
        foreach ($rack in [Rack]::InstalledRacks) {
            Write-Warning ("Turning off rack: " + ($rack.AssetId))
        }
    }
}

Testen von statischen Eigenschaften und Methoden

PS> [Rack]::InstalledRacks.Length
0

PS> [Rack]::PowerOffRacks()

PS> (1..10) | ForEach-Object {
>>   [Rack]::new("Adatum Corporation", "Standard-16",
>>     $_.ToString("Std0000"), 16)
>> } > $null

PS> [Rack]::InstalledRacks.Length
10

PS> [Rack]::InstalledRacks[3]
Brand              Model       AssetId Devices
-----              -----       ------- -------
Adatum Corporation Standard-16 Std0004 {$null, $null, $null, $null...}

PS> [Rack]::PowerOffRacks()
WARNING: Turning off rack: Std0001
WARNING: Turning off rack: Std0002
WARNING: Turning off rack: Std0003
WARNING: Turning off rack: Std0004
WARNING: Turning off rack: Std0005
WARNING: Turning off rack: Std0006
WARNING: Turning off rack: Std0007
WARNING: Turning off rack: Std0008
WARNING: Turning off rack: Std0009
WARNING: Turning off rack: Std0010

Beachten Sie, dass die Anzahl der Racks bei jeder Ausführung dieses Beispiels zunimmt.

Eigenschaftenvalidierungsattribute

Mit Validierungsattributen können Sie testen, dass die für Eigenschaften angegebenen Werte den definierten Anforderungen entsprechen. Die Überprüfung wird in dem Moment ausgelöst, in dem der Wert zugewiesen wird. Siehe about_functions_advanced_parameters.

Beispiel für Die Verwendung von Validierungsattributen

class Device {
    [ValidateNotNullOrEmpty()][string]$Brand
    [ValidateNotNullOrEmpty()][string]$Model
}

[Device]$dev = [Device]::new()

Write-Output "Testing dev"
$dev

$dev.Brand = ""

Testing dev

Brand Model
----- -----

Exception setting "Brand": "The argument is null or empty. Provide an
argument that is not null or empty, and then try the command again."
At C:\tmp\Untitled-5.ps1:11 char:1
+ $dev.Brand = ""
+ ~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], SetValueInvocationException
    + FullyQualifiedErrorId : ExceptionWhenSetting

Vererbung in PowerShell-Klassen

Sie können eine Klasse erweitern, indem Sie eine neue Klasse erstellen, die von einer vorhandenen Klasse abgeleitet wird. Die abgeleitete Klasse erbt die Eigenschaften der Basisklasse. Sie können Methoden und Eigenschaften nach Bedarf hinzufügen oder überschreiben.

PowerShell unterstützt keine mehrfache Vererbung. Klassen können nicht von mehr als einer Klasse erben. Für diesen Zweck können Sie jedoch Schnittstellen verwenden.

Die Vererbungsimplementierung wird vom : Operator definiert. Dies bedeutet, dass diese Klasse erweitert oder diese Schnittstellen implementiert werden. Die abgeleitete Klasse sollte in der Klassendeklaration immer ganz links sein.

Beispiel für einfache Vererbungssyntax

Dieses Beispiel zeigt die einfache Syntax der Vererbung von PowerShell-Klassen.

Class Derived : Base {...}

In diesem Beispiel wird die Vererbung mit einer Schnittstellendeklaration nach der Basisklasse gezeigt.

Class Derived : Base, Interface {...}

Beispiel für einfache Vererbung in PowerShell-Klassen

In diesem Beispiel sind die in den vorherigen Beispielen verwendeten Rack- und Device-Klassen besser definiert, um Eigenschaftswiederherstellungswiederherstellungsvorgänge zu vermeiden, allgemeine Eigenschaften besser auszurichten und allgemeine Geschäftslogik wiederzuverwenden.

Die meisten Objekte im Rechenzentrum sind Unternehmensressourcen, was sinnvoll ist, um sie als Ressourcen nachzuverfolgen. Gerätetypen werden durch die DeviceType Enumeration definiert. Ausführliche Informationen zu Enumerationen finden Sie unter about_Enum .

In unserem Beispiel definieren Rack wir nur und ComputeServer. beide Erweiterungen für die Device -Klasse.

enum DeviceType {
    Undefined = 0
    Compute = 1
    Storage = 2
    Networking = 4
    Communications = 8
    Power = 16
    Rack = 32
}

class Asset {
    [string]$Brand
    [string]$Model
}

class Device : Asset {
    hidden [DeviceType]$devtype = [DeviceType]::Undefined
    [string]$Status

    [DeviceType] GetDeviceType(){
        return $this.devtype
    }
}

class ComputeServer : Device {
    hidden [DeviceType]$devtype = [DeviceType]::Compute
    [string]$ProcessorIdentifier
    [string]$Hostname
}

class Rack : Device {
    hidden [DeviceType]$devtype = [DeviceType]::Rack
    hidden [int]$Slots = 8

    [string]$Datacenter
    [string]$Location
    [Device[]]$Devices = [Device[]]::new($this.Slots)

    Rack (){
        ## Just create the default rack with 8 slots
    }

    Rack ([int]$s){
        ## Add argument validation logic here
        $this.Devices = [Device[]]::new($s)
    }

    [void] AddDevice([Device]$dev, [int]$slot){
        ## Add argument validation logic here
        $this.Devices[$slot] = $dev
    }

    [void] RemoveDevice([int]$slot){
        ## Add argument validation logic here
        $this.Devices[$slot] = $null
    }
}

$FirstRack = [Rack]::new(16)
$FirstRack.Status = "Operational"
$FirstRack.Datacenter = "PNW"
$FirstRack.Location = "F03R02.J10"

(0..15).ForEach({
    $ComputeServer = [ComputeServer]::new()
    $ComputeServer.Brand = "Fabrikam, Inc."       ## Inherited from Asset
    $ComputeServer.Model = "Fbk5040"              ## Inherited from Asset
    $ComputeServer.Status = "Installed"           ## Inherited from Device
    $ComputeServer.ProcessorIdentifier = "x64"    ## ComputeServer
    $ComputeServer.Hostname = ("r1s" + $_.ToString("000")) ## ComputeServer
    $FirstRack.AddDevice($ComputeServer, $_)
  })

$FirstRack
$FirstRack.Devices

Datacenter : PNW
Location   : F03R02.J10
Devices    : {r1s000, r1s001, r1s002, r1s003...}
Status     : Operational
Brand      :
Model      :

ProcessorIdentifier : x64
Hostname            : r1s000
Status              : Installed
Brand               : Fabrikam, Inc.
Model               : Fbk5040

ProcessorIdentifier : x64
Hostname            : r1s001
Status              : Installed
Brand               : Fabrikam, Inc.
Model               : Fbk5040

<... content truncated here for brevity ...>

ProcessorIdentifier : x64
Hostname            : r1s015
Status              : Installed
Brand               : Fabrikam, Inc.
Model               : Fbk5040

Aufrufen von Basisklassenkonstruktoren

Um einen Basisklassenkonstruktor aus einer Unterklasse aufzurufen, fügen Sie die base Schlüsselwort (keyword) hinzu.

class Person {
    [int]$Age

    Person([int]$a)
    {
        $this.Age = $a
    }
}

class Child : Person
{
    [string]$School

    Child([int]$a, [string]$s ) : base($a) {
        $this.School = $s
    }
}

[Child]$littleone = [Child]::new(10, "Silver Fir Elementary School")

$littleone.Age


10

Aufrufen von Basisklassenmethoden

Um vorhandene Methoden in Unterklassen zu überschreiben, deklarieren Sie Methoden mit demselben Namen und derselben Signatur.

class BaseClass
{
    [int]days() {return 1}
}
class ChildClass1 : BaseClass
{
    [int]days () {return 2}
}

[ChildClass1]::new().days()


2

Um Basisklassenmethoden aus überschriebenen Implementierungen aufzurufen, wandeln Sie beim Aufruf in die Basisklasse ([Basisklasse]$this) um.

class BaseClass
{
    [int]days() {return 1}
}
class ChildClass1 : BaseClass
{
    [int]days () {return 2}
    [int]basedays() {return ([BaseClass]$this).days()}
}

[ChildClass1]::new().days()
[ChildClass1]::new().basedays()


2
1

Erben von Schnittstellen

PowerShell-Klassen können eine Schnittstelle mit derselben Vererbungssyntax implementieren, die zum Erweitern von Basisklassen verwendet wird. Da Schnittstellen mehrere Vererbungen zulassen, kann eine PowerShell-Klasse, die eine Schnittstelle implementiert, von mehreren Typen erben, indem die Typnamen nach dem Doppelpunkt (:) durch Kommas (,) getrennt werden. Eine PowerShell-Klasse, die eine Schnittstelle implementiert, muss alle Member dieser Schnittstelle implementieren. Das Weglassen der Implementierungsschnittstellenmember verursacht einen Analysezeitfehler im Skript.

Hinweis

PowerShell unterstützt derzeit nicht das Deklarieren neuer Schnittstellen im PowerShell-Skript.

class MyComparable : System.IComparable
{
    [int] CompareTo([object] $obj)
    {
        return 0;
    }
}

class MyComparableBar : bar, System.IComparable
{
    [int] CompareTo([object] $obj)
    {
        return 0;
    }
}

Importieren von Klassen aus einem PowerShell-Modul

Import-Module und die #requires -Anweisung importieren nur die Modulfunktionen, Aliase und Variablen, wie vom Modul definiert. Klassen werden nicht importiert. Die using module -Anweisung importiert die im Modul definierten Klassen. Wenn das Modul in der aktuellen Sitzung nicht geladen wird, schlägt die using Anweisung fehl. Weitere Informationen zur using Anweisung finden Sie unter about_Using.

Die using module -Anweisung importiert Klassen aus dem Stammmodul (ModuleToProcess) eines Skriptmoduls oder binären Moduls. Klassen, die in geschachtelten Modulen definiert sind, oder klassen, die in Skripts definiert sind, die aus Punktquellen stammen, werden nicht konsistent in das Modul importiert. Klassen, die für Benutzer außerhalb des Moduls verfügbar sein sollen, sollten im Stammmodul definiert werden.

Laden von neu geänderten Code während der Entwicklung

Während der Entwicklung eines Skriptmoduls ist es üblich, Änderungen am Code vorzunehmen und dann die neue Version des Moduls mit Import-Module dem Force-Parameter zu laden. Dies funktioniert nur für Änderungen an Funktionen im Stammmodul. Import-Module lädt keine geschachtelten Module neu. Außerdem gibt es keine Möglichkeit, aktualisierte Klassen zu laden.

Um sicherzustellen, dass Sie die neueste Version ausführen, müssen Sie das Modul mit dem Remove-Module Cmdlet entladen. Remove-Module entfernt das Stammmodul, alle geschachtelten Module und alle in den Modulen definierten Klassen. Anschließend können Sie das Modul und die Klassen mit Import-Module und der using module -Anweisung erneut laden.

Eine weitere gängige Entwicklungspraxis besteht darin, Ihren Code in verschiedene Dateien zu unterteilen. Wenn Sie eine Funktion in einer Datei haben, die klassen verwendet, die in einem anderen Modul definiert sind, sollten Sie die using module -Anweisung verwenden, um sicherzustellen, dass die Funktionen über die erforderlichen Klassendefinitionen verfügen.

Der PSReference-Typ wird mit Klassenmembern nicht unterstützt.

Die Verwendung der [ref] Typumwandlung mit einem Klassenmember schlägt im Hintergrund fehl. APIs, die Parameter verwenden [ref] , können nicht mit Klassenmembern verwendet werden. Die PSReference-Klasse wurde für die Unterstützung von COM-Objekten entwickelt. COM-Objekte weisen Fälle auf, in denen Sie einen Wert als Verweis übergeben müssen.

Weitere Informationen zum [ref] Typ finden Sie unter PSReference-Klasse.

Weitere Informationen