Share via

about_Using

  • Artikel

Kurze Beschreibung

Hiermit können Sie angeben, welche Namespaces in der Sitzung verwendet werden.

Lange Beschreibung

Mit using der -Anweisung können Sie angeben, welche Namespaces in der Sitzung verwendet werden. Das Hinzufügen von Namespaces vereinfacht die Verwendung von .NET-Klassen und -Membern und ermöglicht es Ihnen, Klassen aus Skriptmodulen und Assemblys zu importieren.

Die using Anweisungen müssen vor allen anderen Anweisungen in einem Skript oder Modul vorliegen. Es kann keine unkommentierte Anweisung vorangehen, einschließlich Parametern.

Die using -Anweisung darf keine Variablen enthalten.

Die using -Anweisung sollte nicht mit dem Bereichsmodifizierer using: für Variablen verwechselt werden. Weitere Informationen finden Sie unter about_Remote_Variables.

Namespacesyntax

So geben Sie .NET-Namespaces an, aus denen Typen aufgelöst werden sollen:

using namespace <.NET-namespace>

Wenn Sie einen Namespace angeben, können Sie einfacher anhand ihrer Kurznamen auf Typen verweisen.

Modulsyntax

So laden Sie Klassen aus einem PowerShell-Modul:

using module <module-name>

Der Wert von <module-name> kann ein Modulname, eine vollständige Modulspezifikation oder ein Pfad zu einer Moduldatei sein.

Wenn <module-name> ein Pfad ist, kann der Pfad voll qualifiziert oder relativ sein. Ein relativer Pfad wird relativ zum Skript aufgelöst, das die using-Anweisung enthält.

Wenn <module-name> ein Name oder eine Modulspezifikation ist, durchsucht PowerShell den PSModulePath nach dem angegebenen Modul.

Eine Modulspezifikation ist eine Hashtabelle mit den folgenden Schlüsseln.

  • ModuleName - Erforderlich Gibt den Modulnamen an.
  • GUID - Optional Gibt die GUID des Moduls an.
  • Es ist auch erforderlich , einen der drei folgenden Schlüssel anzugeben. Diese Schlüssel können nicht zusammen verwendet werden.
    • ModuleVersion – Gibt eine zulässige Mindestversion des Moduls an.
    • RequiredVersion : Gibt eine genaue, erforderliche Version des Moduls an.
    • MaximumVersion – Gibt die maximal zulässige Version des Moduls an.

Die using module -Anweisung importiert Klassen aus dem Stammmodul (ModuleToProcess) eines Skriptmoduls oder binären Moduls. Klassen, die in geschachtelten Modulen definiert sind, oder klassen, die in Skripts definiert sind, die aus Punktquellen stammen, werden nicht konsistent in das Modul importiert. Klassen, die für Benutzer außerhalb des Moduls verfügbar sein sollen, sollten im Stammmodul definiert werden.

Während der Entwicklung eines Skriptmoduls ist es üblich, Änderungen am Code vorzunehmen und dann die neue Version des Moduls mit Import-Module dem Force-Parameter zu laden. Dies funktioniert nur für Änderungen an Funktionen im Stammmodul. Import-Module lädt keine geschachtelten Module neu. Außerdem gibt es keine Möglichkeit, aktualisierte Klassen zu laden.

Um sicherzustellen, dass Sie die neueste Version ausführen, müssen Sie das Modul mit dem Remove-Module Cmdlet entladen. Remove-Module entfernt das Stammmodul, alle geschachtelten Module und alle in den Modulen definierten Klassen. Anschließend können Sie das Modul und die Klassen mit Import-Module und der using module -Anweisung erneut laden.

Assemblysyntax

So laden Sie Typen aus einer .NET-Assembly vorab:

using assembly <.NET-assembly-path>

Beim Laden einer Assembly werden .NET-Typen aus dieser Assembly zur Analysezeit in ein Skript vorab geladen. Dadurch können Sie neue PowerShell-Klassen erstellen, die Typen aus der vorinstallierten Assembly verwenden.

Wenn Sie keine neuen PowerShell-Klassen erstellen, verwenden Sie stattdessen das Add-Type Cmdlet. Weitere Informationen finden Sie unter Add-Type.

Beispiele

Beispiel 1: Hinzufügen von Namespaces für die Typnamenauflösung

Das folgende Skript ruft den kryptografischen Hash für die Zeichenfolge "Hallo Welt" ab.

Beachten Sie, wie und using namespace System.Textusing namespace System.IO die Verweise auf [UnicodeEncoding] in System.Text und [Stream] auf [MemoryStream] in System.IOvereinfachen.

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()

Beispiel 2: Laden von Klassen aus einem Skriptmodul

In diesem Beispiel verfügen wir über ein PowerShell-Skriptmodul namens CardGames , das die folgenden Klassen definiert:

  • CardGames.Deck
  • CardGames.Card

Import-Module und die #requires -Anweisung importieren nur die Modulfunktionen, Aliase und Variablen, wie vom Modul definiert. Klassen werden nicht importiert. Der using module Befehl importiert das Modul und lädt auch die Klassendefinitionen.

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)

Beispiel 3: Laden von Klassen aus einer Assembly

In diesem Beispiel wird eine Assembly geladen, damit ihre Klassen zum Erstellen neuer PowerShell-Klassen verwendet werden können. Das folgende Skript erstellt eine neue PowerShell-Klasse, die von der DirectoryContext-Klasse abgeleitet wird.

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