om_Att använda

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 namnrymder som används i sessionen. Genom att lägga till namnrymder förenklas användningen av .

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-namnrymder som typer ska matchas från:

using namespace <.NET-namespace>

Om du anger ett namnområde blir det enklare att referera till typer efter 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 instruktionen using.

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

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

• ModuleName - Obligatoriskt Anger modulnamnet.
• GUID - Valfri Anger GUID för modulen.
• Det är också obligatoriskt att ange en av de tre tangenterna nedan. Dessa nycklar kan inte användas tillsammans.
  • ModuleVersion – Anger en lägsta godtagbar version av modulen.
  • RequiredVersion – Anger en exakt, nödvändig version av modulen.
  • MaximumVersion – Anger den maximala 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 punktkällor till 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 force-parametern . Detta fungerar endast för ändringar av funktioner i rotmodulen. Import-Module laddar inte om några kapslade moduler. Det finns inte heller något sätt att läsa in uppdaterade klasser.

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

Sammansättningssyntax

Så här läser du in typer i förväg från en .

using assembly <.NET-assembly-path>

NET-typer från sammansättningen läses in i förväg till ett skript vid parsningstidpunkten. 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.

Exempel

Exempel 1 – Lägg till namnrymder för typename-matchning

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

Observera hur using namespace System.Text och using namespace System.IO förenkla referenserna till [UnicodeEncoding] in System.Text och [Stream] och till [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()

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 #requires-instruktionen importerar endast modulfunktioner, alias och variabler 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 – Lastklasser 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 DirectoryContext klassen.

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