Acerca de las clasesAbout Classes

Descripción breveShort description

Describe cómo puede utilizar las clases para crear sus propios tipos personalizados.Describes how you can use classes to create your own custom types.

Descripción largaLong description

PowerShell 5,0 agrega una sintaxis formal para definir clases y otros tipos definidos por el usuario.PowerShell 5.0 adds a formal syntax to define classes and other user-defined types. La adición de clases permite a los desarrolladores y profesionales de ti adoptar PowerShell para una gama más amplia de casos de uso.The addition of classes enables developers and IT professionals to embrace PowerShell for a wider range of use cases. Simplifica el desarrollo de artefactos de PowerShell y acelera la cobertura de las superficies de administración.It simplifies development of PowerShell artifacts and accelerates coverage of management surfaces.

Una declaración de clase es un plano que se usa para crear instancias de objetos en tiempo de ejecución.A class declaration is a blueprint used to create instances of objects at run time. Al definir una clase, el nombre de la clase es el nombre del tipo.When you define a class, the class name is the name of the type. Por ejemplo, si declara una clase denominada Device e inicializa una variable $dev en una nueva instancia de Device , $dev es un objeto o una instancia de 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 . Cada instancia de dispositivo puede tener valores diferentes en sus propiedades.Each instance of Device can have different values in its properties.

Escenarios admitidosSupported scenarios

  • Defina tipos personalizados en PowerShell mediante la conocida semántica de programación orientada a objetos, como clases, propiedades, métodos, herencia, etc.Define custom types in PowerShell using familiar object-oriented programming semantics like classes, properties, methods, inheritance, etc.
  • Depure tipos mediante el lenguaje de PowerShell.Debug types using the PowerShell language.
  • Generar y controlar excepciones mediante mecanismos formales.Generate and handle exceptions using formal mechanisms.
  • Defina los recursos de DSC y sus tipos asociados mediante el lenguaje de PowerShell.Define DSC resources and their associated types by using the PowerShell language.

SintaxisSyntax

Las clases se declaran con la sintaxis siguiente: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> ...]
}

Las instancias de las clases se crean mediante cualquiera de las siguientes sintaxis: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

Cuando se usa la [<class-name>]::new() sintaxis, los corchetes que rodean el nombre de clase son obligatorios.When using the [<class-name>]::new() syntax, brackets around the class name are mandatory. Los corchetes señalan una definición de tipo para PowerShell.The brackets signal a type definition for PowerShell.

Sintaxis y uso de ejemploExample syntax and usage

En este ejemplo se muestra la sintaxis mínima necesaria para crear una clase utilizable.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

Propiedades de claseClass properties

Las propiedades son variables declaradas en el ámbito de clase.Properties are variables declared at class scope. Una propiedad puede ser de cualquier tipo integrado o una instancia de otra clase.A property may be of any built-in type or an instance of another class. Las clases no tienen ninguna restricción en el número de propiedades que tienen.Classes have no restriction in the number of properties they have.

Clase de ejemplo con propiedades simplesExample 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

Tipos complejos de ejemplo en las propiedades de claseExample complex types in class properties

En este ejemplo se define una clase de bastidor vacía mediante la clase Device .This example defines an empty Rack class using the Device class. En los ejemplos siguientes, se muestra cómo agregar dispositivos al bastidor y cómo empezar con un bastidor previamente cargado.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...}


Métodos de claseClass methods

Los métodos definen las acciones que una clase puede realizar.Methods define the actions that a class can perform. Los métodos pueden tomar parámetros que proporcionan datos de entrada.Methods may take parameters that provide input data. Los métodos pueden devolver resultados.Methods can return output. Los datos devueltos por un método pueden ser cualquier tipo de datos definido.Data returned by a method can be any defined data type.

Al definir un método para una clase, se hace referencia al objeto de clase actual mediante la $this variable automática.When defining a method for a class, you reference the current class object by using the $this automatic variable. Esto permite tener acceso a las propiedades y otros métodos definidos en la clase actual.This allows you to access properties and other methods defined in the current class.

Ejemplo de una clase simple con propiedades y métodosExample simple class with properties and methods

Extensión de la clase bastidor para agregar y quitar dispositivos en él.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

Resultados en métodos de claseOutput in class methods

Los métodos deben tener un tipo de valor devuelto definido.Methods should have a return type defined. Si un método no devuelve resultados, el tipo de salida debe ser [void] .If a method doesn't return output, then the output type should be [void].

En los métodos de clase, no se envía ningún objeto a la canalización, excepto los que se mencionan en la return instrucción.In class methods, no objects get sent to the pipeline except those mentioned in the return statement. No hay ninguna salida accidental a la canalización desde el código.There's no accidental output to the pipeline from the code.

Nota

Esto es fundamentalmente diferente del modo en que las funciones de PowerShell controlan la salida, donde todo va a la canalización.This is fundamentally different from how PowerShell functions handle output, where everything goes to the pipeline.

Los errores de no terminación escritos en la secuencia de error desde dentro de un método de clase no se pasan.Non-terminating errors written to the error stream from inside a class method are not passed through. Debe usar throw para exponer un error de terminación.You must use throw to surface a terminating error. Con los Write-* cmdlets, todavía puede escribir en los flujos de salida de PowerShell desde dentro de un método de clase.Using the Write-* cmdlets, you can still write to PowerShell's output streams from within a class method. Sin embargo, debe evitarse para que el método emita objetos solo con la return instrucción.However, this should be avoided so that the method emits objects using only the return statement.

Salida del métodoMethod output

En este ejemplo no se muestra ninguna salida accidental de la canalización de los métodos de clase, excepto en la return instrucción.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

ConstructorConstructor

Los constructores permiten establecer valores predeterminados y validar la lógica del objeto en el momento de crear la instancia de la clase.Constructors enable you to set default values and validate object logic at the moment of creating the instance of the class. Los constructores tienen el mismo nombre que la clase.Constructors have the same name as the class. Los constructores pueden tener argumentos para inicializar los miembros de datos del nuevo objeto.Constructors might have arguments, to initialize the data members of the new object.

La clase puede tener cero o más constructores definidos.The class can have zero or more constructors defined. Si no se define ningún constructor, se proporciona a la clase un constructor sin parámetros predeterminado.If no constructor is defined, the class is given a default parameterless constructor. Este constructor inicializa todos los miembros con sus valores predeterminados.This constructor initializes all members to their default values. A los tipos de objeto y las cadenas se les asignan valores NULL.Object types and strings are given null values. Al definir el constructor, no se crea ningún constructor sin parámetros predeterminado.When you define constructor, no default parameterless constructor is created. Cree un constructor sin parámetros si es necesario.Create a parameterless constructor if one is needed.

Sintaxis básica del constructorConstructor basic syntax

En este ejemplo, la clase de dispositivo se define con propiedades y un constructor.In this example, the Device class is defined with properties and a constructor. Para usar esta clase, el usuario debe proporcionar los valores de los parámetros enumerados en el constructor.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

Ejemplo con varios constructoresExample with multiple constructors

En este ejemplo, la clase Device se define con propiedades, un constructor predeterminado y un constructor para inicializar la instancia.In this example, the Device class is defined with properties, a default constructor, and a constructor to initialize the instance.

El constructor predeterminado establece la marca en undefined y deja Model y Vendor-SKU con valores 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

Atributo HiddenHidden attribute

El hidden atributo oculta una propiedad o un método.The hidden attribute hides a property or method. La propiedad o el método todavía es accesible para el usuario y está disponible en todos los ámbitos en los que el objeto está disponible.The property or method is still accessible to the user and is available in all scopes in which the object is available. Los miembros ocultos están ocultos del Get-Member cmdlet y no se pueden mostrar mediante la finalización con tabulación o IntelliSense fuera de la definición de clase.Hidden members are hidden from the Get-Member cmdlet and can't be displayed using tab completion or IntelliSense outside the class definition.

Para obtener más información, vea About_hidden.For more information, see About_hidden.

Ejemplo de uso de atributos ocultosExample using hidden attributes

Cuando se crea un objeto de bastidor , el número de ranuras de los dispositivos es un valor fijo que no debe cambiarse en ningún 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. Este valor se conoce en el momento de la creación.This value is known at creation time.

El uso del atributo Hidden permite al desarrollador mantener el número de ranuras ocultas y evita que los cambios involuntarios en el tamaño del bastidor.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 propiedad ranuras de aviso no se muestra en la $r1 salida.Notice Slots property isn't shown in $r1 output. Sin embargo, el constructor ha cambiado el tamaño.However, the size was changed by the constructor.

Static (atributo)Static attribute

El static atributo define una propiedad o un método que existe en la clase y no necesita ninguna instancia.The static attribute defines a property or a method that exists in the class and needs no instance.

Una propiedad estática está siempre disponible, independientemente de la creación de instancias de clase.A static property is always available, independent of class instantiation. Una propiedad estática se comparte entre todas las instancias de la clase.A static property is shared across all instances of the class. Un método estático está disponible siempre.A static method is available always. Todas las propiedades estáticas están activas para todo el intervalo de sesiones.All static properties live for the entire session span.

Ejemplo de uso de atributos y métodos estáticosExample using static attributes and methods

Asuma que los bastidores que se crean aquí existen en su centro de datos.Assume the racks instantiated here exist in your data center. Por lo tanto, le gustaría realizar un seguimiento de los bastidores en el código.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))
        }
    }
}

La prueba de la propiedad estática y el método existenTesting 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

Tenga en cuenta que el número de bastidores aumenta cada vez que se ejecuta este ejemplo.Notice that the number of racks increases each time you run this example.

Atributos de validación de propiedadesProperty validation attributes

Los atributos de validación permiten probar que los valores dados a las propiedades cumplen los requisitos definidos.Validation attributes allow you to test that values given to properties meet defined requirements. La validación se desencadena en el momento en que se asigna el valor.Validation is triggered the moment that the value is assigned. Vea about_functions_advanced_parameters.See about_functions_advanced_parameters.

Ejemplo de uso de atributos de validaciónExample 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

Herencia en clases de PowerShellInheritance in PowerShell classes

Puede extender una clase creando una nueva clase que derive de una clase existente.You can extend a class by creating a new class that derives from an existing class. La clase derivada hereda las propiedades de la clase base.The derived class inherits the properties of the base class. Puede Agregar o invalidar métodos y propiedades según sea necesario.You can add or override methods and properties as required.

PowerShell no admite la herencia múltiple.PowerShell does not support multiple inheritance. Las clases no pueden heredar de más de una clase.Classes cannot inherit from more than one class. Sin embargo, puede usar interfaces para ese propósito.However, you can use interfaces for that purpose.

El operador define la implementación de la herencia : , lo que significa que se extiende esta clase o se implementan estas interfaces.Inheritance implementation is defined by the : operator; which means to extend this class or implements these interfaces. La clase derivada siempre debe estar más a la izquierda en la declaración de clase.The derived class should always be leftmost in the class declaration.

Ejemplo con sintaxis de herencia simpleExample using simple inheritance syntax

En este ejemplo se muestra la sintaxis de herencia de clases de PowerShell simple.This example shows the simple PowerShell class inheritance syntax.

Class Derived : Base {...}

En este ejemplo se muestra la herencia con una declaración de interfaz que va después de la clase base.This example shows inheritance with an interface declaration coming after the base class.

Class Derived : Base, Interface {...}

Ejemplo de herencia simple en clases de PowerShellExample of simple inheritance in PowerShell classes

En este ejemplo, las clases de bastidor y de dispositivo usadas en los ejemplos anteriores se definen mejor para: evitar repeticiones de propiedad, alinear mejor las propiedades comunes y reutilizar la lógica de negocios común.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 mayoría de los objetos del centro de datos son activos de la empresa, lo que tiene sentido comenzar a realizar el seguimiento como activos.Most objects in the data center are company assets, which makes sense to start tracking them as assets. Los tipos de dispositivos se definen mediante la DeviceType enumeración; consulte about_Enum para obtener más información sobre las enumeraciones.Device types are defined by the DeviceType enumeration, see about_Enum for details on enumerations.

En nuestro ejemplo, solo vamos a definir Rack y, ComputeServer ambas extensiones a la Device clase.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

Llamar a constructores de clase baseCalling base class constructors

Para invocar un constructor de clase base desde una subclase, agregue la base palabra clave.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

Invocar métodos de clase baseInvoke base class methods

Para invalidar los métodos existentes en las subclases, declare métodos con el mismo nombre y la misma 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

Para llamar a métodos de clase base desde implementaciones reemplazadas, convierta a la clase base ([BaseClass] $this) en la invocación.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

Heredar de interfacesInheriting from interfaces

Las clases de PowerShell pueden implementar una interfaz con la misma sintaxis de herencia usada para ampliar las clases base.PowerShell classes can implement an interface using the same inheritance syntax used to extend base classes. Dado que las interfaces permiten la herencia múltiple, una clase de PowerShell que implementa una interfaz puede heredar de varios tipos, separando los nombres de tipo después de los dos puntos ( : ) con comas ( , ).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 clase de PowerShell que implementa una interfaz debe implementar todos los miembros de esa interfaz.A PowerShell class that implements an interface must implement all the members of that interface. Omitir los miembros de la interfaz de implementación produce un error en tiempo de análisis en el script.Omitting the implemention interface members causes a parse-time error in the script.

Nota

PowerShell no admite actualmente la declaración de nuevas interfaces en el script de 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;
    }
}

Importar clases de un módulo de PowerShellImporting classes from a PowerShell module

Import-Module y la #requires instrucción solo importa las funciones, los alias y las variables del módulo, tal y como se define en el módulo.Import-Module and the #requires statement only import the module functions, aliases, and variables, as defined by the module. No se importan las clases.Classes are not imported. La using module instrucción importa las clases definidas en el módulo.The using module statement imports the classes defined in the module. Si el módulo no está cargado en la sesión actual, using se produce un error en la instrucción.If the module isn't loaded in the current session, the using statement fails. Para obtener más información acerca de la using instrucción, vea about_Using.For more information about the using statement, see about_Using.

No se admite el tipo PSReference con miembros de claseThe PSReference type is not supported with class members

El uso de la [ref] conversión de tipos con un miembro de clase produce un error de forma silenciosa.Using the [ref] type-cast with a class member silently fails. Las API que utilizan [ref] parámetros no se pueden usar con miembros de clase.APIs that use [ref] parameters cannot be used with class members. PSReference se diseñó para admitir objetos com.The PSReference was designed to support COM objects. Los objetos COM tienen casos en los que es necesario pasar un valor en por referencia.COM objects have cases where you need to pass a value in by reference.

Para obtener más información sobre el [ref] tipo, consulte clase PSReference.For more information about the [ref] type, see PSReference Class.

Consulte tambiénSee also