Acerca del 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 using instrucciones deben ir antes de cualquier otra instrucción en un script.

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

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

using namespace <.NET-namespace>

Para cargar clases desde un módulo de PowerShell:

using module <module-name>

Para precargar tipos de un ensamblado de .NET:

using assembly <.NET-assembly-path>

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

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