NOM
Add-Type
RÉSUMÉ
Ajoute un type (une classe) Microsoft .NET Framework à une session Windows PowerShell.
SYNTAXE
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>]
DESCRIPTION
L'applet de commande Add-Type vous permet de définir une classe .NET Framework dans votre session Windows PowerShell. Vous pouvez ensuite instancier des objets (à l'aide de l'applet de commande New-Object) et utiliser ces objets, tout comme vous utiliseriez n'importe quel objet .NET Framework. Si vous ajoutez une commande Add-Type à votre profil Windows PowerShell, la classe sera disponible dans toutes les sessions Windows PowerShell.
Vous pouvez indiquer le type en spécifiant un assembly existant ou des fichiers de code source, ou vous pouvez indiquer le code source inclus ou enregistré dans une variable. Vous pouvez même vous contenter de spécifier une méthode ; Add-Type définira et générera la classe. Vous pouvez utiliser cette fonctionnalité pour effectuer des appels de code non managé auprès des fonctions non managées de Windows PowerShell. Si vous spécifiez le code source, Add-Type le compile et génère un assembly en mémoire qui contient les nouveaux types .NET Framework.
Vous pouvez utiliser les paramètres de Add-Type pour spécifier un autre langage et compilateur (CSharp étant la valeur par défaut), des options de compilateur, des dépendances d'assembly, l'espace de noms de la classe, les noms du type, ainsi que l'assembly résultant.
PARAMÈTRES
-AssemblyName <string[]>
Spécifie le nom d'un assembly incluant les types. Add-Type récupère les types à partir de l'assembly spécifié.
Ce paramètre est obligatoire lorsque vous créez des types basés sur le nom d'un assembly.
Entrez le nom complet ou simple (également appelé « nom partiel ») d'un assembly. Les caractères génériques sont autorisés dans le nom de l'assembly. Si vous entrez un nom simple ou partiel, Add-Type le remplace par le nom complet, puis utilise ce nom complet pour charger l'assembly.
Ce paramètre n'accepte ni chemin d'accès ni nom de fichier. Pour entrer le chemin d'accès au fichier de bibliothèque de liens dynamiques (DLL) de l'assembly, utilisez le paramètre Path.
Obligatoire ? true
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? true
-CodeDomProvider <CodeDomProvider>
Spécifie un compilateur ou générateur de code. Add-Type utilise le compilateur spécifié pour compiler le code source. Par défaut, il s'agit du compilateur CSharp. Utilisez ce paramètre si vous utilisez un langage qui ne peut pas être spécifié à l'aide du paramètre Language. Le paramètre CodeDomProvider que vous spécifiez doit être en mesure de générer des assemblys à partir du code source.
Obligatoire ? false
Position ? named
Valeur par défaut Compilateur CSharp
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-CompilerParameters <CompilerParameters>
Spécifie les options du compilateur de code source. Ces options sont envoyées au compilateur sans révision.
Ce paramètre vous permet de demander au compilateur de générer un fichier exécutable, d'incorporer des ressources ou de définir des options de ligne de commande, telles que l'option « /unsafe ». Ce paramètre implémente la classe CompilerParameters (System.CodeDom.Compiler.CompilerParameters).
Obligatoire ? false
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-IgnoreWarnings [<SwitchParameter>]
Ignore les avertissements du compilateur. Utilisez ce paramètre pour empêcher Add-Type de traiter les avertissements du compilateur comme des erreurs.
Obligatoire ? false
Position ? named
Valeur par défaut False
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-Language <Language>
Spécifie le langage utilisé dans le code source. Add-Type utilise ce langage pour sélectionner le compilateur de code approprié.
Les valeurs valides sont « CSharp », « CSharpVersion3 », « VisualBasic » et « JScript ». La valeur par défaut est « CSharp ».
Obligatoire ? false
Position ? named
Valeur par défaut CSharp
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-MemberDefinition <string[]>
Spécifie de nouvelles propriétés ou méthodes pour la classe. Add-Type génère le code de modèle requis pour prendre en charge les propriétés ou méthodes.
Vous pouvez utiliser cette fonctionnalité pour effectuer des appels de code non managé auprès des fonctions non managées de Windows PowerShell. Pour plus d'informations, consultez les exemples.
Obligatoire ? true
Position ? 2
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-Name <string>
Spécifie le nom de la classe à créer. Ce paramètre est obligatoire lors de la génération d'un type à partir d'une définition de membre.
Le nom de type et l'espace de noms doivent être uniques au sein d'une session. Vous ne pouvez pas décharger un type, ni le modifier. Pour modifier le code d'un type, vous devez changer son nom ou démarrer une nouvelle session Windows PowerShell. Sinon, la commande échoue.
Obligatoire ? true
Position ? 1
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-Namespace <string>
Spécifie un espace de noms pour le type.
Si ce paramètre n'est pas inclus dans la commande, le type est créé dans l'espace de noms Microsoft.PowerShell.
Commands.AddType.AutoGeneratedTypes. Si le paramètre est inclus dans la commande avec une valeur de chaîne vide ou une valeur $null, le type est généré dans l'espace de noms global.
Obligatoire ? false
Position ? named
Valeur par défaut Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-OutputAssembly <string>
Génère un fichier DLL pour l'assembly avec le nom spécifié dans l'emplacement. Entrez un chemin d'accès (facultatif) et le nom de fichier. Les caractères génériques sont autorisés. Par défaut, Add-Type génère l'assembly uniquement en mémoire.
Obligatoire ? false
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? true
-OutputType <OutputAssemblyType>
Spécifie le type de sortie de l'assembly de sortie. Les valeurs valides sont Library, ConsoleApplication et WindowsApplication.
Par défaut, aucun type de sortie n'est spécifié.
Ce paramètre est valide uniquement lorsqu'un assembly de sortie est spécifié dans la commande.
Obligatoire ? false
Position ? named
Valeur par défaut Aucun
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-PassThru [<SwitchParameter>]
Retourne un objet System.Runtime qui représente les types ajoutés. Par défaut, cette applet de commande ne génère aucune sortie.
Obligatoire ? false
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-Path <string[]>
Spécifie le chemin d'accès aux fichiers de code source ou aux fichiers DLL d'assembly contenant les types.
Si vous envoyez des fichiers de code source, Add-Type compile le code des fichiers et crée un assembly en mémoire des types. L'extension de nom de fichier spécifiée dans la valeur du paramètre Path détermine le compilateur utilisé par Add-Type.
Si vous envoyez un fichier d'assembly, Add-Type récupère les types à partir de l'assembly. Pour spécifier un assembly en mémoire ou le Global Assembly Cache (GAC), utilisez le paramètre AssemblyName.
Obligatoire ? true
Position ? 1
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-ReferencedAssemblies <string[]>
Spécifie les assemblys dont le type dépend. Par défaut, Add-Type référence System.dll et System.Management.Automation.dll. Les assemblys que vous spécifiez à l'aide de ce paramètre sont référencés en plus des assemblys par défaut.
Obligatoire ? false
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-TypeDefinition <string>
Spécifie le code source qui contient les définitions de type. Entrez le code source dans une chaîne (string ou here-string), ou entrez une variable contenant le code source. Pour plus d'informations sur les chaînes here-string, consultez about_Quoting_Rules.
Incluez une déclaration d'espace de noms dans votre définition de type. Si vous omettez la déclaration d'espace de noms, votre type peut avoir le même nom qu'un autre type ou le raccourci d'un autre type, ce qui provoque un écrasement involontaire. Par exemple, si vous définissez un type appelé « Exception », les scripts utilisant ce type en tant que raccourci pour System.Exception échoueront.
Obligatoire ? true
Position ? 1
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
-UsingNamespace <string[]>
Spécifie les autres espaces de noms obligatoires pour la classe. Ce paramètre ressemble beaucoup au mot clé Using dans C#.
Par défaut, Add-Type référence l'espace de noms System. Lorsque le paramètre MemberDefinition est utilisé, Add-Type référence également l'espace de noms System.Runtime.InteropServices par défaut. Les espaces de noms que vous ajoutez à l'aide du paramètre UsingNamespace sont référencés en plus des espaces de noms par défaut.
Obligatoire ? false
Position ? named
Valeur par défaut
Accepter l'entrée de pipeline ? false
Accepter les caractères génériques ? false
<CommonParameters>
Cette applet de commande prend en charge les paramètres courants : Verbose, Debug,
ErrorAction, ErrorVariable, WarningAction, WarningVariable,
OutBuffer et OutVariable. Pour plus d'informations, tapez
« get-help about_commonparameters ».
ENTRÉES
Aucun
Vous ne pouvez pas diriger d'objets vers Add-Type.
SORTIES
Aucun ou System.RuntimeType
Lorsque vous utilisez le paramètre PassThru, Add-Type retourne un objet System.RuntimeType qui représente le nouveau type. Sinon, cette applet de commande ne génère aucune sortie.
NOTES
Les types que vous ajoutez existent uniquement dans la session active. Pour utiliser les types dans toutes les sessions, ajoutez-les à votre profil Windows PowerShell. Pour plus d'informations sur le profil, consultez about_Profiles.
Les noms de types (et les espaces de noms) doivent être uniques au sein d'une session. Vous ne pouvez pas décharger un type, ni le modifier. Pour modifier le code d'un type, vous devez changer son nom ou démarrer une nouvelle session Windows PowerShell. Sinon, la commande échoue.
Pour certains langages, tels qu'IronPython et JSharp, la classe CodeDomProvider ne génère pas de sortie. En conséquence, les types écrits dans ces langages ne peuvent pas être utilisés avec Add-Type.
Cette applet de commande est basée sur la classe CodeDomProvider. Pour plus d'informations sur cette classe, consultez le kit de développement Microsoft .NET Framework SDK.
-------------------------- EXEMPLE 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)
Description
-----------
Ces commandes ajoutent la classe BasicTest à la session en spécifiant le code source stocké dans une variable. Le type possède une méthode statique appelée Add et une méthode non statique appelée Multiply.
La première commande stocke le code source de la classe dans la variable $source.
La deuxième commande utilise l'applet de commande Add-Type pour ajouter la classe à la session. Étant donné qu'elle utilise le code source inclus, la commande utilise le paramètre TypeDefinition pour spécifier le code dans la variable $source.
Les commandes restantes utilisent la nouvelle classe.
La troisième commande appelle la méthode statique Add de la classe BasicTest. Elle utilise des deux-points doubles (::) pour spécifier un membre statique de la classe.
La quatrième commande utilise l'applet de commande New-Object pour instancier une instance de la classe BasicTest.
Elle enregistre le nouvel objet dans la variable $basicTestObject.
La cinquième commande utilise la méthode Multiply de $basicTestObject.
-------------------------- EXEMPLE 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()
Description
-----------
Ces commandes utilisent l'applet de commande Get-Member pour examiner les objets que les applets de commande Add-Type et New-Object ont créés dans l'exemple précédent.
La première commande utilise l'applet de commande Get-Member pour obtenir le type et les membres de la classe BasicTest que Add-Type a ajoutée à la session. La commande Get-Member révèle qu'il s'agit d'un objet System.RuntimeType, dérivé de la classe System.Object.
La deuxième commande utilise le paramètre Static de Get-Member pour obtenir les méthodes et propriétés statiques de la classe BasicTest. La sortie montre que la méthode Add est incluse.
La troisième commande utilise Get-Member pour obtenir les membres de l'objet stocké dans la variable $BasicTestObject. Il s'agit de l'instance d'objet créée à l'aide de l'applet de commande New-Object avec la classe $BasicType.
La sortie révèle que la valeur de la variable $basicTestObject est une instance de la classe BasicTest et qu'elle inclut un membre appelé Multiply.
-------------------------- EXEMPLE 3 --------------------------
C:\PS>$accType = add-type -assemblyname accessib* -passthru
Description
-----------
Cette commande ajoute les classes de l'assembly Accessibility à la session active. Elle utilise le paramètre AssemblyName pour spécifier le nom de l'assembly. Le caractère générique vous permet d'obtenir l'assembly recherché, même lorsque vous n'êtes pas sûr de son nom ou de son orthographe.
La commande utilise le paramètre PassThru pour générer des objets représentant les classes ajoutées à la session, et elle enregistre ces objets dans la variable $accType.
-------------------------- EXEMPLE 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
Description
-----------
Cet exemple utilise l'applet de commande Add-Type pour ajouter la classe VBFromFile définie dans le fichier Hello.vb à la session active. Le texte du fichier Hello.vb est affiché dans la sortie de commande.
La première commande utilise l'applet de commande Add-Type pour ajouter le type défini dans le fichier Hello.vb à la session active. Elle utilise le paramètre Path pour spécifier le fichier source.
La deuxième commande appelle la fonction SayHello en tant que méthode statique de la classe VBFromFile.
-------------------------- EXEMPLE 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)
Description
-----------
Les commandes de cet exemple montrent comment appeler des API Windows natives dans Windows PowerShell. Add-Type utilise le mécanisme d'appel de code non managé pour appeler une fonction de User32.dll à partir de Windows PowerShell
.
La première commande stocke la signature C# de la fonction ShowWindowAsync dans la variable $signature. (Pour plus d'informations, consultez la rubrique « Fonction ShowWindowAsync » (page éventuellement en anglais) dans la bibliothèque MSDN à l'adresse http://go.microsoft.com/fwlink/?LinkId=143643.) Pour garantir que la méthode résultante sera visible dans une session Windows PowerShell, le mot clé « public » a été ajouté à la signature standard.
La deuxième commande utilise l'applet de commande Add-Type pour ajouter la fonction ShowWindowAsync à la session Windows PowerShell en tant que méthode statique d'une classe créée par Add-Type. Elle utilise le paramètre MemberDefinition pour spécifier la définition de méthode enregistrée dans la variable $signature.
La commande utilise les paramètres Name et Namespace pour spécifier un nom et un espace de noms pour la classe. Elle utilise le paramètre PassThru pour générer un objet représentant les types, et elle enregistre cet objet dans la variable $showWindowAsync.
La troisième et la quatrième commandes utilisent la nouvelle méthode statique ShowWindowAsync. Cette méthode utilise deux paramètres et le handle de fenêtre. Un entier indique comment la fenêtre sera affichée.
La troisième commande appelle ShowWindowAsync. Elle utilise l'applet de commande Get-Process avec la variable automatique $pid pour obtenir le processus hébergeant la session Windows PowerShell active. Elle utilise ensuite la propriété MainWindowHandle du processus actif et une valeur de « 2 », qui représente la valeur SW_MINIMIZE.
Pour restaurer la fenêtre, la quatrième commande utilise une valeur de « 4 » pour la position de la fenêtre, qui représente la valeur SW_RESTORE. (La valeur de SW_MAXIMIZE est 3.)
-------------------------- EXEMPLE 6 --------------------------
C:\PS>Add-Type -MemberDefinition $jsMethod -Name "PrintInfo" -Language JScript
Description
-----------
Cette commande utilise l'applet de commande Add-Type pour ajouter une méthode à partir du code JScript inclus dans la session Windows PowerShell. Elle utilise le paramètre MemberDefinition pour envoyer le code source stocké dans la variable $jsMethod. Elle utilise la variable Name pour spécifier le nom de la classe créée par Add-Type pour la méthode et le paramètre Language afin de spécifier le langage JScript.
-------------------------- EXEMPLE 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 { $_.IsPubli
c }
C:\PS> $fsharpType::loop(4)
4
3
2
1
Description
-----------
Cet exemple montre comment utiliser l'applet de commande Add-Type pour ajouter un compilateur de code FSharp à votre session Windows PowerShell. Pour exécuter cet exemple dans Windows PowerShell, le fichier FSharp.Compiler.CodeDom.dll doit être installé avec le langage FSharp.
La première commande de l'exemple utilise l'applet de commande Add-Type avec le paramètre Path pour spécifier un assembly. Add-Type obtient les types de l'assembly.
La deuxième commande utilise l'applet de commande New-Object pour créer une instance du fournisseur de code FSharp et enregistre le résultat dans la variable $provider.
La troisième commande enregistre le code FSharp qui définit la méthode Loop dans la variable $FSharpCode.
La quatrième commande utilise l'applet de commande Add-Type pour enregistrer les types publics définis dans $fSharp
Code dans la variable $fSharpType. Le paramètre TypeDefinition spécifie le code source qui définit les types. Le paramètre CodeDomProvider spécifie le compilateur de code source.
Le paramètre PassThru demande à Add-Type de retourner un objet Runtime représentant les types. Un opérateur de pipeline (|) envoie l'objet Runtime à l'applet de commande Where-Object, qui retourne uniquement les types publics. Le filtre Where-Object est utilisé car le fournisseur FSharp génère des types non publics pour prendre en charge le type public obtenu.
La cinquième commande appelle la méthode Loop en tant que méthode statique du type stocké dans la variable $fSharpType.
LIENS CONNEXES
Online version: http://go.microsoft.com/fwlink/?LinkID=135195
Add-Member
New-Object
Aucun commentaire:
Enregistrer un commentaire