Add-Type

Riferimento

Modulo:: Microsoft.PowerShell.Utility

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

Sintassi

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

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

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

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

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

Descrizione

Il Add-Type cmdlet consente di definire una classe Microsoft .NET Framework nella sessione di PowerShell. È quindi possibile creare un'istanza di oggetti usando il New-Object cmdlet e usare gli oggetti esattamente come si userebbe qualsiasi oggetto .NET Framework. Se si aggiunge un Add-Type comando 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 o possibile specificare il codice sorgente inline o salvato in una variabile. È anche possibile specificare solo un metodo e Add-Type definire e generare 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 di .NET Framework.

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

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 $Source variabile archivia il codice sorgente per la classe . Il tipo ha un metodo statico denominato Add e un metodo non statico denominato Multiply.

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

Il Add metodo statico 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 New-Object cmdlet crea un'istanza della classe BasicTest . Salva il nuovo oggetto nella $BasicTestObject variabile .

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

Esempio 2: Esaminare un tipo aggiunto

In questo esempio viene usato il Get-Member cmdlet per esaminare gli oggetti creati dai cmdlet e New-Object nell'esempio Add-Type 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 Get-Member cmdlet ottiene il tipo e i membri della classe BasicTest che Add-Type ha aggiunto alla sessione. Il Get-Member comando rivela che si tratta di un oggetto System.RuntimeType derivato dalla classe System.Object .

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

Il Get-Member cmdlet ottiene i membri dell'oggetto archiviato nella $BasicTestObject variabile . $BasicTestObject è stato creato usando il New-Object cmdlet con la classe BasicTest . L'output rivela che il valore della variabile è un'istanza della $BasicTestObject 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 Accessibility.dll alla sessione corrente.

$AccType = Add-Type -AssemblyName "accessib*" -PassThru

La $AccType variabile archivia un oggetto creato con il Add-Type cmdlet . Add-Type utilizza 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 $Signature variabile archivia la firma C# della ShowWindowAsync funzione. Per assicurarsi che il metodo risultante sia visibile in una sessione di PowerShell, la public parola chiave è stata aggiunta alla firma standard. Per altre informazioni, vedere Funzione ShowWindowAsync .

La $ShowWindowAsync variabile archivia l'oggetto creato dal Add-Type parametro PassThru . Il Add-Type cmdlet aggiunge la ShowWindowAsync funzione alla sessione di PowerShell come metodo statico. Il comando usa il parametro MemberDefinition per specificare la definizione del metodo salvata nella $Signature variabile . 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 ShowWindowAsync metodo statico 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 Get-Process cmdlet con la $PID variabile automatica per ottenere il processo che ospita la sessione di PowerShell corrente. Usa quindi la proprietà MainWindowHandle del processo corrente e il valore 2, che rappresenta il SW_MINIMIZE valore .

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

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

Esempio 5: Aggiungere un tipo da un file di Visual Basic

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

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

Hello, World

Add-Type usa il parametro Path per specificare il file di origine, Hello.vbe aggiunge il tipo definito nel file. La SayHello funzione viene chiamata come metodo statico della classe VBFromFile .

Esempio 6: Aggiungere una classe con JScript.NET

Questo esempio usa JScript.NET per creare una nuova classe, FRectangle, nella sessione di PowerShell.

Add-Type @'
 class FRectangle {
   var Length : double;
   var Height : double;
   function Perimeter() : double {
       return (Length + Height) * 2; }
   function Area() : double {
       return Length * Height;  } }
'@ -Language JScript

$rect = [FRectangle]::new()
$rect

Length Height
------ ------
     0      0

Esempio 7: Aggiungere un compilatore F#

Questo esempio illustra come usare il Add-Type cmdlet per aggiungere un compilatore di codice F# alla sessione di PowerShell. Per eseguire questo esempio in PowerShell, è necessario che sia FSharp.Compiler.CodeDom.dll installato con il linguaggio F#.

Add-Type -Path "FSharp.Compiler.CodeDom.dll"
$Provider = New-Object Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider
$FSharpCode = @"
let rec loop n =if n <= 0 then () else beginprint_endline (string_of_int n);loop (n-1)end
"@
$FSharpType = Add-Type -TypeDefinition $FSharpCode -CodeDomProvider $Provider -PassThru |
   Where-Object { $_.IsPublic }
$FSharpType::loop(4)

4
3
2
1

Add-Type usa il parametro Path per specificare un assembly e ottiene i tipi nell'assembly. New-Object crea un'istanza del provider di codice F# e salva il risultato nella $Provider variabile. La $FSharpCode variabile salva il codice F# che definisce il metodo Loop .

La $FSharpType variabile archivia i risultati del Add-Type cmdlet che salva i tipi pubblici definiti in $FSharpCode. Il parametro TypeDefinition specifica il codice sorgente che definisce i tipi. Il parametro CodeDomProvider specifica il compilatore del codice sorgente. Il parametro PassThru indica Add-Type di restituire un oggetto Runtime che rappresenta i tipi. Gli oggetti vengono inviati alla pipeline al Where-Object cmdlet , che restituisce solo i tipi pubblici. Il Where-Object cmdlet viene usato perché il provider F# genera tipi non pubblici per supportare il tipo pubblico risultante.

Il metodo Loop viene chiamato come metodo statico del tipo archiviato nella $FSharpType variabile.

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. Nel nome dell'assembly sono consentiti i caratteri jolly. Se si immette un nome semplice o parziale, Add-Type lo risolve nel 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 di risoluzione dell'assembly .NET standard. 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

-CodeDomProvider

Specifica un generatore di codice o un compilatore. Add-Type usa il compilatore specificato per compilare il codice sorgente. Il valore predefinito è il compilatore C#. Usare questo parametro se si usa una lingua che non può essere specificata usando il parametro Language . CodeDomProvider specificato deve essere in grado di generare assembly dal codice sorgente.

Tipo:	CodeDomProvider
Alias:	Provider
Posizione:	Named
Valore predefinito:	C# compiler
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-CompilerParameters

Specifica le opzioni per il compilatore del 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 . Questo parametro implementa la classe CompilerParameters System.CodeDom.Compiler.CompilerParameters.

Non è possibile usare i parametri CompilerParameters e ReferencedAssemblies nello stesso comando.

Tipo:	CompilerParameters
Alias:	CP
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 la gestione degli 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 Add-Type cmdlet usa il valore di questo parametro per selezionare il CodeDomProvider appropriato. CSharp è il valore predefinito. I valori accettabili per questo parametro sono i seguenti:

CSharp
CSharpVersion2
CSharpVersion3
JScript
VisualBasic

Tipo:	Language
Valori accettati:	CSharp, CSharpVersion2, CSharpVersion3, JScript, VisualBasic
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 dell'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 carattere 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
Posizione:	Named
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-MemberDefinition

Specifica nuovi metodi o proprietà 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 durante la generazione di un tipo da una definizione del 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 non riesce.

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

-Namespace

Specifica uno spazio dei nomi per il tipo.

Se questo parametro non è incluso nel comando, il tipo viene creato nello spazio dei nomi Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes . Se il parametro è incluso nel comando con un valore stringa vuoto o un valore di $Null, il tipo viene generato 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. I caratteri jolly sono consentiti. Per impostazione predefinita, Add-Type genera l'assembly solo in memoria.

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

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.

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 dell'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 Path determina il compilatore che Add-Type usa.

Se si invia un file di assembly, Add-Type accetta i tipi dall'assembly. Per specificare un assembly in memoria o la Global Assembly Cache, usare il parametro AssemblyName .

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 System.dll riferimento a e System.Management.Automation.dll. Oltre agli assembly predefiniti, il comando fa riferimento anche agli assembly specificati mediante questo parametro.

Non è possibile usare i parametri CompilerParameters e ReferencedAssemblies nello stesso comando.

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 una stringa di tipo here o immettere una variabile che contiene 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 accidentale. Ad esempio, se si definisce un tipo denominato Eccezione, 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 viene usato 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 UsingNamespace fanno 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 non riesce.

La classe CodeDomProvider per alcuni linguaggi, ad esempio IronPython e J#, non genera output. Di conseguenza, i tipi scritti in queste lingue non possono essere usati con Add-Type.

Questo cmdlet si basa sulla classe CodeDomProvider di Microsoft .NET Framework.

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

Esempio 5: Aggiungere un tipo da un file di Visual Basic

Esempio 6: Aggiungere una classe con JScript.NET

Esempio 7: Aggiungere un compilatore F#

Parametri

-AssemblyName

-CodeDomProvider

-CompilerParameters

-IgnoreWarnings

-Language

-LiteralPath

-MemberDefinition

-Name

-Namespace

-OutputAssembly

-OutputType

-PassThru

-Path

-ReferencedAssemblies

-TypeDefinition

-UsingNamespace

Input

Output

Note

Risorse aggiuntive

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

Esempio 5: Aggiungere un tipo da un file di Visual Basic

Esempio 6: Aggiungere una classe con JScript.NET

Esempio 7: Aggiungere un compilatore F#

Parametri

-AssemblyName

-CodeDomProvider

-CompilerParameters

-IgnoreWarnings

-Language

-LiteralPath

-MemberDefinition

-Name

-Namespace

-OutputAssembly

-OutputType

-PassThru

-Path

-ReferencedAssemblies

-TypeDefinition

-UsingNamespace

Input

Output

Note

Collegamenti correlati

Risorse aggiuntive