Add-Type

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

Add-Type [-Name] <string> [-MemberDefinition] <string[]> [-CodeDomProvider <CodeDomProvider>] [-CompilerParameters <CompilerParameters>] [-Linguaggio {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-Spazio dei nomi <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>] [-Linguaggio {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

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)

Descrizione
-----------
Con questi comandi la classe BasicTest viene aggiunta alla sessione specificando il codice sorgente archiviato in una variabile. Il tipo dispone di un metodo statico denominato Add e di un metodo non statico denominato Multiply.

Con il primo comando viene archiviato il codice sorgente per la classe nella variabile $source.

Nel secondo comando viene utilizzato il cmdlet Add-Type per aggiungere la classe alla sessione. Poiché viene utilizzato il codice sorgente inline, nel comando viene utilizzato il parametro TypeDefinition per specificare il codice nella variabile $source.

Nei comandi restanti viene utilizzata la nuova classe.

Con il terzo comando viene chiamato il metodo statico Add della classe BasicTest. Vengono utilizzati i caratteri dei doppi due punti (::) per specificare un membro statico della classe.

Il quarto comando utilizza il cmdlet New-Object per creare un'istanza della classe BasicTest. Il nuovo oggetto viene salvato nella variabile $basicTestObject. 

Nel quinto comando viene utilizzato il metodo Multiply di $basicTestObject.

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

Descrizione
-----------
In questi comandi viene utilizzato il cmdlet Get-Member per esaminare gli oggetti creati mediante i cmdlet Add-Type e New-Object nell'esempio precedente.

Il primo comando utilizza il cmdlet Get-Member per ottenere il tipo e i membri della classe BasicTest aggiunta alla sessione mediante Add-Type. Il comando Get-Member consente di sapere che si tratta di un oggetto System.RuntimeType, derivato dalla classe System.Object.

Nel secondo comando viene utilizzato il parametro Static di Get-Member per ottenere i metodi e le proprietà statiche della classe BasicTest. L'output indica che il metodo Add è incluso.

Nel terzo comando viene utilizzato Get-Member per ottenere i membri dell'oggetto archiviato nella variabile $BasicTestObject. Si tratta dell'istanza dell'oggetto creata mediante il cmdlet New-Object con la classe $BasicType. 

L'output indica che il valore della variabile $basicTestObject è un'istanza della classe BasicTest e che include un membro denominato Multiply.

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

Descrizione
-----------
Con questo comando le classi dell'assembly Accessibility vengono aggiunte alla sessione corrente. Viene utilizzato il parametro AssemblyName per specificare il nome dell'assembly. Il carattere jolly consente di ottenere l'assembly corretto, anche quando non si è sicuri del nome o dell'ortografia.

Nel comando viene utilizzato il parametro PassThru per generare oggetti che rappresentano le classi aggiunte alla sessione e gli oggetti vengono salvati nella variabile $accType.

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

Descrizione
-----------
In questo esempio viene utilizzato il cmdlet Add-Type per aggiungere alla sessione corrente la classe VBFromFile definita nel file Hello.vb. Il testo del file Hello.vb viene visualizzato nell'output dei comandi.

Il primo comando utilizza il cmdlet Add-Type per aggiungere alla sessione corrente il tipo definito nel file Hello.vb. Viene utilizzato il parametro path per specificare il file di origine. 

Nel secondo comando viene chiamata la funzione SayHello come metodo statico della classe VBFromFile.

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)

Descrizione
-----------
Con i comandi di questo esempio viene illustrato come chiamare le API Windows native in Windows PowerShell. In Add-Type viene utilizzato il meccanismo P/Invoke (Platform Invoke) per chiamare una funzione in User32.dll da Windows PowerShell.

Il primo comando archivia la firma C# della funzione ShowWindowAsync nella variabile $signature. Per ulteriori informazioni, vedere l'articolo relativo alla funzione ShowWindowAsync in MSDN Library all'indirizzo  (le informazioni potrebbero essere in lingua inglese). Per assicurarsi che il metodo risultante sia visibile in una sessione di Windows PowerShell, la parola chiave "public" è stata aggiunta alla firma standard.

Nel secondo comando viene utilizzato il cmdlet Add-Type per aggiungere la funzione ShowWindowAsync alla sessione di Windows PowerShell come metodo statico di una classe creata da Add-Type. Viene utilizzato il parametro MemberDefinition per specificare la definizione del metodo salvata nella variabile $signature.
 
Nel comando vengono utilizzati i parametri Name e Namespace per specificare un nome e uno spazio dei nomi per la classe e il parametro PassThru per generare un oggetto che rappresenta i tipi e l'oggetto viene salvato nella variabile $showWindowAsync.

Nel terzo e nel quarto comando viene utilizzato il nuovo metodo statico ShowWindowAsync. Il metodo accetta due parametri, l'handle della finestra e un numero intero che specifica come visualizzare la finestra.

Il terzo comando chiama ShowWindowAsync. Utilizza il cmdlet Get-Process con la variabile automatica $pid per ottenere il processo che ospita la sessione corrente di Windows PowerShell. Utilizza quindi la proprietà MainWindowHandle del processo corrente e il valore 2 che rappresenta il valore SW_MINIMIZE.

Per ripristinare la finestra, nel quarto comando viene utilizzato il valore 4 per la posizione della finestra che rappresenta il valore SW_RESTORE. (SW_MAXIMIZE è 3).

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

Descrizione
-----------
In questo comando viene utilizzato il cmdlet Add-Type per aggiungere un metodo dal codice JScript inline alla sessione di Windows PowerShell. Viene utilizzato il parametro MemberDefinition per inviare il codice sorgente archiviato nella variabile $jsMethod. Viene utilizzata la variabile Name per specificare un nome per la classe creata da Add-Type per il metodo e il parametro Language per specificare il linguaggio JScript.

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

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il cmdlet Add-Type per aggiungere un compilatore di codice FSharp alla sessione di Windows PowerShell. Per eseguire questo esempio in Windows PowerShell, è necessario disporre di FSharp.Compiler.CodeDom.dll, che viene installato con il linguaggio FSharp.

Nel primo comando dell'esempio viene utilizzato il cmdlet Add-Type con il parametro Path per specificare un assembly. Add-Type ottiene i tipi nell'assembly.

Nel secondo comando viene utilizzato il cmdlet New-Object per creare un'istanza del provider del codice FSharp e il risultato viene salvato nella variabile $provider.

Nel terzo comando viene salvato il codice FSharp che definisce il metodo Loop nella variabile $FSharpCode.

Nel quarto comando viene utilizzato il cmdlet Add-Type per salvare i tipi pubblici definiti in $fSharpCode nella variabile $fSharpType. Il parametro TypeDefinition specifica il codice sorgente che definisce i tipi. Il parametro CodeDomProvider specifica il compilatore del codice sorgente. 

Con il parametro PassThru viene indicato a Add-Type di restituire un oggetto Runtime che rappresenta i tipi e un operatore pipeline (|) invia l'oggetto Runtime al cmdlet Where-Object che restituisce solo i tipi pubblici. Viene utilizzato il filtro Where-Object perché il provider FSharp genera tipi non pubblici per supportare il tipo pubblico risultante.

Il quinto comando chiama il metodo Loop come metodo statico del tipo archiviato nella variabile $fSharpType.