informazioni sull'uso

Breve descrizione

Consente di indicare quali namespace sono usati nella sessione.

Descrizione lunga

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

Le istruzioni using 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 deve essere confusa con il modificatore di ambito per le using: variabili. Per altre informazioni, vedere about_Remote_Variables.

Sintassi dello spazio dei nomi

Per specificare gli spazi dei nomi .NET da cui risolvere i tipi:

using namespace <.NET-namespace>

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

Sintassi del modulo

Per caricare classi da un modulo di PowerShell:

using module <module-name>

Il valore di <module-name> può essere un nome di 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 che contiene l'istruzione using.

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

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.
• È inoltre necessario specificare una delle tre chiavi seguenti. Queste chiavi non possono essere utilizzate insieme.
  • ModuleVersion: specifica una versione minima accettabile del modulo.
  • RequiredVersion: specifica una versione esatta e obbligatoria del modulo.
  • MaximumVersion: specifica la versione massima accettabile del modulo.

L'istruzione using module importa le classi dal modulo radice (ModuleToProcess) di un modulo script o di un modulo binario. Non importa in modo coerente le classi definite nei moduli nidificati o le classi definite negli script originati dal punto nel modulo. Le classi che si desidera rendere disponibili per gli utenti esterni al modulo devono essere definite nel modulo radice.

Durante lo sviluppo di un modulo di script, è comune apportare modifiche al codice e caricare la nuova versione del modulo utilizzando Import-Module il parametro Force . Questa operazione funziona solo per le modifiche apportate alle funzioni nel modulo radice. Import-Module Non ricarica alcun modulo nidificato. Inoltre, non è possibile caricare le classi aggiornate.

Per assicurarsi di eseguire la versione più recente, è necessario scaricare il modulo utilizzando il Remove-Module cmdlet. Remove-Module Rimuove il modulo radice, tutti i moduli nidificati e tutte le classi definite nei moduli. Quindi è possibile ricaricare il modulo e le classi utilizzando Import-Module l'istruzione using module and.

Sintassi dell'assembly

Per precaricare i tipi da un assembly .NET:

using assembly <.NET-assembly-path>

Il caricamento di un assembly precarica i tipi .NET da tale assembly in uno script in fase di analisi. In questo modo è possibile creare nuove classi di PowerShell che usano i tipi dell'assembly precaricato.

Se non si creano nuove classi di PowerShell, usare invece il Add-Type cmdlet. Per altre informazioni, vedere add-type .

Esempi

Esempio 1 - Aggiungere spazi dei nomi per la risoluzione del nome del tipo

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

Si noti come e using namespace System.Textusing namespace System.IO semplificare i riferimenti a [UnicodeEncoding] in System.Text e [Stream] e a [MemoryStream] 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)
$hashfromstream = Get-FileHash -InputStream $memorystream `
  -Algorithm $algorithm
$hashfromstream.Hash.ToString()

Esempio 2 - Caricare classi da un modulo script

In questo esempio è presente un modulo di script di PowerShell denominato CardGames che definisce le classi seguenti:

• Giochi di carte.Mazzo
• CardGames.Card

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

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)

Esempio 3 - Caricare classi da un assembly

In questo esempio viene caricato un assembly in modo che le relative classi possano essere utilizzate per creare nuove classi di PowerShell. Lo script seguente crea una nuova classe di PowerShell derivata dalla classe 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