om_Att använda

Kort beskrivning

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

Lång beskrivning

Med using-instruktionen 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.

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.

using-instruktionen är inte samma som using: omfångsmodifierare 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] och [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 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 matchar i förhållande till skriptet som har using-instruktionen.

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

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

• ModuleName - Obligatoriskt Anger modulnamnet.
• GUID - Valfri Anger GUID för modulen.
• Det är också Krävs för 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 #requires-instruktionen importerar endast modulfunktioner, alias och variabler enligt modulens definition. Klasser och uppräkningar importeras inte.

using module-instruktionen 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 av Import-Module med 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
• kort

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

[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>

using assembly-instruktionen liknar att använda cmdleten Add-Type. Cmdleten Add-Type lägger dock till typen vid den tidpunkt då Add-Type körs i stället för i början av körningen av skriptet. Mer information finns i add-type.

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