about_Using

Descrizione breve

Consente di specificare gli spazi dei nomi da usare nella sessione.

Descrizione lunga

L'istruzione using consente di specificare gli spazi dei nomi da usare nella sessione. L'aggiunta di spazi dei nomi semplifica l'utilizzo di classi e membri .NET e consente di importare classi da moduli e assembly di script.

Le using istruzioni devono venire prima di qualsiasi altra istruzione in uno script o un modulo. Nessuna istruzione non commentata può precederla, inclusi i parametri.

L'istruzione using non deve contenere variabili.

L'istruzione using non corrisponde al modificatore di ambito per le using: variabili. Per altre informazioni, vedere about_Remote_Variables.

Sintassi dello spazio dei nomi

Per risolvere i tipi da uno spazio dei nomi .NET:

using namespace <.NET-namespace>

Se si specifica uno spazio dei nomi, è più semplice fare riferimento ai tipi in base ai nomi brevi.

Esempio - Aggiungere spazi dei nomi per la risoluzione typename

Lo script seguente ottiene l'hash crittografico per la stringa "Hello World".

Si noti come e using namespace System.Textusing namespace System.IO semplificano i riferimenti a [UnicodeEncoding] in System.Text e [MemoryStream][Stream] in 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)
$getFileHashSplat = @{
    InputStream = $memoryStream
    Algorithm   = $algorithm
}
$hashFromStream = Get-FileHash @getFileHashSplat
$hashFromStream.Hash.ToString()

Sintassi del modulo

Per caricare classi ed enumerazioni da un modulo di PowerShell:

using module <module-name>

Il valore di può essere un nome di <module-name> modulo, una specifica completa del modulo o un percorso di un file di modulo.

Quando <module-name> è un percorso, il percorso può essere completo o relativo. Un percorso relativo viene risolto rispetto allo script con l'istruzione using .

Quando <module-name> è un nome o una specifica del modulo, PowerShell cerca il modulo specificato in PSModulePath .

Una specifica del modulo è una tabella hash con le chiavi seguenti.

• ModuleName - Obbligatorio Specifica il nome del modulo.
• GUID - Facoltativo Specifica il GUID del modulo.
• È anche obbligatorio specificare almeno una delle tre chiavi seguenti.
  • ModuleVersion - Specifica una versione minima accettabile del modulo.
  • MaximumVersion - Specifica la versione massima accettabile del modulo.
  • RequiredVersion - Specifica una versione esatta e obbligatoria del modulo. Non è possibile usare questa opzione con le altre chiavi di versione.

Import-Module e l'istruzione #requires importa solo le funzioni, gli alias e le variabili del modulo, come definito dal modulo. Le classi e le enumerazioni non vengono importate.

L'istruzione using module importa classi ed enumerazioni dal modulo radice (ModuleToProcess) di un modulo script o di un modulo binario. Non importa in modo coerente classi o enumerazioni definite nei moduli annidati o negli script con origine punto nel modulo radice. Definire classi ed enumerazioni che si desidera essere disponibili per gli utenti esterni al modulo direttamente nel modulo radice.

Durante lo sviluppo di un modulo di script, è comune apportare modifiche al codice e quindi caricare la nuova versione del modulo usando Import-Module con il parametro Force . Questa operazione funziona solo per le modifiche apportate alle funzioni nel modulo radice. Import-Module non ricarica i moduli annidati. Inoltre, non è possibile caricare classi o enumerazioni aggiornate.

Per assicurarsi di eseguire la versione più recente, è necessario avviare una nuova sessione. Le classi e le enumerazioni definite in PowerShell e importate con un'istruzione using non possono essere scaricate.

Esempio- Caricare classi da un modulo script

In questo esempio, un modulo script di PowerShell denominato CardGames definisce le classi seguenti:

• Ponte
• Scheda

Import-Module e l'istruzione #requires importa solo le funzioni, gli alias e le variabili del modulo, come definito dal modulo. Le classi non vengono importate. Il using module comando importa il modulo e carica anche le definizioni di classe.

using module CardGames

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

Sintassi dell'assembly

La sintassi seguente carica i tipi .NET da un assembly in uno script all'inizio dell'esecuzione. È necessario utilizzare un percorso completo del file di assembly.

using assembly <.NET-assembly-path>

L'istruzione using assembly è simile all'uso del Add-Type cmdlet . Tuttavia, il Add-Type cmdlet aggiunge il tipo al momento Add-Type dell'esecuzione, anziché all'inizio dell'esecuzione dello script. Per altre informazioni, vedere Add-Type.

Esempio- Caricare i tipi da un assembly

In questo esempio viene caricato un assembly in modo che le relative classi possano essere usate durante l'elaborazione dei dati. Lo script seguente converte i dati in un formato YAML.

using assembly './YamlDotNet.dll'
using namespace YamlDotNet

$yamlSerializer = [Serialization.Serializer]::new()

$info = [ordered]@{
  Inventory = @(
    @{ Name = 'Apples' ; Count = 1234 }
    @{ Name = 'Bagels' ; Count = 5678 }
  )
  CheckedAt = [datetime]'2023-01-01T01:01:01'
}

$yamlSerializer.Serialize($info)

Inventory:
- Name: Apples
  Count: 1234
- Name: Bagels
  Count: 5678
CheckedAt: 2023-01-01T01:01:01.0000000