Share via

about_Using

  • Article

Description courte

Vous permet d’indiquer quels espaces de noms sont utilisés dans la session.

Description longue

L’instruction using vous permet de spécifier les espaces de noms utilisés dans la session. L’ajout d’espaces de noms simplifie l’utilisation des classes .NET et des membres et vous permet d’importer des classes à partir de modules de script et d’assemblys.

Les using instructions doivent passer avant toutes les autres instructions d’un script ou d’un module. Aucune instruction non commentée ne peut la précéder, y compris les paramètres.

L’instruction using ne doit contenir aucune variable.

L’instruction using ne doit pas être confondue avec le modificateur d’étendue using: pour les variables. Pour plus d’informations, consultez about_Remote_Variables.

Syntaxe de l’espace de noms

Pour spécifier des espaces de noms .NET à partir desquels résoudre les types :

using namespace <.NET-namespace>

La spécification d’un espace de noms facilite la référence des types par leurs noms courts.

Syntaxe du module

Pour charger des classes à partir d’un module PowerShell :

using module <module-name>

La valeur de peut être un nom de <module-name> module, une spécification de module complète ou un chemin d’accès à un fichier de module.

Quand <module-name> est un chemin d’accès, le chemin d’accès peut être complet ou relatif. Un chemin d’accès relatif est résolu par rapport au script qui contient l’instruction using.

Quand <module-name> est une spécification de nom ou de module, PowerShell recherche le module spécifié dans PSModulePath .

Une spécification de module est une table de hachage qui contient les clés suivantes.

  • ModuleName - Obligatoire Spécifie le nom du module.
  • GUID - Optionnel Spécifie le GUID du module.
  • Il est également nécessaire de spécifier l’une des trois clés ci-dessous. Ces clés ne peuvent pas être utilisées ensemble.
    • ModuleVersion - Spécifie une version minimale acceptable du module.
    • RequiredVersion - Spécifie une version exacte et obligatoire du module.
    • MaximumVersion - Spécifie la version maximale acceptable du module.

L’instruction using module importe des classes du module racine (ModuleToProcess) d’un module de script ou d’un module binaire. Il n’importe pas de manière cohérente les classes définies dans les modules imbriqués ou les classes définies dans les scripts qui sont générés par des points dans le module. Les classes que vous souhaitez mettre à la disposition des utilisateurs en dehors du module doivent être définies dans le module racine.

Pendant le développement d’un module de script, il est courant d’apporter des modifications au code, puis de charger la nouvelle version du module à l’aide Import-Module du paramètre Force . Cela fonctionne uniquement pour les modifications apportées aux fonctions dans le module racine. Import-Module ne recharge pas les modules imbriqués. En outre, il n’existe aucun moyen de charger des classes mises à jour.

Pour vous assurer que vous exécutez la dernière version, vous devez décharger le module à l’aide de l’applet de Remove-Module commande. Remove-Module supprime le module racine, tous les modules imbriqués et toutes les classes définies dans les modules. Vous pouvez ensuite recharger le module et les classes à l’aide Import-Module de et de l’instruction using module .

Syntaxe d’assembly

Pour précharger des types à partir d’un assembly .NET :

using assembly <.NET-assembly-path>

Le chargement d’un assembly précharge les types .NET de cet assembly dans un script au moment de l’analyse. Cela vous permet de créer de nouvelles classes PowerShell qui utilisent des types à partir de l’assembly préchargé.

Si vous ne créez pas de classes PowerShell, utilisez l’applet de commande à la Add-Type place. Pour plus d’informations, consultez Add-Type.

Exemples

Exemple 1 - Ajouter des espaces de noms pour la résolution de typename

Le script suivant obtient le hachage de chiffrement de la chaîne « Hello World ».

Notez comment using namespace System.Text et using namespace System.IO simplifiez les références à [UnicodeEncoding] dans System.Text et [Stream] à [MemoryStream] dans 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()

Exemple 2 - Charger des classes à partir d’un module de script

Dans cet exemple, nous avons un module de script PowerShell nommé CardGames qui définit les classes suivantes :

  • CardGames.Deck
  • CardGames.Card

Import-Module et l’instruction #requires importe uniquement les fonctions de module, les alias et les variables, telles que définies par le module. Les classes ne sont pas importées. La using module commande importe le module et charge également les définitions de 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)

Exemple 3 - Charger des classes à partir d’un assembly

Cet exemple charge un assembly afin que ses classes puissent être utilisées pour créer de nouvelles classes PowerShell. Le script suivant crée une classe PowerShell dérivée de la 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