about_Using

Kort beskrivning

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

Lång beskrivning

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

Instruktionerna using 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.

- using instruktionen är inte samma som using: omfångsmodifieraren för variabler. Mer information finns i about_Remote_Variables.

Namnområdessyntax

Så här löser du typer från ett .NET-namnområde:

using namespace <.NET-namespace>

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

Exempel – Lägga till namnområden för typnamnsmatchning

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örenklar referenser till [UnicodeEncoding] i System.Text och [Stream][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)
$getFileHashSplat = @{
    InputStream = $memoryStream
    Algorithm   = $algorithm
}
$hashFromStream = Get-FileHash @getFileHashSplat
$hashFromStream.Hash.ToString()

Modulsyntax

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

using module <module-name>

Värdet <module-name> för 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 matchar i förhållande till skriptet som har -instruktionen using .

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

En modulspecifikation är en hashtable som har följande nycklar.

• ModuleName - Obligatoriskt Anger modulnamnet.
• GUID - Valfritt Anger GUID för modulen.
• Det är också Obligatoriskt att ange minst en av de tre nycklarna nedan.
  • ModuleVersion – Anger en lägsta godtagbar version av modulen.
  • MaximumVersion – Anger den maximala godkända versionen av modulen.
  • RequiredVersion – Anger en exakt, nödvändig version av modulen. Detta kan inte användas med de andra versionsnycklarna.

Import-Module och -instruktionen #requires importerar endast modulfunktioner, alias och variabler enligt modulens definition. Klasser och uppräkningar importeras inte.

Instruktionen using module importerar klasser och uppräkningar från rotmodulen (ModuleToProcess) i en skriptmodul eller binär modul. Den importerar inte konsekvent klasser eller uppräkningar som definierats i kapslade moduler eller i skript som är punktbaserade i rotmodulen. Definiera klasser och uppräkningar som du vill ska vara tillgängliga för användare utanför modulen direkt 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 uppdaterade klasser eller uppräkningar.

För att säkerställa att du kör den senaste versionen måste du starta en ny session. Klasser och uppräkningar som definierats i PowerShell och importerats med en using instruktion kan inte tas bort.

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

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

• Däck
• Card

Import-Module och -instruktionen #requires 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

[Deck]$deck = [Deck]::new()
$deck.Shuffle()
[Card[]]$hand1 = $deck.Deal(5)
[Card[]]$hand2 = $deck.Deal(5)
[Card[]]$hand3 = $deck.Deal(5)

Sammansättningssyntax

Följande syntax läser in .NET-typer från en sammansättning till ett skript i början av körningen. Du måste använda en fullständigt kvalificerad sökväg till sammansättningsfilen.

using assembly <.NET-assembly-path>

-instruktionen using assembly liknar cmdleten Add-Type . Cmdleten Add-Type lägger dock till typen vid den tidpunkt som Add-Type körs i stället för i början av körningen av skriptet. Mer information finns i Lägg till typ.

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

Det här exemplet läser in en sammansättning så att dess klasser kan användas när data bearbetas. Följande skript konverterar data till ett YAML-format.

using assembly './YamlDotNet.dll'
using namespace YamlDotNet

$yamlSerializer = [Serialization.Serializer]::new()

$info = [ordered]@{
  Inventory = @(
    @{ Name = 'Apples' ; Count = 1234 }
    @{ Name = 'Bagels' ; Count = 5678 }
  )
  CheckedAt = [datetime]'2023-01-01T01:01:01'
}

$yamlSerializer.Serialize($info)

Inventory:
- Name: Apples
  Count: 1234
- Name: Bagels
  Count: 5678
CheckedAt: 2023-01-01T01:01:01.0000000