Add-Type

Artikel
10/30/2009

Fügt einer Windows PowerShell-Sitzung einen Microsoft .NET Framework-Typ (eine Klasse) hinzu.

Syntax

Add-Type -AssemblyName <string[]> [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-Name] <string> [-MemberDefinition] <string[]> [-CodeDomProvider <CodeDomProvider>] [-CompilerParameters <CompilerParameters>] [-Language {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-Namespace <string>] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-UsingNamespace <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-Path] <string[]> [-CompilerParameters <CompilerParameters>] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-TypeDefinition] <string> [-CodeDomProvider <CodeDomProvider>] [-CompilerParameters <CompilerParameters>] [-Language {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Beschreibung

Mit dem Cmdlet "Add-Type" können Sie in der Windows PowerShell-Sitzung eine .NET Framework-Klasse definieren. Sie können dann (mit dem Cmdlet "New-Object") Objekte instanziieren und die Objekte wie jedes andere .NET Framework-Objekt verwenden. Wenn Sie dem Windows PowerShell-Profil den Befehl "Add-Type" hinzufügen, ist die Klasse in allen Windows PowerShell-Sitzungen verfügbar.

Sie können den Typ angeben, indem Sie eine vorhandene Assembly oder Quellcodedateien angeben, oder Sie können Quellcode inline angeben oder in einer Variablen gespeicherten Quellcode angeben. Sie können sogar nur eine Methode angeben, und mit Add-Type wird die Klasse definiert und generiert. Mit diesem Feature können Sie Plattformaufrufe (P/Invoke) von nicht verwalteten Funktionen in Windows PowerShell ausführen. Wenn Sie Quellcode angeben, kompiliert Add-Type den angegebenen Quellcode und generiert eine speicherinterne Assembly, die die neuen .NET Framework-Typen enthält.

Sie können mithilfe der Parameter von Add-Type eine alternative Sprache und einen alternativen Compiler (der Standardwert ist "CSharp"), Compileroptionen, Assemblyabhängigkeiten, den Klassennamespace sowie den Namen des Typs und der resultierenden Assembly angeben.

Parameter

-AssemblyName <string[]>

Gibt den Namen einer Assembly an, die die Typen einschließt. Add-Type übernimmt die Typen aus der angegebenen Assembly. Beim Erstellen von Typen auf Grundlage eines Assemblynamens ist dieser Parameter erforderlich.

Geben Sie den vollständigen oder einfachen Namen (auch als "partieller Name" bezeichnet) einer Assembly ein. Platzhalterzeichen sind im Assemblynamen zulässig. Wenn Sie einen einfachen oder partiellen Namen eingeben, löst ihn Add-Type in den vollständigen Namen auf und verwendet diesen dann zum Laden der Assembly.

Dieser Parameter akzeptiert weder einen Pfad noch einen Dateinamen. Um den Pfad zur DLL-Datei (Dynamic Link Library) der Assembly einzugeben, verwenden Sie den Path-Parameter.

Erforderlich?	true
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	true

-CodeDomProvider <CodeDomProvider>

Gibt einen Code-Generator oder einen Compiler an. Add-Type kompiliert den Quellcode mithilfe des angegebenen Compilers. Der Standardwert ist der CSharp-Compiler. Verwenden Sie diesen Parameter zum Angeben einer Sprache, die nicht mit dem Language-Parameter angegeben werden kann. Der CodeDomProvider, den Sie angeben, muss Assemblys aus Quellcode generieren können.

Erforderlich?	false
Position?	named
Standardwert	CSharp-Compiler
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-CompilerParameters <CompilerParameters>

Gibt die Optionen für den Quellcodecompiler an. Diese Optionen werden ohne Änderungen an den Compiler gesendet.

Mit diesem Parameter können Sie festlegen, dass der Compiler eine ausführbare Datei generiert, Ressourcen einbetten oder Befehlszeilenoptionen, z. B. die Option "/unsafe", festlegen. Dieser Parameter implementiert die CompilerParameters-Klasse (System.CodeDom.Compiler.CompilerParameters).

Erforderlich?	false
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-IgnoreWarnings

Ignoriert Compilerwarnungen. Verwenden Sie diesen Parameter, um zu verhindern, dass Add-Type Compilerwarnungen als Fehler behandelt.

Erforderlich?	false
Position?	named
Standardwert	False
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-Language <Language>

Gibt die im Quellcode verwendete Sprache an. Der richtige Codecompiler wird von Add-Type anhand der Sprache ausgewählt.

Gültige Werte sind "CSharp", "CSharpVersion3", "VisualBasic" und "JScript". Der Standardwert ist "CSharp".

Erforderlich?	false
Position?	named
Standardwert	CSharp
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-MemberDefinition <string[]>

Gibt neue Eigenschaften oder Methoden für die Klasse an. Add-Type generiert den Vorlagencode, der für die Unterstützung der Eigenschaften oder Methoden erforderlich ist.

Mit diesem Feature können Sie Plattformaufrufe (P/Invoke) von nicht verwalteten Funktionen in Windows PowerShell ausführen. Weitere Informationen finden Sie in den Beispielen.

Erforderlich?	true
Position?	2
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-Name <string>

Gibt den Namen der zu erstellenden Klasse an. Beim Generieren eines Typs aus einer Elementdefinition ist dieser Parameter erforderlich.

Der Name und Namespace des Typs müssen innerhalb einer Sitzung eindeutig sein. Ein Typ kann nicht entladen oder geändert werden. Wenn der Code für einen Typ geändert werden muss, müssen Sie den Namen ändern oder eine neue Windows PowerShell-Sitzung starten. Andernfalls schlägt der Befehl fehl.

Erforderlich?	true
Position?	1
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-Namespace <string>

Gibt einen Namespace für den Typ an.

Wenn dieser Parameter nicht im Befehl enthalten ist, wird der Typ im Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes-Namespace erstellt. Wenn der Parameter mit einem leeren Zeichenfolgenwert oder dem Wert $null im Befehl enthalten ist, wird der Typ im globalen Namespace generiert.

Erforderlich?	false
Position?	named
Standardwert	Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-OutputAssembly <string>

Generiert eine DLL-Datei für die Assembly mit dem angegebenen Namen an dem Speicherort. Geben Sie einen Pfad (optional) und einen Dateinamen ein. Platzhalterzeichen sind zulässig. Standardmäßig generiert Add-Type die Assembly nur im Arbeitsspeicher.

Erforderlich?	false
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	true

-OutputType <OutputAssemblyType>

Gibt den Ausgabetyp der Ausgabeassembly an. Gültige Werte sind "Library", "ConsoleApplication" und "WindowsApplication".

Standardmäßig wird kein Ausgabetyp angegeben.

Dieser Parameter ist nur gültig, wenn eine Ausgabeassembly im Befehl angegeben wird.

Erforderlich?	false
Position?	named
Standardwert	Keiner
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-PassThru

Gibt ein System.Runtime-Objekt zurück, das die Typen darstellt, die hinzugefügt wurden. Standardmäßig wird von diesem Cmdlet keine Ausgabe generiert.

Erforderlich?	false
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-Path <string[]>

Gibt den Pfad von Quellcodedateien oder Assembly-DLL-Dateien an, die die Typen enthalten.

Wenn Sie Quellcodedateien senden, kompiliert Add-Type den Code in den Dateien und erstellt eine speicherinterne Assembly der Typen. Die im Wert von "Path" angegebene Dateinamenerweiterung bestimmt den von Add-Type verwendeten Compiler.

Wenn Sie eine Assemblydatei senden, übernimmt Add-Type die Typen aus der Assembly. Verwenden Sie zum Angeben einer speicherinternen Assembly oder des globalen Assemblycaches den AssemblyName-Parameter.

Erforderlich?	true
Position?	1
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-ReferencedAssemblies <string[]>

Gibt die Assemblys an, von denen der Typ abhängt. Add-Type verweist standardmäßig auf "System.dll" und "System.Management.Automation.dll". Zusätzlich zu den Standardassemblys wird auf die Assemblys verwiesen, die Sie mit diesem Parameter angeben.

Erforderlich?	false
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-TypeDefinition <string>

Gibt den Quellcode an, der die Typdefinitionen enthält. Geben Sie den Quellcode in einer Zeichenfolge oder einer here-Zeichenfolge ein, oder geben Sie eine Variable ein, die den Quellcode enthält. Weitere Informationen über here-Zeichenfolgen finden Sie unter "about_Quoting_Rules".

Schließen Sie in die Typdefinition eine Namespacedeklaration ein. Wenn Sie die Namespacedeklaration weglassen, stimmt möglicherweise der Name des Typs mit dem Namen eines anderen Typs oder der Verknüpfung für einen anderen Typ überein. Dies kann ein unbeabsichtigtes Überschreiben verursachen. Wenn Sie beispielsweise einen Typ mit dem Namen "Exception" definieren, schlagen Skripts fehl, in denen "Exception" als Kurzform für "System.Exception" verwendet wird.

Erforderlich?	true
Position?	1
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

-UsingNamespace <string[]>

Gibt weitere Namespaces an, die für die Klasse erforderlich sind. Dies entspricht dem Using-Schlüsselwort in C#.

Standardmäßig verweist Add-Type auf den System-Namespace. Wenn der MemberDefinition-Parameter verwendet wird, verweist Add-Type standardmäßig auch auf den System.Runtime.InteropServices-Namespace. Zusätzlich zu den Standardnamespaces wird auf die Namespaces verwiesen, die Sie mit dem UsingNamespace-Parameter hinzufügen.

Erforderlich?	false
Position?	named
Standardwert
Pipelineeingaben akzeptieren?	false
Platzhalterzeichen akzeptieren?	false

<CommonParameters>

Dieses Cmdlet unterstützt die folgenden allgemeinen Parameter: -Verbose, -Debug, -ErrorAction, -ErrorVariable, -OutBuffer und -OutVariable. Weitere Informationen finden Sie unter about_Commonparameters.

Eingaben und Ausgaben

Der Eingabetyp ist der Typ der Objekte, die über die Pipeline an das Cmdlet übergeben werden können. Der Rückgabetyp ist der Typ der Objekte, die das Cmdlet zurückgibt.

Eingaben

Keiner

Objekte können nicht über die Pipeline an Add-Type übergeben werden.

Ausgaben

Keiner oder System.RuntimeType

Wenn Sie den PassThru-Parameter verwenden, gibt Add-Type ein System.RuntimeType-Objekt zurück, das den neuen Typ darstellt. Andernfalls wird von diesem Cmdlet keine Ausgabe generiert.

Hinweise

Die Typen, die Sie hinzufügen, sind nur in der aktuellen Sitzung vorhanden. Fügen Sie die Typen dem Windows PowerShell-Profil hinzu, wenn Sie sie in allen Sitzungen verwenden möchten. Weitere Informationen über das Profil finden Sie unter "about_Profiles".

Typnamen (und -namespaces) müssen innerhalb einer Sitzung eindeutig sein. Ein Typ kann nicht entladen oder geändert werden. Wenn der Code für einen Typ geändert werden muss, müssen Sie den Namen ändern oder eine neue Windows PowerShell-Sitzung starten. Andernfalls schlägt der Befehl fehl.

Die CodeDomProvider-Klasse für einige Sprachen, z. B. IronPython und JSharp, generiert keine Ausgabe. Daher können in diesen Sprachen geschriebene Typen nicht mit Add-Type verwendet werden.

Dieses Cmdlet basiert auf der CodeDomProvider-Klasse. Weitere Informationen über diese Klasse finden Sie im Microsoft .NET Framework SDK.

Beispiel 1

C:\PS>$source = @"
public class BasicTest
{
    public static int Add(int a, int b)
    {
        return (a + b);
    }

    public int Multiply(int a, int b)
    {
        return (a * b);
    }
}
"@

C:\PS> Add-Type -TypeDefinition $source

C:\PS> [BasicTest]::Add(4, 3)

C:\PS> $basicTestObject = New-Object BasicTest 
C:\PS> $basicTestObject.Multiply(5, 2)

Beschreibung
-----------
Mit diesen Befehlen wird der Sitzung durch Angabe von Quellcode, der in einer Variablen gespeichert ist, die BasicTest-Klasse hinzugefügt. Der Typ verfügt über die statische Add-Methode und die nicht statische Multiply-Methode.

Im ersten Befehl wird der Quellcode für die Klasse in der Variablen "$source" gespeichert.

Im zweiten Befehl wird die Klasse mit dem Cmdlet "Add-Type" der Sitzung hinzugefügt. Aufgrund der Verwendung von Inlinequellcode wird im Befehl der Code in der Variablen "$source" mit dem TypeDefinition-Parameter angegeben.

In den restlichen Befehlen wird die neue Klasse verwendet.

Im dritten Befehl wird die statische Add-Methode der BasicTest-Klasse aufgerufen. Statische Elemente der Klasse werden mit zweifachem Doppelpunkt (::) angegeben.

Im vierten Befehl wird eine Instanz der BasicTest-Klasse mit dem Cmdlet "New-Object" instanziiert. Das neue Objekt wird in der Variablen "$basicTestObject" gespeichert. 

Im fünften Befehl wird die Multiply-Methode von $basicTestObject verwendet.

Beispiel 2

C:\PS>[BasicTest] | get-member

C:\PS> [BasicTest] | get-member -static

C:\PS> $basicTestObject | get-member

C:\PS> [BasicTest] | get-member


   TypeName: System.RuntimeType

Name                           MemberType Definition
----                           ---------- ----------
Clone                          Method     System.Object Clone()
Equals                         Method     System.Boolean Equals
FindInterfaces                 Method     System.Type[] FindInt
...


C:\PS> [BasicTest] | get-member -static

   TypeName: BasicTest

Name            MemberType Definition
----            ---------- ----------
Add             Method     static System.Int32 Add(Int32 a, Int32 b)
Equals          Method     static System.Boolean Equals(Object objA,
ReferenceEquals Method     static System.Boolean ReferenceEquals(Obj


C:\PS> $basicTestObject | get-member

   TypeName: BasicTest

Name        MemberType Definition
----        ---------- ----------
Equals      Method     System.Boolean Equals(Object obj)
GetHashCode Method     System.Int32 GetHashCode()
GetType     Method     System.Type GetType()
Multiply    Method     System.Int32 Multiply(Int32 a, Int32 b)
ToString    Method     System.String ToString()

Beschreibung
-----------
In diesen Befehlen werden die Objekte, die im vorherigen Beispiel mit den Cmdlets "Add-Type" und "New-Object" erstellt wurden, mit dem Cmdlet "Get-Member" untersucht.

Im ersten Befehl werden der Typ und die Elemente der BasicTest-Klasse, die mit "Add-Type" der Sitzung hinzugefügt wurde, mit dem Cmdlet "Get-Member" abgerufen. Mit dem Befehl "Get-Member" wird ermittelt, dass es sich um ein System.RuntimeType-Objekt handelt, das von der System.Object-Klasse abgeleitet wird.

Im zweiten Befehl werden die statischen Eigenschaften und Methoden der BasicTest-Klasse mit dem Static-Parameter von Get-Member abgerufen. In der Ausgabe ist die Add-Methode eingeschlossen.

Im dritten Befehl werden die Elemente des in der Variablen "$BasicTestObject" gespeicherten Objekts mit Get-Member abgerufen. Dies ist die Objektinstanz, die durch Verwendung des Cmdlet "New-Object" mit der $BasicType-Klasse erstellt wurde. 

Die Ausgabe zeigt, dass der Wert der Variablen "$basicTestObject" eine Instanz der BasicTest-Klasse ist und dass sie ein Element mit dem Namen "Multiply" enthält.

Beispiel 3

C:\PS>$accType = add-type -assemblyname accessib* -passthru

Beschreibung
-----------
Mit diesem Befehl werden der aktuellen Sitzung die Klassen aus der Accessibility-Assembly hinzugefügt. In dem Befehl wird der Name der Assembly mithilfe des AssemblyName-Parameters angegeben. Mit dem Platzhalterzeichen können Sie die richtige Assembly abrufen, selbst wenn Sie deren Namen oder Schreibweise nicht genau kennen.

Im Befehl werden mit dem PassThru-Parameter Objekte generiert, die die der Sitzung hinzugefügten Klassen darstellen, und die Objekte werden in der Variablen "$accType" gespeichert.

Beispiel 4

C:\PS>add-type -path c:\ps-test\Hello.vb

[VBFromFile]::SayHello(", World")

# From Hello.vb
Public Class VBFromFile

Public Shared Function SayHello(sourceName As String) As String
Dim myValue As String = "Hello"

return myValue + sourceName
End Function
End Class

C:\PS> [VBFromFile]::SayHello(", World")
Hello, World

Beschreibung
-----------
In diesem Beispiel wird die in der Datei "Hello.vb" definierte VBFromFile-Klasse mit dem Cmdlet "Add-Type" der aktuellen Sitzung hinzugefügt. In der Befehlsausgabe wird der Text der Datei "Hello.vb" angezeigt.

Im ersten Befehl wird der in der Datei "Hello.vb" definierte Typ mit dem Cmdlet "Add-Type" der aktuellen Sitzung hinzugefügt. Der Befehl gibt die Quelldatei mithilfe des Path-Parameters an. 

Im zweiten Befehl wird die SayHello-Funktion als statische Methode der VBFromFile-Klasse aufgerufen.

Beispiel 5

C:\PS>$signature = @"
[DllImport("user32.dll")]
public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
"@

$showWindowAsync = Add-Type -memberDefinition $signature -name "Win32ShowWindowAsync" -namespace Win32Functions -passThru

# Minimize the Windows PowerShell console
$showWindowAsync::ShowWindowAsync((Get-Process -id $pid).MainWindowHandle, 2) 

# Restore it
$showWindowAsync::ShowWindowAsync((Get-Process -id $pid).MainWindowHandle, 4)

Beschreibung
-----------
Die Befehle in diesem Beispiel veranschaulichen, wie in Windows PowerShell systemeigene Windows-APIs aufgerufen werden. Add-Type verwendet den Plattformaufrufmechanismus (P/Invoke) zum Aufrufen einer Funktion in "User32.dll" von Windows PowerShell.

Im ersten Befehl wird die C#-Signatur der ShowWindowAsync-Funktion in der Variablen "$signature" gespeichert. (Weitere Informationen finden Sie unter "ShowWindowAsync-Funktion" in der MSDN Library unter "https://go.microsoft.com/fwlink/?LinkId=143643", möglicherweise auf Englisch.) Um sicherzustellen, dass die resultierende Methode in einer Windows PowerShell-Sitzung sichtbar ist, wurde der Standardsignatur das public-Schlüsselwort hinzugefügt.

Im zweiten Befehl wird das Cmdlet "Add-Type" verwendet, um der Windows PowerShell-Sitzung die ShowWindowAsync-Funktion als statische Methode einer Klasse hinzuzufügen, die von Add-Type erstellt wird. Im Befehl wird die in der Variablen "$signature" gespeicherte Methodendefinition mit dem MemberDefinition-Parameter angegeben.
 
Der Befehl gibt einen Namen und einen Namespace für die Klasse mithilfe des Name-Parameters bzw. des Namespace-Parameters an. Mit dem PassThru-Parameter wird ein Objekt generiert, das die Typen darstellt, und das Objekt wird in der Variablen "$showWindowAsync" gespeichert.

Im dritten und vierten Befehl wird die neue statische ShowWindowAsync-Methode verwendet. Die Methode akzeptiert zwei Parameter sowie das Fensterhandle, und eine ganze Zahl gibt an, wie das Fenster angezeigt werden soll.

Im dritten Befehl wird ShowWindowAsync aufgerufen. Das Cmdlet "Get-Process" wird mit der automatischen Variablen "$pid" verwendet, um den Prozess abzurufen, der die aktuelle Windows PowerShell-Sitzung hostet. Anschließend werden die MainWindowHandle-Eigenschaft des aktuellen Prozesses und der Wert "2" verwendet, der den SW_MINIMIZE-Wert darstellt.

Um das Fenster wiederherzustellen, wird im vierten Befehl der Wert "4" für die Fensterposition verwendet, der den SW_RESTORE-Wert darstellt. (SW_MAXIMIZE entspricht 3.)

Beispiel 6

C:\PS>Add-Type -MemberDefinition $jsMethod -Name "PrintInfo" -Language JScript

Beschreibung
-----------
In diesem Befehl wird eine Methode aus JScript-Inlinecode mit dem Cmdlet "Add-Type" der Windows PowerShell-Sitzung hinzugefügt. Mit dem MemberDefinition-Parameter wird in der Variablen "$jsMethod" gespeicherter Quellcode gesendet. Mit der Variablen "Name" wird ein Name für die Klasse angegeben, die Add-Type für die Methode erstellt, und mit dem Language-Parameter wird die Programmiersprache JScript angegeben.

Beispiel 7

C:\PS>Add-Type -Path FSharp.Compiler.CodeDom.dll


C:\PS> Add-Type -Path FSharp.Compiler.CodeDom.dll
C:\PS> $provider = New-Object Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider

C:\PS> $fSharpCode = @" 
let rec loop n = 
if n <= 0 then () else begin
print_endline (string_of_int n);
loop (n-1)
end
"@

C:\PS> $fsharpType = Add-Type -TypeDefinition $fSharpCode -CodeDomProvider $provider -PassThru | where { $_.IsPublic }
C:\PS> $fsharpType::loop(4)
4
3
2
1

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie der Windows PowerShell-Sitzung mit dem Cmdlet "Add-Type" ein FSharp-Codecompiler hinzugefügt wird. Zum Ausführen dieses Beispiels in Windows PowerShell benötigen Sie die Datei "FSharp.Compiler.CodeDom.dll" die mit der Programmiersprache FSharp installiert wird.

Im ersten Befehl des Beispiels wird das Cmdlet "Add-Type" mit dem Path-Parameter verwendet, um eine Assembly anzugeben. Add-Type ruft die Typen in der Assembly ab.

Im zweiten Befehl wird eine Instanz des FSharp-Codeanbieters mit dem Cmdlet "New-Object" erstellt, und das Ergebnis wird in der Variablen "$provider" gespeichert.

Im dritten Befehl wird der FSharp-Code, der die Loop-Methode definiert, in der Variablen "$FSharpCode" gespeichert.

Im vierten Befehl werden die in $fSharpCode definierten öffentlichen Typen mit dem Cmdlet "Add-Type" in der Variablen "$fSharpType" gespeichert. Der TypeDefinition-Parameter gibt den Quellcode an, der die Typen definiert. Der CodeDomProvider-Parameter gibt den Quellcodecompiler an. 

Der PassThru-Parameter legt fest, dass Add-Type ein Runtime-Objekt zurückgibt, das die Typen darstellt, und mit dem Pipelineoperator (|) wird das Runtime-Objekt an das Cmdlet "Where-Object" gesendet, das nur die öffentlichen Typen zurückgibt. Da der FSharp-Anbieter nicht öffentliche Typen generiert, wird der Filter "Where-Object" verwendet, um den resultierenden öffentlichen Typ zu unterstützen.

Im fünften Befehl wird die Loop-Methode als statische Methode des in der Variablen "$fSharpType" gespeicherten Typs aufgerufen.

Siehe auch

Konzepte

Add-Member
New-Object

Freigeben über