Compartir a través de

acerca_De_Uso

Descripción breve

Permite indicar qué espacios de nombres se utilizan en la sesión.

Descripción larga

La using instrucción permite especificar qué espacios de nombres se utilizan en la sesión. La adición de espacios de nombres simplifica el uso de las clases y los miembros de .NET, y permite importar clases de módulos y ensamblados de script.

Las instrucciones using deben aparecer antes de cualquier otra instrucción de un script o módulo. Ninguna instrucción no confirmada puede precederla, incluidos los parámetros.

La instrucción using no debe contener ninguna variable.

La using instrucción no debe confundirse con el modificador de using: ámbito de las variables. Para obtener más información, vea about_Remote_Variables.

Sintaxis de espacio de nombres

Para especificar los espacios de nombres de .NET desde los que resolver tipos:

using namespace <.NET-namespace>

Especificar un espacio de nombres facilita la referencia de tipos por sus nombres cortos.

Sintaxis del módulo

Para cargar clases desde un módulo de PowerShell:

using module <module-name>

El valor de <module-name> puede ser un nombre de módulo, una especificación de módulo completa o una ruta de acceso a un archivo de módulo.

Cuando <module-name> es una ruta de acceso, la ruta de acceso puede ser completa o relativa. Se resuelve una ruta de acceso relativa con respecto al script que contiene la instrucción using.

Cuando <module-name> es un nombre o especificación de módulo, PowerShell busca en el psModulePath de para el módulo especificado.

Una especificación de módulo es una tabla hash que tiene las siguientes claves.

  • ModuleName - Required Especifica el nombre del módulo.
  • GUID - opcional Especifica el GUID del módulo.
  • También es necesario especificar una de las tres teclas siguientes. Estas teclas no se pueden usar juntas.
    • ModuleVersion: especifica una versión mínima aceptable del módulo.
    • RequiredVersion: especifica una versión exacta y necesaria del módulo.
    • MaximumVersion: especifica la versión máxima aceptable del módulo.

La using module sentencia importa clases desde el módulo raíz (ModuleToProcess) de un módulo de script o módulo binario. No importa de forma coherente las clases definidas en módulos anidados o las clases definidas en scripts que se originan en puntos en el módulo. Las clases que desea que estén disponibles para usuarios fuera del módulo deben definirse en el módulo raíz.

Durante el desarrollo de un módulo de script, es común realizar cambios en el código y luego cargar la nueva versión del módulo usando Import-Module con el parámetro Force . Esto funciona solo para los cambios en las funciones del módulo raíz. Import-Module No vuelve a cargar ningún módulo anidado. Además, no hay forma de cargar ninguna clase actualizada.

Para asegurarse de que está ejecutando la versión más reciente, debe descargar el módulo mediante el Remove-Module cmdlet. Remove-Module Quita el módulo raíz, todos los módulos anidados y las clases definidas en los módulos. A continuación, puede volver a cargar el módulo y las clases usando Import-Module y la using module instrucción.

Sintaxis de ensamblado

Para precargar tipos de un ensamblado de .NET:

using assembly <.NET-assembly-path>

Al cargar un ensamblado, se cargan previamente los tipos de .NET de ese ensamblado en un script en el momento del análisis. Esto le permite crear nuevas clases de PowerShell que usan tipos del ensamblado precargado.

Si no va a crear nuevas clases de PowerShell, use el Add-Type cmdlet en su lugar. Para obtener más información, vea de tipo de complemento .

Ejemplos

Ejemplo 1: Agregar espacios de nombres para la resolución de nombres de tipo

El siguiente script obtiene el hash criptográfico de la cadena "Hola mundo".

Observe cómo el using namespace System.Text y using namespace System.IO simplifica las referencias a [UnicodeEncoding] in System.Text y [Stream] y to in [MemoryStream]System.IO.

using namespace System.Text
using namespace System.IO

[string]$string = "Hello World"
## Valid values are "SHA1", "SHA256", "SHA384", "SHA512", "MD5"
[string]$algorithm = "SHA256"

[byte[]]$stringbytes = [UnicodeEncoding]::Unicode.GetBytes($string)

[Stream]$memorystream = [MemoryStream]::new($stringbytes)
$hashfromstream = Get-FileHash -InputStream $memorystream `
  -Algorithm $algorithm
$hashfromstream.Hash.ToString()

Ejemplo 2 - Cargar clases desde un módulo de script

En este ejemplo, tenemos un módulo de script de PowerShell denominado CardGames que define las siguientes clases:

  • CardGames.Deck
  • CardGames.Card

Import-Module y la instrucción #requires solo importan las funciones, alias y variables del módulo, tal como se define en el módulo. Las clases no se importan. El comando using module importa el módulo y también carga las definiciones de clase.

using module CardGames
using namespace CardGames

[Deck]$deck = [Deck]::new()
$deck.Shuffle()
[Card[]]$hand1 = $deck.Deal(5)
[Card[]]$hand2 = $deck.Deal(5)
[Card[]]$hand3 = $deck.Deal(5)

Ejemplo 3: Cargar clases de un ensamblado

En este ejemplo se carga un ensamblado para que sus clases se puedan usar para crear nuevas clases de PowerShell. El siguiente script crea una nueva clase de PowerShell que se deriva de la clase DirectoryContext .

using assembly 'C:\Program Files\PowerShell\7\System.DirectoryServices.dll'
using namespace System.DirectoryServices.ActiveDirectory

class myDirectoryClass : System.DirectoryServices.ActiveDirectory.DirectoryContext
{

  [DirectoryContext]$domain

  myDirectoryClass([DirectoryContextType]$ctx) : base($ctx)
  {
    $this.domain = [DirectoryContext]::new([DirectoryContextType]$ctx)
  }

}

$myDomain = [myDirectoryClass]::new([DirectoryContextType]::Domain)
$myDomain

domain                                                    Name UserName ContextType
------                                                    ---- -------- -----------
System.DirectoryServices.ActiveDirectory.DirectoryContext                    Domain
  • Last updated on