Odpowiednik słowa kluczowego „using” w języku C # w programie PowerShell?

Kiedy używam innego obiektu w .net-Framework w C #, mogę zaoszczędzić dużo pisania, używając dyrektywy using.

using FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It;

...


  var blurb = new Thingamabob();

...

Czy zatem w Powershell można zrobić coś podobnego? Uzyskuję dostęp do wielu obiektów .net i nie jestem zadowolony, że muszę pisać

 $blurb = new-object FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It.Thingamabob;

cały czas.

PowerShell 5.0 (zawarty w WMF5 lub Windows 10 i nowszych) dodaje using namespacekonstrukcję do języka. Możesz go użyć w swoim skrypcie w następujący sposób:

#Require -Version 5.0
using namespace FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It
$blurb = [Thingamabob]::new()

( #RequireInstrukcja w pierwszym wierszu nie jest konieczna using namespace, ale uniemożliwi uruchomienie skryptu w wersji PS 4.0 i niższych, gdzie using namespacewystępuje błąd składni).

Tak naprawdę na poziomie przestrzeni nazw nie ma nic takiego. Często przypisuję często używane typy do zmiennych, a następnie tworzę je:

$thingtype = [FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It.Thingamabob];
$blurb = New-Object $thingtype.FullName

Prawdopodobnie nie warto, jeśli ten typ nie będzie używany wielokrotnie, ale uważam, że to najlepsze, co możesz zrobić.

Sprawdź ten post na blogu sprzed kilku lat: http://blogs.msdn.com/richardb/archive/2007/02/21/add-types-ps1-poor-man-s-using-for-powershell.aspx

Oto add-types.ps1fragment tego artykułu:

param(
    [string] $assemblyName = $(throw 'assemblyName is required'),
    [object] $object
)

process {
    if ($_) {
        $object = $_
    }

    if (! $object) {
        throw 'must pass an -object parameter or pipe one in'
    }

    # load the required dll
    $assembly = [System.Reflection.Assembly]::LoadWithPartialName($assemblyName)

    # add each type as a member property
    $assembly.GetTypes() | 
    where {$_.ispublic -and !$_.IsSubclassOf( [Exception] ) -and $_.name -notmatch "event"} | 
    foreach { 
        # avoid error messages in case it already exists
        if (! ($object | get-member $_.name)) {
            add-member noteproperty $_.name $_ -inputobject $object
        }
    }
}

Aby z niego skorzystać:

RICBERG470> $tfs | add-types "Microsoft.TeamFoundation.VersionControl.Client"
RICBERG470> $itemSpec = new-object $tfs.itemspec("$/foo", $tfs.RecursionType::none)

Zasadniczo przeszukuję zestaw pod kątem nietrywialnych typów, a następnie piszę „konstruktora”, który używa Add-Member i dodaje je (w uporządkowany sposób) do obiektów, na których mi zależy.

Zobacz także następujący post: http://richardberg.net/blog/?p=38

to tylko żart, żart ...

$fullnames = New-Object ( [System.Collections.Generic.List``1].MakeGenericType( [String]) );

function using ( $name ) { 
foreach ( $type in [Reflection.Assembly]::LoadWithPartialName($name).GetTypes() )
    {
        $fullnames.Add($type.fullname);
    }
}

function new ( $name ) {
    $fullname = $fullnames -like "*.$name";
    return , (New-Object $fullname[0]);
}

using System.Windows.Forms
using FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It
$a = new button
$b = new Thingamabob

Oto kod, który działa w programie PowerShell 2,0, aby dodać aliasy typów. Ale problem polega na tym, że nie ma określonego zakresu. Przy odrobinie dodatkowej pracy można „cofnąć import” przestrzeni nazw, ale powinno to zapewnić dobry początek.

##############################################################################
#.SYNOPSIS
# Add a type accelerator to the current session.
#
#.DESCRIPTION
# The Add-TypeAccelerator function allows you to add a simple type accelerator
# (like [regex]) for a longer type (like [System.Text.RegularExpressions.Regex]).
#
#.PARAMETER Name
# The short form accelerator should be just the name you want to use (without
# square brackets).
#
#.PARAMETER Type
# The type you want the accelerator to accelerate.
#
#.PARAMETER Force
# Overwrites any existing type alias.
#
#.EXAMPLE
# Add-TypeAccelerator List "System.Collections.Generic.List``1"
# $MyList = New-Object List[String]
##############################################################################
function Add-TypeAccelerator {

    [CmdletBinding()]
    param(

        [Parameter(Position=1,Mandatory=$true,ValueFromPipelineByPropertyName=$true)]
        [String[]]$Name,

        [Parameter(Position=2,Mandatory=$true,ValueFromPipeline=$true)]
        [Type]$Type,

        [Parameter()]
        [Switch]$Force

    )

    process {

        $TypeAccelerators = [Type]::GetType('System.Management.Automation.TypeAccelerators')

        foreach ($a in $Name) {
            if ( $TypeAccelerators::Get.ContainsKey($a) ) {
                if ( $Force ) {
                    $TypeAccelerators::Remove($a) | Out-Null
                    $TypeAccelerators::Add($a,$Type)
                }
                elseif ( $Type -ne $TypeAccelerators::Get[$a] ) {
                    Write-Error "$a is already mapped to $($TypeAccelerators::Get[$a])"
                }
            }
            else {
                $TypeAccelerators::Add($a, $Type)
            }
        }

    }

}

Jeśli potrzebujesz tylko utworzyć instancję swojego typu, możesz zapisać nazwę długiej przestrzeni nazw w ciągu:

$st = "System.Text"
$sb = New-Object "$st.StringBuilder"

Nie jest tak potężny jak usingdyrektywa w C #, ale przynajmniej jest bardzo łatwy w użyciu.

Dziękuję wszystkim za wkład. Oznaczyłem wkład Richarda Berga jako odpowiedź, ponieważ najbardziej przypomina to, czego szukam.

Wszystkie twoje odpowiedzi przyniosły mi drogę, która wydaje się najbardziej obiecująca: w swoim poście na blogu Keith Dahlby proponuje komendę Get-Type, która umożliwia łatwe konstruowanie typów dla metod ogólnych.

Myślę, że nie ma powodu, aby nie rozszerzać tego, aby przeszukiwać również wstępnie zdefiniowaną ścieżkę zestawów dla typu.

Zastrzeżenie: nie zbudowałem tego - jeszcze ...

Oto jak można to wykorzystać:

$path = (System.Collections.Generic, FooCompany.Bar.Qux.Assembly.With.Ridiculous.Long.Namespace.I.Really.Mean.It)

$type = get-type -Path $path List Thingamabob
$obj = new-object $type
$obj.GetType()

Spowodowałoby to ładną ogólną Listę Thingamabob. Oczywiście wszystko poza definicją ścieżki zawarłbym w jeszcze jednej funkcji narzędzia. Rozszerzony typ pobierania obejmowałby krok rozstrzygania dowolnego typu ze ścieżki.

#Requires -Version 5
using namespace System.Management.Automation.Host
#using module

Zdaję sobie sprawę, że to stary post, ale szukałem tego samego i trafiłem na to: http://weblogs.asp.net/adweigert/powershell-adding-the-using-statement

Edycja: Przypuszczam, że powinienem sprecyzować, że pozwala na użycie znanej składni ...

using ($x = $y) { ... }