ฉันต้องการกำหนดและใช้ประเภทที่กำหนดเองในสคริปต์ PowerShell ของฉัน ตัวอย่างเช่นสมมติว่าฉันต้องการวัตถุที่มีโครงสร้างต่อไปนี้:

Contact
{
    string First
    string Last
    string Phone
}

ฉันจะสร้างสิ่งนี้ได้อย่างไรเพื่อให้ฉันสามารถใช้งานได้ดังต่อไปนี้:

function PrintContact
{
    param( [Contact]$contact )
    "Customer Name is " + $contact.First + " " + $contact.Last
    "Customer Phone is " + $contact.Phone 
}

สิ่งนี้เป็นไปได้หรือแม้แต่แนะนำใน PowerShell

ก่อนหน้า PowerShell 3

ระบบ Extensible Type ของ PowerShell ไม่ได้ให้คุณสร้างประเภทคอนกรีตที่คุณสามารถทดสอบกับวิธีที่คุณทำในพารามิเตอร์ของคุณได้ หากคุณไม่ต้องการการทดสอบนั้นคุณสามารถใช้วิธีการอื่น ๆ ที่กล่าวถึงข้างต้นได้

หากคุณต้องการประเภทจริงที่คุณสามารถแคสต์หรือพิมพ์ตรวจสอบได้ดังในสคริปต์ตัวอย่างของคุณ ... ไม่สามารถทำได้โดยไม่ต้องเขียนใน C # หรือ VB.net และรวบรวม ใน PowerShell 2 คุณสามารถใช้คำสั่ง "Add-Type" เพื่อทำให้ง่ายขึ้น:

add-type @"
public struct contact {
   public string First;
   public string Last;
   public string Phone;
}
"@

หมายเหตุทางประวัติศาสตร์ : ใน PowerShell 1 นั้นยากยิ่งกว่า คุณต้องใช้ CodeDom ด้วยตนเองมีสคริปต์ new-struct ของฟังก์ชันเก่ามากบน PoshCode.org ซึ่งจะช่วยได้ ตัวอย่างของคุณกลายเป็น:

New-Struct Contact @{
    First=[string];
    Last=[string];
    Phone=[string];
}

การใช้Add-TypeหรือNew-Structจะให้คุณทดสอบชั้นเรียนในของคุณparam([Contact]$contact)และสร้างใหม่โดยใช้$contact = new-object Contactและอื่น ๆ ...

ใน PowerShell 3

หากคุณไม่ต้องการคลาส "ของจริง" ที่คุณสามารถแคสต์ได้คุณไม่จำเป็นต้องใช้วิธีการเพิ่มสมาชิกที่สตีเวนและคนอื่น ๆ ได้แสดงไว้ข้างต้น

เนื่องจาก PowerShell 2 คุณสามารถใช้พารามิเตอร์ -Property สำหรับ New-Object:

$Contact = New-Object PSObject -Property @{ First=""; Last=""; Phone="" }

และใน PowerShell 3 เรามีความสามารถในการใช้PSCustomObjectตัวเร่งความเร็วเพื่อเพิ่ม TypeName:

[PSCustomObject]@{
    PSTypeName = "Contact"
    First = $First
    Last = $Last
    Phone = $Phone
}

คุณยังคงได้รับออบเจ็กต์เดียวเท่านั้นดังนั้นคุณควรสร้างNew-Contactฟังก์ชันเพื่อให้แน่ใจว่าทุกออบเจ็กต์ออกมาเหมือนกัน แต่ตอนนี้คุณสามารถตรวจสอบพารามิเตอร์ "เป็น" หนึ่งในประเภทนั้นได้อย่างง่ายดายโดยการตกแต่งพารามิเตอร์ด้วยPSTypeNameแอตทริบิวต์:

function PrintContact
{
    param( [PSTypeName("Contact")]$contact )
    "Customer Name is " + $contact.First + " " + $contact.Last
    "Customer Phone is " + $contact.Phone 
}

ใน PowerShell 5

ใน PowerShell 5 ทุกอย่างเปลี่ยนแปลงและในที่สุดเราก็ได้classและenumเป็นคำหลักภาษาสำหรับการกำหนดประเภท (ไม่มีstructแต่ก็ไม่เป็นไร):

class Contact
{
    # Optionally, add attributes to prevent invalid values
    [ValidateNotNullOrEmpty()][string]$First
    [ValidateNotNullOrEmpty()][string]$Last
    [ValidateNotNullOrEmpty()][string]$Phone

    # optionally, have a constructor to 
    # force properties to be set:
    Contact($First, $Last, $Phone) {
       $this.First = $First
       $this.Last = $Last
       $this.Phone = $Phone
    }
}

นอกจากนี้เรายังมีวิธีใหม่ในการสร้างวัตถุโดยไม่ต้องใช้New-Object: [Contact]::new()- อันที่จริงถ้าคุณทำให้ชั้นเรียนของคุณเรียบง่ายและไม่ได้กำหนดตัวสร้างคุณสามารถสร้างวัตถุได้โดยการส่งแฮชแท็ก (แม้ว่าจะไม่มีตัวสร้าง แต่ก็ไม่มีทาง เพื่อบังคับว่าต้องตั้งค่าคุณสมบัติทั้งหมด):

class Contact
{
    # Optionally, add attributes to prevent invalid values
    [ValidateNotNullOrEmpty()][string]$First
    [ValidateNotNullOrEmpty()][string]$Last
    [ValidateNotNullOrEmpty()][string]$Phone
}

$C = [Contact]@{
   First = "Joel"
   Last = "Bennett"
}

การสร้างชนิดที่กำหนดเองสามารถทำได้ใน PowerShell
Kirk Munro มีโพสต์ที่ยอดเยี่ยมสองโพสต์ที่ให้รายละเอียดกระบวนการอย่างละเอียด

• การตั้งชื่อวัตถุที่กำหนดเอง
• การกำหนดคุณสมบัติเริ่มต้นสำหรับ Custom Objects

หนังสือWindows PowerShell In Action by Manningยังมีตัวอย่างโค้ดสำหรับสร้างภาษาเฉพาะโดเมนเพื่อสร้างประเภทที่กำหนดเอง หนังสือเล่มนี้ยอดเยี่ยมมากดังนั้นฉันจึงแนะนำให้อ่าน

หากคุณกำลังมองหาวิธีที่รวดเร็วในการดำเนินการข้างต้นคุณสามารถสร้างฟังก์ชันเพื่อสร้างวัตถุที่กำหนดเองเช่น

function New-Person()
{
  param ($FirstName, $LastName, $Phone)

  $person = new-object PSObject

  $person | add-member -type NoteProperty -Name First -Value $FirstName
  $person | add-member -type NoteProperty -Name Last -Value $LastName
  $person | add-member -type NoteProperty -Name Phone -Value $Phone

  return $person
}

นี่คือวิธีทางลัด:

$myPerson = "" | Select-Object First,Last,Phone

คำตอบของ Steven Murawski นั้นยอดเยี่ยมมาก แต่ฉันชอบสิ่งที่สั้นกว่า (หรือมากกว่าแค่เลือกวัตถุที่ดีกว่าแทนที่จะใช้ไวยากรณ์ของสมาชิกเพิ่ม):

function New-Person() {
  param ($FirstName, $LastName, $Phone)

  $person = new-object PSObject | select-object First, Last, Phone

  $person.First = $FirstName
  $person.Last = $LastName
  $person.Phone = $Phone

  return $person
}

ไม่แปลกใจที่ไม่มีใครพูดถึงตัวเลือกง่ายๆนี้ (เทียบกับ 3 หรือใหม่กว่า) สำหรับการสร้างวัตถุที่กำหนดเอง:

[PSCustomObject]@{
    First = $First
    Last = $Last
    Phone = $Phone
}

ประเภทนี้จะเป็น PSCustomObject ไม่ใช่ประเภทที่กำหนดเองจริง แต่น่าจะเป็นวิธีที่ง่ายที่สุดในการสร้างวัตถุแบบกำหนดเอง

มีแนวคิดของ PSObject และ Add-Member ที่คุณสามารถใช้ได้

$contact = New-Object PSObject

$contact | Add-Member -memberType NoteProperty -name "First" -value "John"
$contact | Add-Member -memberType NoteProperty -name "Last" -value "Doe"
$contact | Add-Member -memberType NoteProperty -name "Phone" -value "123-4567"

ผลลัพธ์นี้เช่น:

[8] » $contact

First                                       Last                                       Phone
-----                                       ----                                       -----
John                                        Doe                                        123-4567

ทางเลือกอื่น (ที่ฉันทราบ) คือการกำหนดประเภทใน C # / VB.NET และโหลดแอสเซมบลีนั้นลงใน PowerShell เพื่อใช้งานโดยตรง

พฤติกรรมนี้ได้รับการสนับสนุนอย่างแน่นอนเนื่องจากอนุญาตให้สคริปต์หรือส่วนอื่น ๆ ของสคริปต์ของคุณทำงานร่วมกับออบเจ็กต์จริงได้

นี่คือเส้นทางที่ยากในการสร้างประเภทที่กำหนดเองและเก็บไว้ในคอลเลกชัน

$Collection = @()

$Object = New-Object -TypeName PSObject
$Object.PsObject.TypeNames.Add('MyCustomType.Contact.Detail')
Add-Member -InputObject $Object -memberType NoteProperty -name "First" -value "John"
Add-Member -InputObject $Object -memberType NoteProperty -name "Last" -value "Doe"
Add-Member -InputObject $Object -memberType NoteProperty -name "Phone" -value "123-4567"
$Collection += $Object

$Object = New-Object -TypeName PSObject
$Object.PsObject.TypeNames.Add('MyCustomType.Contact.Detail')
Add-Member -InputObject $Object -memberType NoteProperty -name "First" -value "Jeanne"
Add-Member -InputObject $Object -memberType NoteProperty -name "Last" -value "Doe"
Add-Member -InputObject $Object -memberType NoteProperty -name "Phone" -value "765-4321"
$Collection += $Object

Write-Ouput -InputObject $Collection

นี่เป็นอีกหนึ่งตัวเลือกที่ใช้ความคิดที่คล้ายกับการแก้ปัญหาดังกล่าว PSTypeName โดยJaykul (และยังต้อง PSv3 หรือสูงกว่า)

ตัวอย่าง

1. สร้างไฟล์TypeName .Types.ps1xmlเพื่อกำหนดประเภทของคุณ เช่นPerson.Types.ps1xml:

<?xml version="1.0" encoding="utf-8" ?>
<Types>
  <Type>
    <Name>StackOverflow.Example.Person</Name>
    <Members>
      <ScriptMethod>
        <Name>Initialize</Name>
        <Script>
            Param (
                [Parameter(Mandatory = $true)]
                [string]$GivenName
                ,
                [Parameter(Mandatory = $true)]
                [string]$Surname
            )
            $this | Add-Member -MemberType 'NoteProperty' -Name 'GivenName' -Value $GivenName
            $this | Add-Member -MemberType 'NoteProperty' -Name 'Surname' -Value $Surname
        </Script>
      </ScriptMethod>
      <ScriptMethod>
        <Name>SetGivenName</Name>
        <Script>
            Param (
                [Parameter(Mandatory = $true)]
                [string]$GivenName
            )
            $this | Add-Member -MemberType 'NoteProperty' -Name 'GivenName' -Value $GivenName -Force
        </Script>
      </ScriptMethod>
      <ScriptProperty>
        <Name>FullName</Name>
        <GetScriptBlock>'{0} {1}' -f $this.GivenName, $this.Surname</GetScriptBlock>
      </ScriptProperty>
      <!-- include properties under here if we don't want them to be visible by default
      <MemberSet>
        <Name>PSStandardMembers</Name>
        <Members>
        </Members>
      </MemberSet>
      -->
    </Members>
  </Type>
</Types>

2. นำเข้าประเภทของคุณ: Update-TypeData -AppendPath .\Person.Types.ps1xml
3. สร้างวัตถุประเภทที่คุณกำหนดเอง: $p = [PSCustomType]@{PSTypeName='StackOverflow.Example.Person'}
4. เริ่มต้นประเภทของคุณโดยใช้วิธีการสคริปต์ที่คุณกำหนดใน XML: $p.Initialize('Anne', 'Droid')
5. ดูสิ; คุณจะเห็นคุณสมบัติทั้งหมดที่กำหนด:$p | Format-Table -AutoSize
6. พิมพ์เรียก mutator เพื่ออัปเดตค่าคุณสมบัติ: $p.SetGivenName('Dan')
7. ดูอีกครั้งเพื่อดูค่าที่อัปเดต: $p | Format-Table -AutoSize

คำอธิบาย

• ไฟล์ PS1XML อนุญาตให้คุณกำหนดคุณสมบัติที่กำหนดเองในประเภท
• ไม่ จำกัด เฉพาะประเภท. net ตามที่เอกสารระบุไว้ ดังนั้นคุณสามารถใส่สิ่งที่คุณชอบลงใน '/ types / Type / Name' วัตถุใด ๆ ที่สร้างด้วย 'PSTypeName' ที่ตรงกันจะสืบทอดสมาชิกที่กำหนดไว้สำหรับประเภทนี้
• สมาชิกเพิ่มผ่านPS1XMLหรือAdd-Memberถูก จำกัดNoteProperty, AliasProperty, ScriptProperty, CodeProperty, ScriptMethodและCodeMethod(หรือPropertySet/ MemberSetแม้ว่าผู้ที่อยู่ภายใต้ข้อ จำกัด เหมือนกัน) คุณสมบัติทั้งหมดนี้เป็นแบบอ่านอย่างเดียว
• ด้วยการกำหนดScriptMethodเราสามารถโกงข้อ จำกัด ข้างต้นได้ เช่นเราสามารถกำหนดวิธีการ (เช่นInitialize) ที่สร้างคุณสมบัติใหม่ตั้งค่าให้เรา ดังนั้นจึงมั่นใจได้ว่าวัตถุของเรามีคุณสมบัติทั้งหมดที่เราต้องการเพื่อให้สคริปต์อื่น ๆ ของเราทำงานได้
• เราสามารถใช้เคล็ดลับเดียวกันนี้เพื่อให้คุณสมบัติที่จะสามารถปรับปรุง (แม้จะผ่านวิธีมากกว่าที่ได้รับมอบหมายโดยตรง) SetGivenNameที่แสดงในตัวอย่างของ

แนวทางนี้ไม่เหมาะสำหรับทุกสถานการณ์ แต่มีประโยชน์สำหรับการเพิ่มพฤติกรรมที่เหมือนคลาสให้กับประเภทที่กำหนดเอง / สามารถใช้ร่วมกับวิธีการอื่น ๆ ที่กล่าวถึงในคำตอบอื่น ๆ เช่นในโลกแห่งความเป็นจริงฉันอาจกำหนดFullNameคุณสมบัติใน PS1XML เท่านั้นจากนั้นใช้ฟังก์ชันเพื่อสร้างวัตถุด้วยค่าที่ต้องการดังนี้:

ข้อมูลเพิ่มเติม

ดูเอกสารประกอบหรือไฟล์ประเภท OOTB Get-Content $PSHome\types.ps1xmlสำหรับแรงบันดาลใจ

# have something like this defined in my script so we only try to import the definition once.
# the surrounding if statement may be useful if we're dot sourcing the script in an existing 
# session / running in ISE / something like that
if (!(Get-TypeData 'StackOverflow.Example.Person')) {
    Update-TypeData '.\Person.Types.ps1xml'
}

# have a function to create my objects with all required parameters
# creating them from the hash table means they're PROPERties; i.e. updatable without calling a 
# setter method (note: recall I said above that in this scenario I'd remove their definition 
# from the PS1XML)
function New-SOPerson {
    [CmdletBinding()]
    [OutputType('StackOverflow.Example.Person')]
    Param (
        [Parameter(Mandatory)]
        [string]$GivenName
        ,
        [Parameter(Mandatory)]
        [string]$Surname
    )
    ([PSCustomObject][Ordered]@{
        PSTypeName = 'StackOverflow.Example.Person'
        GivenName = $GivenName
        Surname = $Surname
    })
}

# then use my new function to generate the new object
$p = New-SOPerson -GivenName 'Simon' -Surname 'Borg'

# and thanks to the type magic... FullName exists :)
Write-Information "$($p.FullName) was created successfully!" -InformationAction Continue