Clases

Creación de una clase

Una clase sirve para definir la estructura de un objeto. En cierto modo, es su esqueleto. Define los miembros de un objeto, incluidas las propiedades y los métodos.

Class <NombreDeMiClase> {  
    [Type]<Miembro1>  
    [Type]<Miembro2>  
    [Type]<Miembro3>  
    ...  
} 

PS > Class Autor {  
    $Name  
    $Email  
    $Age  
    $PostalCode  
} 

Sobrecarga de métodos (overload)

La sobrecarga de métodos (overload en inglés) permite definir un conjunto de métodos con el mismo nombre. Esto puede parecer un poco confuso, pero hay una explicación bastante sencilla para este proceso. Cada método tiene una firma. Esta firma se define en función de los parámetros del método. El número, el orden y, sobre todo, el tipo de parámetros determinan la firma.

Ejemplo de sobrecarga de un nuevo método GetPostalCode()

PS > Class Autor {  
    ...  
     [String]GetPostalCode([int]$PostalCode){  
         if ($PostalCode -eq 44000){  
            Return 'Nantes'  
         }else{  
            Return 'Desconocido'  
        }  
    }  
    [int]GetPostalCode([string]$PostalCode){  
        if ($PostalCode -eq 'Nantes'){  
            Return 44000  ...

Estática

Las clases tienen una opción estática sobre sus miembros, identificada por la palabra clave static, situada antes del miembro.

Sintaxis

Clase <NombredeMiClase> {  
    static [Type]<Miembro1>  
    static [Type]<Miembro2>  
    ...  
} 

Esta característica garantiza que el miembro esté disponible sin necesidad de instanciar el objeto y, por tanto, de llamar a un constructor.

Las sintaxis para utilizar miembros estáticos son las siguientes:

[MiClase]::<MiembroEstático>  
$MiObjeto::<MiembroEstático> 

Los miembros estáticos se encuentran en un gran número de clases del sistema.

Ejemplo de clase conocida

PS > [DateTime]::Now 
sábado 15 octubre 2016 19:47:04 

Ejemplo de integración de un miembro estático

PS > Class Autor {  
    ...  
       Static $Edition = 'ExpertIT'  
}  
PS > [Autor]::Edition  
ExpertIT  
PS > $Me = [Autor]::New(25)  
PS > $Me::Edition  
ExpertIT 

Preste especial atención a la sintaxis con ::, y no al punto simple (.). Si ha comprendido bien los principios anteriores comprenderá fácilmente la lógica detrás del uso de la variable automática...

Ámbito de las variables

Antes de seguir adelante, es importante conocer bien los conceptos básicos sobre los ámbitos de PowerShell.

Un recordatorio rápido:

En nuestra situación con las clases, solo es necesario tener en cuenta estos tres ámbitos. No se recomienda utilizar estas sintaxis en un script, a menos que sepa exactamente lo que está haciendo. Si necesita manipular un objeto dentro de una propiedad o método, lo más adecuado es utilizar parámetros en métodos o constructores.

PS > $Var = 0  
PS > Class Scoping {  
      $Prop = $Var  
      Static $StaticProp = $Var  
   }  
    
PS > $Sco = [Scoping]::New()  
PS > [Scoping]::StaticProp  
0  
PS > $Sco.Prop  
0 

Herencia

La herencia se utiliza para declarar una clase base que luego utilizan las clases derivadas. Esta mecanismo permite que la clase derivada herede todos los miembros de la clase base, especialmente los métodos.

Sintaxis

PS > Class <BaseClass>{  
    <Property1>  
    <Property2>  
    <Methode1>  
    <BaseClass>($Parameter1,$Parameter2){}  
}  
PS > Class <DeriClass> : <BaseClass> {  
    <otherProperty3>  
<DeriClass>($Parameter1,$Parameter2):base($Parameter1,$Parameter2){}  
} 

La declaración de la clase derivada incluye su nombre y el de la clase base, separados por el carácter :. No es posible declarar varias clases base para una clase derivada:

PS > Class <DeriClass> : <BaseClass>,<BaseClase2> 

A continuación, hay que declarar el constructor de la clase derivada. Para ello, entre la declaración de parámetros e instrucciones, es necesario añadir la palabra clave base, también precedida del carácter :. Le siguen los parámetros del constructor de la clase base.

Creación Enum

PowerShell V5 implementa la noción de enumeración, palabra clave enum. Antes de PowerShell 5, era necesario utilizar el cmdlet Add-Type junto con código en C# para declarar enumeraciones.

Las enumeraciones pueden utilizarse para restringir los valores que puede contener una variable. De forma similar a lo que permite el atributo de validación ValidateSet() en un parámetro.

PS > enum <NombreDeLaEnumeración> {  
    <NombreValor1>  
    <NombreValor2>  
    <NombreValor3>      
    ...  
} 

PS > enum CódigoLibro {  
    Recurso Informático  
    ExpertIT  
    Epsilon  
}  
PS > [CódigoLibro]$Estelibro = 'ExpertIT' 

PS > [CódigoLibro]$Estelibro = 1  
PS > $Estelibro   
ExpertIT...

Integración en un módulo

Es probable que las clases tengan un destino más amplio que un simple script PowerShell. Por ello, resulta totalmente adecuado integrarlas en un módulo para facilitar su reutilización y distribución.

Los módulos constan de un manifiesto en formato PSD1 y un archivo de módulo en formato PSM1. En este caso, solo se necesita el archivo de manifiesto. El campo ScriptToProcess se utiliza para cargar la clase contenida en un archivo PS1.

Organización del módulo TestClass:

└─TestClass  
    ├─ Classes  
      └─ myclass.ps1  
    └─ TestClass.psd1 

El archivo myclass.ps1 contiene la clase [Computer] del ejemplo anterior. Para el archivo de manifiesto, rellenamos el campo ScriptToProcess de la siguiente manera:

ScriptsToProcess = @('Class/myclass.ps1') 

Por último, el módulo se coloca en un directorio donde se descubre e importa automáticamente mediante el comando Import-Module:

PS > Import-Module TestClass 

Por último, probamos la instanciación de la clase [Computer]:

PS > [Computer]::New('PC-Generic','Windows')  
  
Name      OS  
----      --  
PC-Generic Windows 

La clase puede ahora...

Palabra clave Using

La instrucción using ya se trató anteriormente, cuando se explicó cómo colocar clases en un módulo. También se utiliza para facilitar la llamada a clases presentes en los namespaces. Pero, ¿qué es un namespace?

Es una estructura jerárquica que organiza las clases de acuerdo con una utilidad/temática en particular.

Por ejemplo, la clase Directory designa una carpeta, y esta clase está contenida en el espacio de nombres system.IO. Este último también contiene la clase File, que designa archivos.

Cuando se llama a una clase del framework .NET en PowerShell, el namespace y el nombre de la clase aparecen entre corchetes.

Por ejemplo, crear un directorio utilizando la clase Directory:  
PS > [System.IO.Directory]::CreateDirectory('C:\Temps')  
  
Mode                 LastWriteTime         Length Name  
----                 -------------         ------ ----  
d----            5/17/2023  6:25 PM               Temps...

Uso de clases en la validación de parámetros

En el capítulo Funciones Avanzadas, vimos en detalle cómo los parámetros pueden ser validados de diferentes maneras. Ahora que hemos cubierto la noción de clases, podemos añadir a estos elementos mediante el uso de clases.

function Restart-ServiceRunning {  
   [CmdletBinding()]  
   Param (  
        [string[]]$Name  
   )  
   Restart-Service @PSBoundParameters  
}