à propos de l'utilisation

Brève description

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 et des membres .NET et vous permet d’importer des classes à partir de modules de script et d’assemblys.

Les instructions using doivent être fournies avant les autres instructions d’un script ou d’un module. Aucune instruction noncommenté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 de portée pour les using: variables. Pour plus d'informations, voir about_Remote_Variables.

Syntaxe de l’espace de noms

Pour spécifier les 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 <module-name> peut être un nom de module, une spécification complète du module ou un chemin d’accès à un fichier de module.

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

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

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

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

L’instruction using module importe des classes à partir du module racine (ModuleToProcess) d’un module de script ou d’un module binaire. Il n’importe pas systématiquement les classes définies dans les modules imbriqués ou les classes définies dans les scripts qui sont sourcé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.

Lors du 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. De plus, il n’y a 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 Remove-Module de commande. Remove-Module Supprime le module racine, tous les modules imbriqués et toutes les classes définies dans les modules. Ensuite, vous pouvez recharger le module et les classes à l’aide de l’instruction Import-Module et .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 des classes PowerShell qui utilisent les types 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 pour la chaîne « Hello World ».

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

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 importent uniquement les fonctions de module, les alias et les variables, comme défini par le module. Les classes ne sont pas importées. La commande using module 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 - Classes de charge à partir d’un assemblage

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
  • Last updated on