Ich möchte in einigen meiner PowerShell-Skripts einen benutzerdefinierten Typ definieren und verwenden können. Nehmen wir zum Beispiel an, ich brauche ein Objekt mit der folgenden Struktur:

Contact
{
    string First
    string Last
    string Phone
}

Wie würde ich vorgehen, um dies zu erstellen, damit ich es in folgenden Funktionen verwenden kann:

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

Ist so etwas in PowerShell möglich oder sogar empfohlen?

Vor PowerShell 3

Mit dem Extensible Type System von PowerShell konnten Sie ursprünglich keine konkreten Typen erstellen, die Sie anhand der Parameter testen können. Wenn Sie diesen Test nicht benötigen, können Sie eine der anderen oben genannten Methoden anwenden.

Wenn Sie einen tatsächlichen Typ möchten, den Sie wie in Ihrem Beispielskript umwandeln oder mit dem Sie ihn überprüfen können, können Sie dies nicht tun, ohne ihn in C # oder VB.net zu schreiben und zu kompilieren. In PowerShell 2 können Sie den Befehl "Typ hinzufügen" verwenden, um dies ganz einfach zu tun:

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

Historischer Hinweis : In PowerShell 1 war es noch schwieriger. Sie mussten CodeDom manuell verwenden, es gibt ein sehr altes Funktions- New- Struct - Skript auf PoshCode.org, das helfen wird. Ihr Beispiel wird:

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

Mit Add-Typeoder New-Structkönnen Sie die Klasse in Ihrer Klasse testen param([Contact]$contact)und neue erstellen, indem Sie $contact = new-object Contactusw. verwenden ...

In PowerShell 3

Wenn Sie keine "echte" Klasse benötigen, in die Sie umwandeln können, müssen Sie nicht die Add-Member-Methode verwenden, die Steven und andere oben demonstriert haben .

Seit PowerShell 2 können Sie den Parameter -Property für New-Object verwenden:

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

In PowerShell 3 haben wir die Möglichkeit, mithilfe des PSCustomObjectBeschleunigers einen Typnamen hinzuzufügen:

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

Sie erhalten immer noch nur ein einzelnes Objekt. Sie sollten daher eine New-ContactFunktion erstellen, um sicherzustellen, dass jedes Objekt gleich ausgegeben wird. Sie können jetzt jedoch leicht überprüfen, ob ein Parameter "ist" einer dieser Typen ist, indem Sie einen Parameter mit dem folgenden PSTypeNameAttribut dekorieren :

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

In PowerShell 5

In PowerShell 5 ändert sich alles und wir haben endlich classund enumals Sprachschlüsselwörter zum Definieren von Typen (es gibt keine, structaber das ist in Ordnung):

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

Wir haben auch eine neue Möglichkeit zum Erstellen von Objekten ohne Verwendung New-Object: [Contact]::new()- Wenn Sie Ihre Klasse einfach halten und keinen Konstruktor definieren, können Sie Objekte erstellen, indem Sie eine Hashtabelle umwandeln (obwohl es ohne Konstruktor keine Möglichkeit gibt um zu erzwingen, dass alle Eigenschaften festgelegt werden müssen):

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

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

Das Erstellen benutzerdefinierter Typen kann in PowerShell erfolgen.
Kirk Munro hat tatsächlich zwei großartige Beiträge, die den Prozess gründlich beschreiben.

• Benutzerdefinierte Objekte benennen
• Definieren von Standardeigenschaften für benutzerdefinierte Objekte

Das Buch Windows PowerShell In Action von Manning enthält auch ein Codebeispiel zum Erstellen einer domänenspezifischen Sprache zum Erstellen benutzerdefinierter Typen. Das Buch ist rundum ausgezeichnet, daher kann ich es nur empfehlen.

Wenn Sie nur nach einer schnellen Möglichkeit suchen, dies zu tun, können Sie eine Funktion zum Erstellen eines benutzerdefinierten Objekts erstellen

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
}

Dies ist die Verknüpfungsmethode:

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

Steven Murawskis Antwort ist großartig, aber ich mag das kürzere (oder besser gesagt das sauberere Auswahlobjekt, anstatt die Syntax für Add-Member zu verwenden):

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
}

Überrascht erwähnte niemand diese einfache Option (vs 3 oder höher) zum Erstellen von benutzerdefinierten Objekten:

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

Der Typ ist PSCustomObject, jedoch kein tatsächlicher benutzerdefinierter Typ. Aber es ist wahrscheinlich der einfachste Weg, ein benutzerdefiniertes Objekt zu erstellen.

Es gibt das Konzept von PSObject und Add-Member, das Sie verwenden können.

$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"

Dies gibt aus wie:

[8] » $contact

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

Die andere Alternative (die mir bekannt ist) besteht darin, einen Typ in C # / VB.NET zu definieren und diese Assembly zur direkten Verwendung in PowerShell zu laden.

Dieses Verhalten wird definitiv empfohlen, da andere Skripte oder Abschnitte Ihres Skripts mit einem tatsächlichen Objekt arbeiten können.

Hier ist der schwierige Weg, um benutzerdefinierte Typen zu erstellen und in einer Sammlung zu speichern.

$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

Hier ist eine weitere Option, die eine ähnliche Idee wie die von Jaykul erwähnte PSTypeName-Lösung verwendet (und daher auch PSv3 oder höher erfordert).

Beispiel

1. Erstellen Sie eine TypeName .Types.ps1xml- Datei, die Ihren Typ definiert. ZB 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. Importieren Sie Ihren Typ: Update-TypeData -AppendPath .\Person.Types.ps1xml
3. Erstellen Sie ein Objekt Ihres benutzerdefinierten Typs: $p = [PSCustomType]@{PSTypeName='StackOverflow.Example.Person'}
4. Initialisieren Sie Ihren Typ mit der Skriptmethode, die Sie im XML definiert haben: $p.Initialize('Anne', 'Droid')
5. Schau es dir an; Sie sehen alle definierten Eigenschaften:$p | Format-Table -AutoSize
6. Geben Sie den Aufruf eines Mutators ein, um den Wert einer Eigenschaft zu aktualisieren: $p.SetGivenName('Dan')
7. Schauen Sie es sich noch einmal an, um den aktualisierten Wert zu sehen: $p | Format-Table -AutoSize

Erläuterung

• Mit der PS1XML-Datei können Sie benutzerdefinierte Eigenschaften für Typen definieren.
• Es ist nicht auf .net-Typen beschränkt, wie in der Dokumentation angegeben. So können Sie in '/ Types / Type / Name' ein beliebiges Objekt einfügen, das mit einem passenden 'PSTypeName' erstellt wurde. Es erbt die für diesen Typ definierten Mitglieder.
• Mitglieder hinzugefügt durch PS1XMLoder Add-Membersind beschränkt auf NoteProperty, AliasProperty, ScriptProperty, CodeProperty, ScriptMethod, und CodeMethod(oder PropertySet/ MemberSet, obwohl diejenigen , unterliegen den gleichen Einschränkungen). Alle diese Eigenschaften sind schreibgeschützt.
• Durch die Definition von a können ScriptMethodwir die obige Einschränkung betrügen. ZB Wir können eine Methode (z. B. Initialize) definieren, die neue Eigenschaften erstellt und deren Werte für uns festlegt. So stellen Sie sicher, dass unser Objekt alle Eigenschaften hat, die wir benötigen, damit unsere anderen Skripte funktionieren.
• Wir können denselben Trick verwenden, um zu ermöglichen, dass die Eigenschaften aktualisiert werden können (allerdings über eine Methode anstelle einer direkten Zuweisung), wie in den Beispielen gezeigt SetGivenName.

Dieser Ansatz ist nicht für alle Szenarien ideal. Dies ist jedoch nützlich, um benutzerdefinierten Typen klassenähnliches Verhalten hinzuzufügen. / Kann in Verbindung mit anderen in den anderen Antworten genannten Methoden verwendet werden. In der realen Welt würde ich wahrscheinlich nur die FullNameEigenschaft in PS1XML definieren und dann eine Funktion verwenden, um das Objekt mit den erforderlichen Werten zu erstellen, wie folgt:

Mehr Info

Schauen Sie sich die Dokumentation oder die OOTB-Datei an, Get-Content $PSHome\types.ps1xmlum sich inspirieren zu lassen.

# 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