Add-Type

Riferimento

Modulo:: Microsoft.PowerShell.Utility

Aggiunge una classe Microsoft .NET a una sessione di PowerShell.

Sintassi

Add-Type
   [-TypeDefinition] <String>
   [-Language <Language>]
   [-ReferencedAssemblies <String[]>]
   [-OutputAssembly <String>]
   [-OutputType <OutputAssemblyType>]
   [-PassThru]
   [-IgnoreWarnings]
   [-CompilerOptions <String[]>]
   [<CommonParameters>]

Add-Type
   [-Name] <String>
   [-MemberDefinition] <String[]>
   [-Namespace <String>]
   [-UsingNamespace <String[]>]
   [-Language <Language>]
   [-ReferencedAssemblies <String[]>]
   [-OutputAssembly <String>]
   [-OutputType <OutputAssemblyType>]
   [-PassThru]
   [-IgnoreWarnings]
   [-CompilerOptions <String[]>]
   [<CommonParameters>]

Add-Type
   [-Path] <String[]>
   [-ReferencedAssemblies <String[]>]
   [-OutputAssembly <String>]
   [-OutputType <OutputAssemblyType>]
   [-PassThru]
   [-IgnoreWarnings]
   [-CompilerOptions <String[]>]
   [<CommonParameters>]

Add-Type
   -LiteralPath <String[]>
   [-ReferencedAssemblies <String[]>]
   [-OutputAssembly <String>]
   [-OutputType <OutputAssemblyType>]
   [-PassThru]
   [-IgnoreWarnings]
   [-CompilerOptions <String[]>]
   [<CommonParameters>]

Add-Type
   -AssemblyName <String[]>
   [-PassThru]
   [<CommonParameters>]

Descrizione

Il cmdlet Add-Type consente di definire una classe Microsoft .NET Core nella sessione di PowerShell. È quindi possibile creare un'istanza degli oggetti usando il cmdlet New-Object e usare gli oggetti esattamente come si userebbe qualsiasi oggetto .NET Core. Se si aggiunge un comando Add-Type al profilo di PowerShell, la classe è disponibile in tutte le sessioni di PowerShell.

È possibile specificare il tipo specificando un assembly o file di codice sorgente esistenti oppure specificare il codice sorgente inline o salvato in una variabile. È anche possibile specificare solo un metodo e Add-Type definisce e genera la classe . In Windows è possibile usare questa funzionalità per effettuare chiamate Platform Invoke (P/Invoke) a funzioni non gestite in PowerShell. Se si specifica il codice sorgente, Add-Type compila il codice sorgente specificato e genera un assembly in memoria contenente i nuovi tipi .NET Core.

È possibile usare i parametri di Add-Type per specificare un linguaggio e un compilatore alternativi, C# è l'impostazione predefinita, le opzioni del compilatore, le dipendenze dell'assembly, lo spazio dei nomi della classe, i nomi del tipo e l'assembly risultante.

A partire da PowerShell 7, Add-Type non compila un tipo se esiste già un tipo con lo stesso nome. Inoltre, Add-Type cerca gli assembly in una cartella ref nella cartella che contiene pwsh.dll.

Esempio

Esempio 1: Aggiungere un tipo .NET a una sessione

In questo esempio viene aggiunta la classe BasicTest alla sessione specificando il codice sorgente archiviato in una variabile. La classe BasicTest viene usata per aggiungere numeri interi, creare un oggetto e moltiplicare i numeri interi.

$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);
    }
}
"@

Add-Type -TypeDefinition $Source
[BasicTest]::Add(4, 3)
$BasicTestObject = New-Object BasicTest
$BasicTestObject.Multiply(5, 2)

La variabile $Source archivia il codice sorgente per la classe . Il tipo ha un metodo statico denominato Add e un metodo non statico denominato Multiply.

Il cmdlet Add-Type aggiunge la classe alla sessione. Poiché usa codice sorgente inline, il comando usa il parametro TypeDefinition per specificare il codice nella variabile $Source.

Il metodo statico Add della classe BasicTest utilizza i caratteri a due punti (::) per specificare un membro statico della classe . I numeri interi vengono aggiunti e viene visualizzata la somma.

Il cmdlet New-Object crea un'istanza della classe BasicTest. Salva il nuovo oggetto nella variabile $BasicTestObject.

$BasicTestObject usa il metodo Multiply. I numeri interi vengono moltiplicati e il prodotto viene visualizzato.

Esempio 2: Esaminare un tipo aggiunto

In questo esempio viene utilizzato il cmdlet Get-Member per esaminare gli oggetti creati nei cmdlet Add-Type e New-Object creati nell'esempio 1 di esempio 1.

[BasicTest] | Get-Member

TypeName: System.RuntimeType

Name                 MemberType Definition
----                 ---------- ----------
AsType               Method     type AsType()
Clone                Method     System.Object Clone(), System.Object ICloneable.Clone()
Equals               Method     bool Equals(System.Object obj), bool Equals(type o)
FindInterfaces       Method     type[] FindInterfaces(System.Reflection.TypeFilter filter...
...

[BasicTest] | Get-Member -Static

TypeName: BasicTest

Name            MemberType Definition
----            ---------- ----------
Add             Method     static int Add(int a, int b)
Equals          Method     static bool Equals(System.Object objA, System.Object objB)
new             Method     BasicTest new()
ReferenceEquals Method     static bool ReferenceEquals(System.Object objA, System.Object objB)

$BasicTestObject | Get-Member

TypeName: BasicTest

Name        MemberType Definition
----        ---------- ----------
Equals      Method     bool Equals(System.Object obj)
GetHashCode Method     int GetHashCode()
GetType     Method     type GetType()
Multiply    Method     int Multiply(int a, int b)
ToString    Method     string ToString()

Il cmdlet Get-Member ottiene il tipo e i membri della classe BasicTest che Add-Type aggiunta alla sessione. Il comando Get-Member rivela che si tratta di un oggetto System.RuntimeType, derivato dalla classe System.Object.

Il parametro Get-Memberstatic ottiene le proprietà statiche e i metodi della classe BasicTest. L'output mostra che il metodo Add è incluso.

Il cmdlet Get-Member ottiene i membri dell'oggetto archiviato nella variabile $BasicTestObject. $BasicTestObject è stato creato usando il cmdlet New-Object con la classe BasicTest. L'output rivela che il valore della variabile $BasicTestObject è un'istanza della classe BasicTest e che include un membro denominato Multiply.

Esempio 3: Aggiungere tipi da un assembly

In questo esempio vengono aggiunte le classi dall'assembly JsonSchema.NET.dll alla sessione corrente.

Set-Location -Path $PSHOME
$AccType = Add-Type -AssemblyName *jsonschema* -PassThru

Set-Location usa il parametro Path per specificare la variabile $PSHOME. La variabile fa riferimento alla directory di installazione di PowerShell in cui si trova il file DLL.

La variabile $AccType archivia un oggetto creato con il cmdlet Add-Type. Add-Type usa il parametro AssemblyName per specificare il nome dell'assembly. Il carattere jolly asterisco (*) consente di ottenere l'assembly corretto anche quando non si è certi del nome o del relativo ortografia. Il parametro PassThru genera oggetti che rappresentano le classi aggiunte alla sessione.

Esempio 4: Chiamare API Di Windows native

In questo esempio viene illustrato come chiamare API Windows native in PowerShell. Add-Type usa il meccanismo Platform Invoke (P/Invoke) per chiamare una funzione in User32.dll da PowerShell. Questo esempio funziona solo nei computer che eseguono il sistema operativo Windows.

$Signature = @"
[DllImport("user32.dll")]public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
"@

$addTypeSplat = @{
    MemberDefinition = $Signature
    Name = "Win32ShowWindowAsync"
    Namespace = 'Win32Functions'
    PassThru = $true
}
$ShowWindowAsync = Add-Type @addTypeSplat

# Minimize the PowerShell console

$ShowWindowAsync::ShowWindowAsync((Get-Process -Id $PID).MainWindowHandle, 2)

# Restore the PowerShell console

$ShowWindowAsync::ShowWindowAsync((Get-Process -Id $PID).MainWindowHandle, 4)

La variabile $Signature archivia la firma C# della funzione ShowWindowAsync. Per assicurarsi che il metodo risultante sia visibile in una sessione di PowerShell, la parola chiave public è stata aggiunta alla firma standard. Per altre informazioni, vedere funzione ShowWindowAsync.

La variabile $ShowWindowAsync archivia l'oggetto creato dal parametroPassThru Add-Type. Il cmdlet Add-Type aggiunge la funzione ShowWindowAsync alla sessione di PowerShell come metodo statico. Il comando usa il parametro MemberDefinition per specificare la definizione del metodo salvata nella variabile $Signature. Il comando usa i parametri name e namespace per specificare un nome e uno spazio dei nomi per la classe. Il parametro PassThru genera un oggetto che rappresenta i tipi.

Il nuovo metodo statico ShowWindowAsync viene usato nei comandi per ridurre al minimo e ripristinare la console di PowerShell. Il metodo accetta due parametri: l'handle della finestra e un numero intero che specifica la modalità di visualizzazione della finestra.

Per ridurre al minimo la console di PowerShell, ShowWindowAsync usa il cmdlet Get-Process con la variabile automatica $PID per ottenere il processo che ospita la sessione di PowerShell corrente. Usa quindi la proprietà MainWindowHandle del processo corrente e un valore di 2, che rappresenta il valore SW_MINIMIZE.

Per ripristinare la finestra, ShowWindowAsync usa un valore di 4 per la posizione della finestra, che rappresenta il valore SW_RESTORE.

Per ingrandire la finestra, usare il valore di 3 che rappresenta SW_MAXIMIZE.

Parametri

-AssemblyName

Specifica il nome di un assembly che include i tipi. Add-Type accetta i tipi dall'assembly specificato. Questo parametro è obbligatorio quando si creano tipi in base a un nome di assembly.

Immettere il nome completo o semplice, noto anche come nome parziale, di un assembly. I caratteri jolly sono consentiti nel nome dell'assembly. Se si immette un nome semplice o parziale, Add-Type lo risolve con il nome completo e quindi usa il nome completo per caricare l'assembly.

L'uso dei parametri Path o LiteralPath garantisce il caricamento dell'assembly da caricare. Quando si usa il parametro AssemblyName, PowerShell chiede a .NET di risolvere il nome dell'assembly usando il processo standard di risoluzione degli assembly .NET. Poiché .NET cerca prima la cartella dell'applicazione, Add-Type potrebbe caricare un assembly da $PSHOME anziché dalla versione nella cartella corrente. Per altre informazioni, vedere Percorso assembly.

Se .NET non riesce a risolvere il nome, PowerShell cerca nel percorso corrente per trovare l'assembly. Quando si usano caratteri jolly nel parametro AssemblyName, il processo di risoluzione dell'assembly .NET non riesce causando l'individuazione di PowerShell nella posizione corrente.

Tipo:	String[]
Alias:	AN
Posizione:	Named
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	True

-CompilerOptions

Specifica le opzioni per il compilatore di codice sorgente. Queste opzioni vengono inviate al compilatore senza revisione.

Questo parametro consente di indirizzare il compilatore a generare un file eseguibile, incorporare risorse o impostare le opzioni della riga di comando, ad esempio l'opzione /unsafe.

Tipo:	String[]
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-IgnoreWarnings

Ignora gli avvisi del compilatore. Usare questo parametro per impedire Add-Type di gestire gli avvisi del compilatore come errori.

Tipo:	SwitchParameter
Posizione:	Named
Valore predefinito:	False
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Language

Specifica il linguaggio usato nel codice sorgente. Il valore accettabile per questo parametro è CSharp.

Tipo:	Language
Valori accettati:	CSharp
Posizione:	Named
Valore predefinito:	CSharp
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-LiteralPath

Specifica il percorso dei file del codice sorgente o dei file DLL di assembly che contengono i tipi . A differenza di Path, il valore del parametro LiteralPath viene usato esattamente come viene digitato. Nessun carattere viene interpretato come caratteri jolly. Se il percorso include caratteri di escape, racchiuderlo tra virgolette singole. Le virgolette singole indicano a PowerShell di non interpretare alcun carattere come sequenze di escape.

L'uso dei parametri Path o LiteralPath garantisce il caricamento dell'assembly da caricare.

Tipo:	String[]
Alias:	PSPath, LP
Posizione:	Named
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-MemberDefinition

Specifica nuove proprietà o metodi per la classe . Add-Type genera il codice del modello necessario per supportare le proprietà o i metodi.

In Windows è possibile usare questa funzionalità per effettuare chiamate Platform Invoke (P/Invoke) a funzioni non gestite in PowerShell.

Tipo:	String[]
Posizione:	1
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Name

Specifica il nome della classe da creare. Questo parametro è obbligatorio quando si genera un tipo da una definizione di membro.

Il nome del tipo e lo spazio dei nomi devono essere univoci all'interno di una sessione. Non è possibile scaricare un tipo o modificarlo. Per modificare il codice per un tipo, è necessario modificare il nome o avviare una nuova sessione di PowerShell. In caso contrario, il comando ha esito negativo.

Tipo:	String
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Namespace

Per impostazione predefinita, questo comando crea il tipo nello spazio dei nomi Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes. Quando si usa questo parametro, il tipo viene creato nello spazio dei nomi specificato. Se il valore è una stringa vuota, il tipo viene creato nello spazio dei nomi globale.

Tipo:	String
Alias:	NS
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-OutputAssembly

Genera un file DLL per l'assembly con il nome specificato nel percorso. Immettere un percorso e un nome file facoltativi. Sono consentiti caratteri jolly. Per impostazione predefinita, Add-Type genera l'assembly solo in memoria. Se si restituisce l'assembly in un file, è necessario includere il parametro PassThru per restituire il tipo dall'assembly appena creato.

Tipo:	String
Alias:	OA
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	True

-OutputType

Specifica il tipo di output dell'assembly di output. Per impostazione predefinita, non viene specificato alcun tipo di output. Questo parametro è valido solo quando viene specificato un assembly di output nel comando . Per altre informazioni sui valori, vedere 'enumerazione OutputAssemblyType.

I valori accettabili per questo parametro sono i seguenti:

ConsoleApplication
Library
WindowsApplication

Importante

A partire da PowerShell 7.1, ConsoleApplication e WindowsApplication non sono supportati e PowerShell genera un errore irreversibile se uno dei due è specificato come valori per il parametro OutputType.

Tipo:	OutputAssemblyType
Alias:	OT
Valori accettati:	ConsoleApplication, Library, WindowsApplication
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-PassThru

Restituisce un oggetto System.Runtime che rappresenta i tipi aggiunti. Per impostazione predefinita, questo cmdlet non genera alcun output. Usare questo parametro se è stato usato OutputAssembly per creare un file DLL e si vuole restituire il tipo dall'assembly appena creato.

Tipo:	SwitchParameter
Posizione:	Named
Valore predefinito:	False
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Path

Specifica il percorso dei file del codice sorgente o dei file DLL di assembly che contengono i tipi .

Se si inviano file di codice sorgente, Add-Type compila il codice nei file e crea un assembly in memoria dei tipi. L'estensione di file specificata nel valore di Percorso determina il compilatore usato Add-Type.

L'uso dei parametri Path o LiteralPath garantisce il caricamento dell'assembly da caricare.

Tipo:	String[]
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-ReferencedAssemblies

Specifica gli assembly da cui dipende il tipo. Per impostazione predefinita, Add-Type fa riferimento System.dll e System.Management.Automation.dll. A partire da PowerShell 6, ReferencedAssemblies non include gli assembly .NET predefiniti. È necessario includere un riferimento specifico al parametro nel valore passato a questo parametro.

Tipo:	String[]
Alias:	RA
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-TypeDefinition

Specifica il codice sorgente che contiene le definizioni dei tipi. Immettere il codice sorgente in una stringa o in una stringa qui oppure immettere una variabile contenente il codice sorgente. Per altre informazioni sulle stringhe qui, vedere about_Quoting_Rules.

Includere una dichiarazione dello spazio dei nomi nella definizione del tipo. Se si omette la dichiarazione dello spazio dei nomi, il tipo potrebbe avere lo stesso nome di un altro tipo o il collegamento per un altro tipo, causando una sovrascrittura involontaria. Ad esempio, se si definisce un tipo denominato Exception, gli script che usano Exception come collegamento per System.Exception avranno esito negativo.

Tipo:	String
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-UsingNamespace

Specifica altri spazi dei nomi necessari per la classe . Questo è molto simile alla parola chiave C#, Using.

Per impostazione predefinita, Add-Type fa riferimento allo spazio dei nomi system. Quando si usa il parametro MemberDefinition, Add-Type fa riferimento allo spazio dei nomi System.Runtime.InteropServices per impostazione predefinita. Gli spazi dei nomi aggiunti tramite il parametro using UsingNamespace vengono a cui viene fatto riferimento oltre agli spazi dei nomi predefiniti.

Tipo:	String[]
Alias:	Using
Posizione:	Named
Valore predefinito:	System namespace
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

Input

None

Non è possibile inviare tramite pipe oggetti a questo cmdlet.

Output

None

Per impostazione predefinita, questo cmdlet non restituisce alcun output.

Type

Quando si utilizza il parametro PassThru, questo cmdlet restituisce un oggetto System.Type che rappresenta il nuovo tipo.

Note

I tipi aggiunti esistono solo nella sessione corrente. Per usare i tipi in tutte le sessioni, aggiungerli al profilo di PowerShell. Per altre informazioni sul profilo, vedere about_Profiles.

I nomi dei tipi e gli spazi dei nomi devono essere univoci all'interno di una sessione. Non è possibile scaricare un tipo o modificarlo. Se è necessario modificare il codice per un tipo, è necessario modificare il nome o avviare una nuova sessione di PowerShell. In caso contrario, il comando ha esito negativo.

In Windows PowerShell (versione 5.1 e successive) è necessario usare Add-Type per qualsiasi elemento non già caricato. In genere, questo vale per gli assembly presenti nella Global Assembly Cache (GAC). In PowerShell 6 e versioni successive non esiste alcuna gac, quindi PowerShell installa i propri assembly in $PSHOME. Questi assembly vengono caricati automaticamente su richiesta, quindi non è necessario usare Add-Type per caricarli. Tuttavia, l'uso di Add-Type è ancora consentito per consentire la compatibilità implicita degli script con qualsiasi versione di PowerShell.

Gli assembly nella GAC possono essere caricati in base al nome del tipo, anziché in base al percorso. Il caricamento di assembly da un percorso arbitrario richiede Add-Type, perché tali assembly non possono essere caricati automaticamente.

Condividi tramite

Add-Type

Sintassi

Descrizione

Esempio

Esempio 1: Aggiungere un tipo .NET a una sessione

Esempio 2: Esaminare un tipo aggiunto

Esempio 3: Aggiungere tipi da un assembly

Esempio 4: Chiamare API Di Windows native

Parametri

-AssemblyName

-CompilerOptions

-IgnoreWarnings

-Language

-LiteralPath

-MemberDefinition

-Name

-Namespace

-OutputAssembly

-OutputType

-PassThru

-Path

-ReferencedAssemblies

-TypeDefinition

-UsingNamespace

Input

Output

Note

Collegamenti correlati

Commenti e suggerimenti