Äquivalent zu C#"Verwenden" Keyword in PowerShell?

Question

Wenn ich ein anderes Objekt im .Net-Framework in C# verwende, kann ich viel Tippen speichern, indem ich die Verwendung der Anweisung verwenden.

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

...


  var blurb = new Thingamabob();

...

Gibt es also einen Weg in Powershell, etwas Ähnliches zu tun? Ich greife auf viele .NET -Objekte zu und freue mich nicht, tippen zu müssen

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

die ganze Zeit.

Answer 1

PowerShell 5.0 (enthalten in WMF5 oder Windows 10 und Up) fügt die hinzu using namespace Konstrukt in die Sprache. Sie können es in Ihrem Skript wie SO verwenden:

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

(Das #Require Die Anweisung in der ersten Zeile ist nicht erforderlich, um zu verwenden using namespace, aber es verhindert, dass das Skript in PS 4.0 und unter wo ausführt using namespace ist ein Syntaxfehler.)

Answer 2

Es gibt wirklich nichts auf der Namespace -Ebene. Ich weise Variablen häufig häufig verwendete Typen zu und instanziiere sie dann:

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

Wahrscheinlich nicht wert, wenn der Typ nicht wiederholt verwendet wird, aber ich glaube, es ist das Beste, was Sie tun können.

Answer 3

Schauen Sie sich diesen Blog -Beitrag vor ein paar Jahren an: http://blogs.msdn.com/richardb/archive/2007/02/21/add-types-ps1-poor-man-using-for-powershell.aspx

Hier ist add-types.ps1, Auszug aus diesem Artikel:

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

Und um es zu verwenden:

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

---

Grundsätzlich kriechen ich die Baugruppe für nicht triviale Typen und schreibe dann einen "Konstruktor", bei dem Add-Mitglied sie (auf strukturierte Weise) zu den Objekten hinzufügen, die mir wichtig sind.

Siehe auch diesen Followup -Beitrag: http://richardberg.net/blog/?p=38

Answer 4

Das ist nur ein Witz, Witz ...

$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

Answer 5

Hier ist ein Code, der in PowerShell 2.0 funktioniert, um Typ -Aliase hinzuzufügen. Das Problem ist jedoch, dass es nicht geschrieben ist. Mit etwas zusätzlichen Arbeit könnten Sie die Namespaces "nicht importieren", aber dies sollte Sie zu einem guten Start bringen.

##############################################################################
#.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)
            }
        }

    }

}

Answer 6

Wenn Sie nur eine Instanz Ihres Typs erstellen müssen, können Sie den Namen des langen Namespace in einer Zeichenfolge speichern:

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

Es ist nicht so mächtig wie das using Richtlinie in C#, aber zumindest ist es sehr einfach zu bedienen.

Answer 7

Vielen Dank an alle für Ihre Eingabe. Ich habe Richard Bergs Beitrag als Antwort gekennzeichnet, weil er dem, wonach ich suche, am ähnlichsten ähnelt.

Alle Ihre Antworten haben mich auf die Strecke gebracht, die am vielversprechendsten erscheint: in Sein Blog -Beitrag Keith Dahlby schlägt ein Befehl Get-Typ vor, das eine einfache Konditionierung von Typen für generische Methoden ermöglicht.

Ich denke, es gibt keinen Grund gegen die Exetendierung dieser, um auch einen vordefinierten Pfad der Baugruppen für einen Typ zu durchsuchen.

Haftungsausschluss: Ich habe das noch nicht gebaut - ...

So könnte man es verwenden:

$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()

Dies würde zu einer schönen generischen Liste von Dingen führen. Natürlich würde ich alles in einer anderen Nutzfunktion in Everything die Pfaddefinition abschließen. Der erweiterte Getress-Typ würde einen Schritt enthalten, um einen bestimmten Typ erneut auf den Pfad zu beheben.

Answer 8

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

Answer 9

Mir ist klar, dass dies ein alter Beitrag ist, aber ich suchte nach demselben und stieß auf diese: http://weblogs.asp.net/adweigert/powershell-adding-the-using-sterdement

Bearbeiten: Ich nehme an, ich sollte angeben, dass Sie die vertraute Syntax von ...

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