about_Using

Artikel
06/21/2023

Kort beskrivning

Gör att du kan ange vilka namnområden som används i sessionen.

Lång beskrivning

Med instruktionen using kan du ange vilka namnområden som används i sessionen. Genom att lägga till namnrymder förenklas användningen av .NET-klasser och -medlemmar och du kan importera klasser från skriptmoduler och sammansättningar.

- using instruktionerna måste komma före andra instruktioner i ett skript eller en modul. Ingen okommenterad instruktion kan föregå den, inklusive parametrar.

-instruktionen using får inte innehålla några variabler.

Instruktionen using ska inte förväxlas med omfångsmodifieraren using: för variabler. Mer information finns i about_Remote_Variables.

Namnområdessyntax

Så här anger du .NET-namnområden som du vill matcha typer från:

using namespace <.NET-namespace>

Om du anger ett namnområde blir det enklare att referera till typer med deras korta namn.

Modulsyntax

Så här läser du in klasser från en PowerShell-modul:

using module <module-name>

Värdet för <module-name> kan vara ett modulnamn, en fullständig modulspecifikation eller en sökväg till en modulfil.

När <module-name> är en sökväg kan sökvägen vara fullständigt kvalificerad eller relativ. En relativ sökväg matchas i förhållande till skriptet som innehåller using-instruktionen.

När <module-name> är ett namn eller en modulspecifikation söker PowerShell i PSModulePath efter den angivna modulen.

En modulspecifikation är en hash-tabell som har följande nycklar.

ModuleName - Krävs Anger modulnamnet.
GUID - Valfri Anger GUID för modulen.
Det är också Obligatoriskt att ange en av de tre nycklarna nedan. Dessa nycklar kan inte användas tillsammans.
- ModuleVersion – Anger en lägsta godtagbar version av modulen.
- RequiredVersion – Anger en exakt version av modulen som krävs.
- MaximumVersion – Anger den högsta godkända versionen av modulen.

Instruktionen using module importerar klasser från rotmodulen (ModuleToProcess) i en skriptmodul eller binär modul. Den importerar inte konsekvent klasser som definierats i kapslade moduler eller klasser som definierats i skript som är punktbaserade i modulen. Klasser som du vill ska vara tillgängliga för användare utanför modulen ska definieras i rotmodulen.

Under utvecklingen av en skriptmodul är det vanligt att göra ändringar i koden och sedan läsa in den nya versionen av modulen med hjälp Import-Module av parametern Force . Detta fungerar endast för ändringar av funktioner i rotmodulen. Import-Module läser inte in några kapslade moduler igen. Det finns heller inget sätt att läsa in några uppdaterade klasser.

För att säkerställa att du kör den senaste versionen måste du ta bort modulen med cmdleten Remove-Module . Remove-Module tar bort rotmodulen, alla kapslade moduler och alla klasser som definierats i modulerna. Sedan kan du läsa in modulen och klasserna igen med hjälp av Import-Module och -instruktionen using module .

Sammansättningssyntax

Så här läser du in typer från en .NET-sammansättning i förväg:

using assembly <.NET-assembly-path>

När du läser in en sammansättning läses .NET-typer från den sammansättningen in i ett skript vid parsningstillfället. På så sätt kan du skapa nya PowerShell-klasser som använder typer från den förinstallerade sammansättningen.

Om du inte skapar nya PowerShell-klasser använder du cmdleten Add-Type i stället. Mer information finns i Add-Type (Lägg till typ).

Exempel

Exempel 1 – Lägga till namnrymder för typnamnsmatchning

Följande skript hämtar den kryptografiska hashen för strängen "Hello World".

Observera hur using namespace System.Text och using namespace System.IO förenklar referenser till [UnicodeEncoding] i System.Text och [Stream] till [MemoryStream] i 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()

Exempel 2 – Läsa in klasser från en skriptmodul

I det här exemplet har vi en PowerShell-skriptmodul med namnet CardGames som definierar följande klasser:

CardGames.Deck
CardGames.Card

Import-Module och -instruktionen #requires importerar endast modulfunktionerna, aliasen och variablerna enligt modulens definition. Klasser importeras inte. Kommandot using module importerar modulen och läser även in klassdefinitionerna.

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)

Exempel 3 – Läsa in klasser från en sammansättning

Det här exemplet läser in en sammansättning så att dess klasser kan användas för att skapa nya PowerShell-klasser. Följande skript skapar en ny PowerShell-klass som härleds från klassen 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

Dela via