Tương đương với từ khóa “using” của C # trong powershell?

Khi tôi sử dụng một đối tượng khác trong .net-Framework trong C #, tôi có thể tiết kiệm rất nhiều thao tác nhập bằng cách sử dụng chỉ thị using.

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

...


  var blurb = new Thingamabob();

...

Vậy có cách nào trong Powershell để làm điều gì đó tương tự không? Tôi đang truy cập rất nhiều đối tượng .net và không hài lòng khi phải nhập

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

mọi lúc.

PowerShell 5.0 (có trong WMF5 hoặc Windows 10 trở lên), thêm using namespacecấu trúc vào ngôn ngữ. Bạn có thể sử dụng nó trong script của mình như sau:

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

(Câu #Requirelệnh trên dòng đầu tiên là không cần thiết để sử dụng using namespace, nhưng nó sẽ ngăn tập lệnh chạy trong PS 4.0 và bên dưới using namespacelà lỗi cú pháp.)

Thực sự không có gì ở cấp độ không gian tên như vậy. Tôi thường gán các kiểu thường dùng cho các biến và sau đó khởi tạo chúng:

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

Có lẽ không đáng nếu loại này không được sử dụng nhiều lần, nhưng tôi tin rằng đó là điều tốt nhất bạn có thể làm.

Kiểm tra bài đăng trên blog này từ vài năm trước: http://blogs.msdn.com/richardb/archive/2007/02/21/add-types-ps1-poor-man-s-using-for-powershell.aspx

Đây là add-types.ps1, trích từ bài báo đó:

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

Và, để sử dụng nó:

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

Về cơ bản những gì tôi làm là thu thập dữ liệu lắp ráp cho các kiểu không tầm thường, sau đó viết một "phương thức khởi tạo" sử dụng Add-Member để thêm chúng (theo cách có cấu trúc) vào các đối tượng mà tôi quan tâm.

Xem thêm bài đăng tiếp theo này: http://richardberg.net/blog/?p=38

đây chỉ là một trò đùa, một trò đùa ...

$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

Đây là một số mã hoạt động trong PowerShell 2.0 để thêm bí danh loại. Nhưng vấn đề là nó không có phạm vi. Với một số công việc bổ sung, bạn có thể "hủy nhập" không gian tên, nhưng điều này sẽ giúp bạn có một khởi đầu tốt.

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

    }

}

Nếu bạn chỉ cần tạo một phiên bản thuộc loại của mình, bạn có thể lưu trữ tên của không gian tên dài trong một chuỗi:

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

Nó không mạnh bằng usingchỉ thị trong C #, nhưng ít nhất nó rất dễ sử dụng.

Cảm ơn mọi người đã đóng góp ý kiến. Tôi đã đánh dấu đóng góp của Richard Berg như một câu trả lời, bởi vì nó gần giống nhất với những gì tôi đang tìm kiếm.

Tất cả các câu trả lời của bạn đã đưa tôi đi theo hướng có vẻ hứa hẹn nhất: Trong bài đăng trên blog của mình, Keith Dahlby đề xuất một commandlet Get-Type cho phép dễ dàng phân tích các loại cho các phương pháp chung.

Tôi nghĩ rằng không có lý do gì chống lại việc loại bỏ điều này để cũng tìm kiếm thông qua một đường dẫn được xác định trước của các tập hợp cho một kiểu.

Tuyên bố từ chối trách nhiệm: Tôi chưa xây dựng nó - chưa ...

Đây là cách người ta có thể sử dụng nó:

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

Điều này sẽ dẫn đến một Danh sách Thingamabob chung tốt đẹp. Tất nhiên tôi sẽ tóm tắt mọi thứ không có định nghĩa đường dẫn chỉ trong một chức năng tiện ích khác. Kiểu get mở rộng sẽ bao gồm một bước để giải quyết bất kỳ kiểu nào đã cho vẫn giữ nguyên đường dẫn.

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

Tôi nhận ra đây là một bài đăng cũ, nhưng tôi cũng đang tìm kiếm thứ tương tự và bắt gặp nó: http://weblogs.asp.net/adweigert/powershell-adding-the-using-statement

Chỉnh sửa: Tôi cho rằng tôi nên chỉ định rằng nó cho phép bạn sử dụng cú pháp quen thuộc của ...

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