Informazioni sulle classiAbout Classes

Breve descrizioneShort description

Viene descritto come utilizzare le classi per creare tipi personalizzati.Describes how you can use classes to create your own custom types.

Descrizione lungaLong description

PowerShell 5,0 aggiunge una sintassi formale per definire classi e altri tipi definiti dall'utente.PowerShell 5.0 adds a formal syntax to define classes and other user-defined types. L'aggiunta di classi consente agli sviluppatori e ai professionisti IT di adottare PowerShell per una più ampia gamma di casi d'uso.The addition of classes enables developers and IT professionals to embrace PowerShell for a wider range of use cases. Semplifica lo sviluppo di artefatti di PowerShell e accelera la copertura delle superfici di gestione.It simplifies development of PowerShell artifacts and accelerates coverage of management surfaces.

Una dichiarazione di classe è un progetto utilizzato per creare istanze di oggetti in fase di esecuzione.A class declaration is a blueprint used to create instances of objects at run time. Quando si definisce una classe, il nome della classe è il nome del tipo.When you define a class, the class name is the name of the type. Se, ad esempio, si dichiara una classe denominata Device e si Inizializza una variabile $dev in una nuova istanza del dispositivo , $dev è un oggetto o un'istanza di tipo Device.For example, if you declare a class named Device and initialize a variable $dev to a new instance of Device , $dev is an object or instance of type Device. Ogni istanza del dispositivo può avere valori diversi nelle proprietà.Each instance of Device can have different values in its properties.

Scenari supportatiSupported scenarios

  • Definire tipi personalizzati in PowerShell usando semantica di programmazione orientata a oggetti familiare come classi, proprietà, metodi, ereditarietà e così via.Define custom types in PowerShell using familiar object-oriented programming semantics like classes, properties, methods, inheritance, etc.
  • Eseguire il debug dei tipi usando il linguaggio di PowerShell.Debug types using the PowerShell language.
  • Generare e gestire le eccezioni tramite meccanismi formali.Generate and handle exceptions using formal mechanisms.
  • Definire le risorse DSC e i relativi tipi associati usando il linguaggio di PowerShell.Define DSC resources and their associated types by using the PowerShell language.

SintassiSyntax

Le classi vengono dichiarate usando la sintassi seguente:Classes are declared using the following syntax:

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

Viene creata un'istanza delle classi utilizzando una delle seguenti sintassi:Classes are instantiated using either of the following syntaxes:

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

Nota

Quando si usa la [<class-name>]::new() sintassi, le parentesi quadre intorno al nome della classe sono obbligatorie.When using the [<class-name>]::new() syntax, brackets around the class name are mandatory. Le parentesi quadre segnalano una definizione di tipo per PowerShell.The brackets signal a type definition for PowerShell.

Sintassi e utilizzo di esempioExample syntax and usage

In questo esempio viene illustrata la sintassi minima necessaria per creare una classe utilizzabile.This example shows the minimum syntax needed to create a usable class.

class Device {
    [string]$Brand
}

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

Proprietà della classeClass properties

Le proprietà sono variabili dichiarate nell'ambito della classe.Properties are variables declared at class scope. Una proprietà può essere di qualsiasi tipo incorporato o di un'istanza di un'altra classe.A property may be of any built-in type or an instance of another class. Le classi non hanno alcuna restrizione nel numero di proprietà.Classes have no restriction in the number of properties they have.

Classe di esempio con proprietà sempliciExample class with simple properties

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

Tipi complessi di esempio nelle proprietà della classeExample complex types in class properties

Questo esempio definisce una classe rack vuota con la classe Device .This example defines an empty Rack class using the Device class. Gli esempi seguenti illustrano come aggiungere dispositivi al rack e come iniziare con un rack precaricato.The examples, following this one, show how to add devices to the rack and how to start with a pre-loaded rack.

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


Metodi della classeClass methods

I metodi definiscono le azioni che una classe è in grado di eseguire.Methods define the actions that a class can perform. I metodi possono assumere parametri che forniscono dati di input.Methods may take parameters that provide input data. I metodi possono restituire l'output.Methods can return output. I dati restituiti da un metodo possono essere qualsiasi tipo di dati definito.Data returned by a method can be any defined data type.

Quando si definisce un metodo per una classe, si fa riferimento all'oggetto classe corrente usando la $this variabile automatica.When defining a method for a class, you reference the current class object by using the $this automatic variable. In questo modo è possibile accedere alle proprietà e ad altri metodi definiti nella classe corrente.This allows you to access properties and other methods defined in the current class.

Esempio di classe semplice con proprietà e metodiExample simple class with properties and methods

Estensione della classe rack per aggiungere e rimuovere dispositivi da o verso tale classe.Extending the Rack class to add and remove devices to or from it.

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

Output nei metodi della classeOutput in class methods

I metodi devono avere un tipo restituito definito.Methods should have a return type defined. Se un metodo non restituisce output, il tipo di output deve essere [void] .If a method doesn't return output, then the output type should be [void].

Nei metodi della classe non viene inviato alcun oggetto alla pipeline, ad eccezione di quelli citati nell' return istruzione.In class methods, no objects get sent to the pipeline except those mentioned in the return statement. Non viene generato alcun output accidentale dalla pipeline dal codice.There's no accidental output to the pipeline from the code.

Nota

Questo è fondamentalmente diverso dal modo in cui le funzioni di PowerShell gestiscono l'output, dove tutto passa alla pipeline.This is fundamentally different from how PowerShell functions handle output, where everything goes to the pipeline.

Gli errori non fatali scritti nel flusso di errore dall'interno di un metodo della classe non vengono passati.Non-terminating errors written to the error stream from inside a class method are not passed through. È necessario utilizzare throw per la segnalazione di un errore di terminazione.You must use throw to surface a terminating error. Usando i Write-* cmdlet, è comunque possibile scrivere nei flussi di output di PowerShell da un metodo di classe.Using the Write-* cmdlets, you can still write to PowerShell's output streams from within a class method. Tuttavia, questa operazione deve essere evitata in modo che il metodo emetta oggetti usando solo l' return istruzione.However, this should be avoided so that the method emits objects using only the return statement.

Output del metodoMethod output

In questo esempio non viene illustrato alcun output accidentale alla pipeline dai metodi della classe, tranne che nell' return istruzione.This example demonstrates no accidental output to the pipeline from class methods, except on the return statement.

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

CostruttoreConstructor

I costruttori consentono di impostare i valori predefiniti e di convalidare la logica dell'oggetto al momento della creazione dell'istanza della classe.Constructors enable you to set default values and validate object logic at the moment of creating the instance of the class. I costruttori hanno lo stesso nome della classe.Constructors have the same name as the class. I costruttori possono avere argomenti per inizializzare i membri dati del nuovo oggetto.Constructors might have arguments, to initialize the data members of the new object.

La classe può avere zero o più costruttori definiti.The class can have zero or more constructors defined. Se non è stato definito alcun costruttore, alla classe viene assegnato un costruttore senza parametri predefinito.If no constructor is defined, the class is given a default parameterless constructor. Questo costruttore inizializza tutti i membri sui rispettivi valori predefiniti.This constructor initializes all members to their default values. Ai tipi di oggetto e alle stringhe vengono assegnati valori null.Object types and strings are given null values. Quando si definisce il costruttore, non viene creato alcun costruttore senza parametri predefinito.When you define constructor, no default parameterless constructor is created. Creare un costruttore senza parametri se ne è necessario uno.Create a parameterless constructor if one is needed.

Sintassi di base del costruttoreConstructor basic syntax

In questo esempio, la classe Device viene definita con proprietà e un costruttore.In this example, the Device class is defined with properties and a constructor. Per utilizzare questa classe, è necessario che l'utente fornisca i valori per i parametri elencati nel costruttore.To use this class, the user is required to provide values for the parameters listed in the constructor.

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

Esempio con più costruttoriExample with multiple constructors

In questo esempio, la classe Device viene definita con proprietà, un costruttore predefinito e un costruttore per inizializzare l'istanza.In this example, the Device class is defined with properties, a default constructor, and a constructor to initialize the instance.

Il costruttore predefinito imposta il marchio su undefined e lascia Model e Vendor-SKU con i valori null.The default constructor sets the brand to Undefined , and leaves model and vendor-sku with null values.

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

Attributo HiddenHidden attribute

L' hidden attributo nasconde una proprietà o un metodo.The hidden attribute hides a property or method. La proprietà o il metodo è ancora accessibile all'utente ed è disponibile in tutti gli ambiti in cui l'oggetto è disponibile.The property or method is still accessible to the user and is available in all scopes in which the object is available. I membri nascosti sono nascosti dal Get-Member cmdlet e non possono essere visualizzati con il completamento tramite TAB o IntelliSense all'esterno della definizione della classe.Hidden members are hidden from the Get-Member cmdlet and can't be displayed using tab completion or IntelliSense outside the class definition.

Per ulteriori informazioni, vedere About_hidden.For more information, see About_hidden.

Esempio di uso di attributi nascostiExample using hidden attributes

Quando viene creato un oggetto rack , il numero di slot per i dispositivi è un valore fisso che non deve essere modificato in qualsiasi momento.When a Rack object is created, the number of slots for devices is a fixed value that shouldn't be changed at any time. Questo valore è noto al momento della creazione.This value is known at creation time.

L'uso dell'attributo Hidden consente allo sviluppatore di memorizzare il numero di slot nascosti e impedisce la modifica delle dimensioni del rack da parte degli sviluppatori.Using the hidden attribute allows the developer to keep the number of slots hidden and prevents unintentional changes the size of the rack.

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

La proprietà degli slot di avviso non è visualizzata nell' $r1 output.Notice Slots property isn't shown in $r1 output. Tuttavia, la dimensione è stata modificata dal costruttore.However, the size was changed by the constructor.

Attributo staticoStatic attribute

L' static attributo definisce una proprietà o un metodo presente nella classe e non necessita di alcuna istanza.The static attribute defines a property or a method that exists in the class and needs no instance.

Una proprietà statica è sempre disponibile, indipendente dall'istanza della classe.A static property is always available, independent of class instantiation. Una proprietà statica viene condivisa tra tutte le istanze della classe.A static property is shared across all instances of the class. Un metodo statico è sempre disponibile.A static method is available always. Tutte le proprietà statiche sono attive per l'intero intervallo di sessioni.All static properties live for the entire session span.

Esempio di uso di attributi e metodi staticiExample using static attributes and methods

Si supponga che i rack di cui è stata creata un'istanza siano presenti nel data center.Assume the racks instantiated here exist in your data center. Quindi, si desidera tenere traccia dei rack nel codice.So, you would like to keep track of the racks in your code.

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))
        }
    }
}

Test della proprietà statica e del metodo esistenteTesting static property and method exist

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

Si noti che il numero di rack aumenta ogni volta che si esegue questo esempio.Notice that the number of racks increases each time you run this example.

Attributi di convalida delle proprietàProperty validation attributes

Gli attributi di convalida consentono di verificare che i valori assegnati alle proprietà soddisfino i requisiti definiti.Validation attributes allow you to test that values given to properties meet defined requirements. La convalida viene attivata nel momento in cui viene assegnato il valore.Validation is triggered the moment that the value is assigned. Vedere about_Functions_Advanced_Parameters.See about_functions_advanced_parameters.

Esempio di uso degli attributi di convalidaExample using validation attributes

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

Ereditarietà nelle classi di PowerShellInheritance in PowerShell classes

È possibile estendere una classe creando una nuova classe che deriva da una classe esistente.You can extend a class by creating a new class that derives from an existing class. La classe derivata eredita le proprietà della classe di base.The derived class inherits the properties of the base class. È possibile aggiungere o eseguire l'override di metodi e proprietà in modo obbligatorio.You can add or override methods and properties as required.

PowerShell non supporta l'ereditarietà multipla.PowerShell does not support multiple inheritance. Le classi non possono ereditare da più di una classe.Classes cannot inherit from more than one class. Tuttavia, è possibile usare le interfacce a tale scopo.However, you can use interfaces for that purpose.

L'implementazione dell'ereditarietà è definita dall' : operatore, che significa estendere questa classe o implementare tali interfacce.Inheritance implementation is defined by the : operator; which means to extend this class or implements these interfaces. La classe derivata deve sempre essere più a sinistra nella dichiarazione di classe.The derived class should always be leftmost in the class declaration.

Esempio di uso della sintassi di ereditarietà sempliceExample using simple inheritance syntax

Questo esempio illustra la semplice sintassi di ereditarietà della classe PowerShell.This example shows the simple PowerShell class inheritance syntax.

Class Derived : Base {...}

In questo esempio viene illustrata l'ereditarietà con una dichiarazione di interfaccia successiva alla classe di base.This example shows inheritance with an interface declaration coming after the base class.

Class Derived : Base, Interface {...}

Esempio di ereditarietà semplice nelle classi di PowerShellExample of simple inheritance in PowerShell classes

In questo esempio le classi del rack e del dispositivo usate negli esempi precedenti sono definite in modo migliore: evitare le ripetizioni delle proprietà, allineare meglio le proprietà comuni e riutilizzare la logica di business comune.In this example the Rack and Device classes used in the previous examples are better defined to: avoid property repetitions, better align common properties, and reuse common business logic.

La maggior parte degli oggetti nel data center è costituita da asset aziendali, pertanto è consigliabile iniziare a monitorarli come asset.Most objects in the data center are company assets, which makes sense to start tracking them as assets. I tipi di dispositivo sono definiti dall' DeviceType enumerazione, vedere about_Enum per informazioni dettagliate sulle enumerazioni.Device types are defined by the DeviceType enumeration, see about_Enum for details on enumerations.

In questo esempio vengono definiti solo e, Rack ComputeServer entrambe le estensioni alla Device classe.In our example, we're only defining Rack and ComputeServer; both extensions to the Device class.

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

Chiamata di costruttori della classe baseCalling base class constructors

Per richiamare un costruttore della classe base da una sottoclasse, aggiungere la base parola chiave.To invoke a base class constructor from a subclass, add the base keyword.

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

Richiama metodi della classe di baseInvoke base class methods

Per eseguire l'override di metodi esistenti nelle sottoclassi, dichiarare i metodi usando lo stesso nome e la stessa firma.To override existing methods in subclasses, declare methods using the same name and signature.

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

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

2

Per chiamare metodi della classe di base da implementazioni sottoposte a override, eseguire il cast alla classe di base ([BaseClass] $this) nella chiamata.To call base class methods from overridden implementations, cast to the base class ([baseclass]$this) on invocation.

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

Ereditarietà dalle interfacceInheriting from interfaces

Le classi PowerShell possono implementare un'interfaccia usando la stessa sintassi di ereditarietà usata per estendere le classi di base.PowerShell classes can implement an interface using the same inheritance syntax used to extend base classes. Poiché le interfacce consentono l'ereditarietà multipla, una classe PowerShell che implementa un'interfaccia può ereditare da più tipi, separando i nomi dei tipi dopo i due punti ( : ) con virgole ( , ).Because interfaces allow multiple inheritance, a PowerShell class implementing an interface may inherit from multiple types, by separating the type names after the colon (:) with commas (,). Una classe PowerShell che implementa un'interfaccia deve implementare tutti i membri di tale interfaccia.A PowerShell class that implements an interface must implement all the members of that interface. Se si ometteno i membri dell'interfaccia di implementazione, lo script genera un errore in fase di analisi.Omitting the implemention interface members causes a parse-time error in the script.

Nota

PowerShell non supporta attualmente la dichiarazione di nuove interfacce nello script di PowerShell.PowerShell does not currently support declaring new interfaces in PowerShell script.

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

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

Importazione di classi da un modulo di PowerShellImporting classes from a PowerShell module

Import-Module l' #requires istruzione importa solo le funzioni del modulo, gli alias e le variabili, come definito dal modulo.Import-Module and the #requires statement only import the module functions, aliases, and variables, as defined by the module. Le classi non vengono importate.Classes are not imported. L' using module istruzione importa le classi definite nel modulo.The using module statement imports the classes defined in the module. Se il modulo non viene caricato nella sessione corrente, l' using istruzione ha esito negativo.If the module isn't loaded in the current session, the using statement fails. Per ulteriori informazioni sull' using istruzione, vedere about_Using.For more information about the using statement, see about_Using.

Il tipo PSReference non è supportato con i membri della classeThe PSReference type is not supported with class members

L'uso del [ref] cast di tipo con un membro della classe non viene eseguito automaticamente.Using the [ref] type-cast with a class member silently fails. Le API che usano [ref] i parametri non possono essere usate con i membri della classe.APIs that use [ref] parameters cannot be used with class members. PSReference è stato progettato per supportare gli oggetti com.The PSReference was designed to support COM objects. Gli oggetti COM presentano casi in cui è necessario passare un valore in per riferimento.COM objects have cases where you need to pass a value in by reference.

Per ulteriori informazioni sul [ref] tipo, vedere classe PSReference.For more information about the [ref] type, see PSReference Class.

Vedere ancheSee also