about_Using

Kurzbeschreibung

Ermöglicht Ihnen anzugeben, welche Namespaces in der Sitzung verwendet werden.

Lange Beschreibung

Mit der using 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 das Importieren von Klassen aus Skriptmodulen und Assemblys.

Die using-Anweisungen müssen vor anderen Anweisungen in einem Skript oder Modul erfolgen. Es kann keine nicht kommentierte Anweisung vorangehen, einschließlich Parametern.

Die using-Anweisung darf keine Variablen enthalten.

Die using Anweisung sollte nicht mit dem scope-Modifizierer 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>

Das Angeben eines Namespace erleichtert das Verweisen auf Typen anhand ihrer Kurznamen.

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 vollqualifizierte oder relativ sein. Ein relativer Pfad wird relativ zum Skript aufgelöst, das die using-Anweisung enthält.

Wenn <module-name> eine Namens- oder Modulspezifikation ist, durchsucht PowerShell die PSModulePath- nach dem angegebenen Modul.

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

• ModuleName - Erforderlicher Gibt den Modulnamen an.
• GUID - Optionaler 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 akzeptable 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 eines Binärmoduls. Klassen, die in geschachtelten Modulen definiert sind, oder Klassen, die in Skripts definiert sind, die mit Punkten versehen sind, werden nicht konsistent 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 verschachtelten 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 neu 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. Auf diese Weise können Sie neue PowerShell-Klassen erstellen, die Typen aus der vorab geladenen 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 Typnamensauflösung

Das folgende Skript ruft den kryptografischen Hash für die Zeichenfolge "Hello World" ab.

Beachten Sie, wie die using namespace System.Text und using namespace System.IO vereinfachen die Verweise auf [UnicodeEncoding] in System.Text und [Stream] und auf [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()

Beispiel 2: Laden von Klassen aus einem Skriptmodul

In diesem Beispiel haben wir ein PowerShell-Skriptmodul mit dem Namen 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 befehl using module 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 Baugruppe

In diesem Beispiel wird eine Assembly geladen, sodass ihre Klassen zum Erstellen neuer PowerShell-Klassen verwendet werden können. Mit dem folgenden Skript wird eine neue PowerShell-Klasse erstellt, die von der DirectoryContext-Klasse abgeleitet ist.

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