Add-Type
Agrega una clase de Microsoft .NET a una sesión de PowerShell.
Sintaxis
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>]Description
El Add-Type cmdlet le permite definir una clase de Microsoft .NET Framework en la sesión de PowerShell.
A continuación, puede crear instancias de objetos mediante el New-Object cmdlet y usar los objetos igual que usaría cualquier objeto de .NET Framework. Si agrega un Add-Type comando al perfil de PowerShell, la clase está disponible en todas las sesiones de PowerShell.
Para especificar el tipo, especifique un ensamblado o archivos de código fuente existentes, o especifique el código fuente en línea o guardado en una variable. Incluso puede especificar solo un método y Add-Type definirá y generará la clase . En Windows, puede usar esta característica para realizar llamadas de invocación de plataforma (P/Invoke) a funciones no administradas en PowerShell. Si especifica código fuente, Add-Type compila el código fuente especificado y genera un ensamblado en memoria que contiene los nuevos tipos de .NET Framework.
Puede usar los parámetros de Add-Type para especificar un lenguaje alternativo y un compilador, C# es el valor predeterminado, las opciones del compilador, las dependencias del ensamblado, el espacio de nombres de clase, los nombres del tipo y el ensamblado resultante.
Ejemplos
Ejemplo 1: Adición de un tipo de .NET a una sesión
En este ejemplo se agrega la clase BasicTest a la sesión especificando el código fuente almacenado en una variable. La clase BasicTest se usa para agregar enteros, crear un objeto y multiplicar enteros.
$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 variable almacena el código fuente de la clase . El tipo tiene un método estático denominado Add y un método no estático denominado Multiply.
El Add-Type cmdlet agrega la clase a la sesión. Dado que usa código fuente insertado, el comando usa el parámetro TypeDefinition para especificar el código en la $Source variable.
El Add método estático de la clase BasicTest usa los caracteres de dos puntos y comas (::) para especificar un miembro estático de la clase . Los enteros se agregan y se muestra la suma.
El New-Object cmdlet crea una instancia de la clase BasicTest . Guarda el nuevo objeto en la $BasicTestObject variable .
$BasicTestObject usa el Multiply método . Los enteros se multiplican y se muestra el producto.
Ejemplo 2: Examen de un tipo agregado
En este ejemplo se usa el Get-Member cmdlet para examinar los objetos que los Add-Type cmdlets y New-Object creados en el ejemplo 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()El Get-Member cmdlet obtiene el tipo y los miembros de la clase BasicTest que Add-Type se agregaron a la sesión. El Get-Member comando revela que es un objeto System.RuntimeType , que se deriva de la clase System.Object .
El Get-Member parámetro Static obtiene las propiedades y métodos estáticos de la clase BasicTest . La salida muestra que se incluye el Add método .
El Get-Member cmdlet obtiene los miembros del objeto almacenados en la $BasicTestObject variable .
$BasicTestObject se creó mediante el New-Object cmdlet con la clase BasicTest . La salida revela que el valor de la $BasicTestObject variable es una instancia de la clase BasicTest y que incluye un miembro denominado Multiply.
Ejemplo 3: Agregar tipos de un ensamblado
En este ejemplo se agregan las clases del Accessibility.dll ensamblado a la sesión actual.
$AccType = Add-Type -AssemblyName "accessib*" -PassThruLa $AccType variable almacena un objeto creado con el Add-Type cmdlet . Add-Type usa el parámetro AssemblyName para especificar el nombre del ensamblado. El carácter comodín asterisco (*) permite obtener el ensamblado correcto incluso cuando no está seguro del nombre o su ortografía. El parámetro PassThru genera objetos que representan las clases que se agregan a la sesión.
Ejemplo 4: Llamada a las API nativas de Windows
En este ejemplo se muestra cómo llamar a las API nativas de Windows en PowerShell. Add-Type usa el mecanismo De invocación de plataforma (P/Invoke) para llamar a una función desde User32.dll PowerShell. Este ejemplo solo funciona en equipos que ejecutan el 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 variable almacena la firma de C# de la ShowWindowAsync función. Para asegurarse de que el método resultante está visible en una sesión de PowerShell, la public palabra clave se agregó a la firma estándar. Para obtener más información, vea ShowWindowAsync function( Función ShowWindowAsync ).
La $ShowWindowAsync variable almacena el objeto creado por el Add-Type parámetro PassThru .
El Add-Type cmdlet agrega la ShowWindowAsync función a la sesión de PowerShell como método estático. El comando usa el parámetro MemberDefinition para especificar la definición del método guardada en la $Signature variable. El comando usa los parámetros Name y Namespace para especificar un nombre y un espacio de nombres para la clase . El parámetro PassThru genera un objeto que representa los tipos.
El nuevo ShowWindowAsync método estático se usa en los comandos para minimizar y restaurar la consola de PowerShell. El método toma dos parámetros: el identificador de ventana y un entero que especifica cómo se muestra la ventana.
Para minimizar la consola de PowerShell, ShowWindowAsync usa el Get-Process cmdlet con la $PID variable automática para obtener el proceso que hospeda la sesión actual de PowerShell. A continuación, usa la propiedad MainWindowHandle del proceso actual y un valor de 2, que representa el SW_MINIMIZE valor.
Para restaurar la ventana, ShowWindowAsync usa un valor de para la posición de 4 la ventana, que representa el SW_RESTORE valor.
Para maximizar la ventana, use el valor de 3 que representa SW_MAXIMIZE.
Ejemplo 5: Agregar un tipo desde un archivo de Visual Basic
En este ejemplo se usa el Add-Type cmdlet para agregar la clase VBFromFile definida en el Hello.vb archivo a la sesión actual. El texto del Hello.vb archivo se muestra en la salida 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, WorldAdd-Type usa el parámetro Path para especificar el archivo de origen, Hello.vby agrega el tipo definido en el archivo. La SayHello función se llama como método estático de la clase VBFromFile .
Ejemplo 6: Agregar una clase con JScript.NET
En este ejemplo se usa JScript.NET para crear una nueva clase, FRectangle, en la sesión de 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 0Ejemplo 7: Adición de un compilador de F#
En este ejemplo se muestra cómo usar el Add-Type cmdlet para agregar un compilador de código de F# a la sesión de PowerShell. Para ejecutar este ejemplo en PowerShell, debe tener instalado FSharp.Compiler.CodeDom.dll con el lenguaje 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
1Add-Type usa el parámetro Path para especificar un ensamblado y obtiene los tipos del ensamblado.
New-Object crea una instancia del proveedor de código F# y guarda el resultado en la $Provider variable . La $FSharpCode variable guarda el código de F# que define el método Loop .
La $FSharpType variable almacena los resultados del Add-Type cmdlet que guarda los tipos públicos definidos en $FSharpCode. El parámetro TypeDefinition especifica el código fuente que define los tipos. El parámetro CodeDomProvider especifica el compilador de código fuente. El parámetro PassThru dirige Add-Type para devolver un objeto Runtime que representa los tipos.
Los objetos se envían a la canalización al Where-Object cmdlet , que devuelve solo los tipos públicos. El Where-Object cmdlet se usa porque el proveedor de F# genera tipos no públicos para admitir el tipo público resultante.
El método Loop se llama como un método estático del tipo almacenado en la $FSharpType variable.
Parámetros
-AssemblyName
Especifica el nombre de un ensamblado que incluye los tipos. Add-Type toma los tipos del ensamblado especificado. Este parámetro es necesario cuando se crean tipos basados en un nombre de ensamblado.
Escriba el nombre completo o simple, también conocido como nombre parcial, de un ensamblado. Se permiten caracteres comodín en el nombre del ensamblado. Si escribe un nombre simple o parcial, Add-Type lo resuelve en el nombre completo y, a continuación, usa el nombre completo para cargar el ensamblado.
El uso de los parámetros Path o LiteralPath garantiza que está cargando el ensamblado que pretende cargar. Cuando se usa el parámetro AssemblyName , PowerShell pide a .NET que resuelva el nombre del ensamblado mediante el proceso de resolución de ensamblados estándar de .NET. Dado que .NET busca primero la carpeta de la aplicación, Add-Type podría cargar un ensamblado desde $PSHOME en lugar de la versión en la carpeta actual. Para obtener más información, vea Ubicación del ensamblado.
Si .NET no puede resolver el nombre, PowerShell busca en la ubicación actual para encontrar el ensamblado. Cuando se usan caracteres comodín en el parámetro AssemblyName , se produce un error en el proceso de resolución de ensamblados de .NET, lo que hace que PowerShell busque en la ubicación actual.
| Tipo: | String[] |
| Alias: | AN |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | True |
-CodeDomProvider
Especifica un compilador o generador de código. Add-Type usa el compilador especificado para compilar el código fuente. El valor predeterminado es el compilador de C#. Use este parámetro si usa un idioma que no se puede especificar mediante el parámetro Language . CodeDomProvider que especifique debe poder generar ensamblados a partir del código fuente.
| Tipo: | CodeDomProvider |
| Alias: | Provider |
| Posición: | Named |
| Valor predeterminado: | C# compiler |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-CompilerParameters
Especifica las opciones para el compilador de código fuente. Estas opciones se envían al compilador sin revisar.
Este parámetro permite dirigir al compilador para generar un archivo ejecutable, insertar recursos o establecer opciones de línea de comandos, como la /unsafe opción . Este parámetro implementa la clase CompilerParameters , System.CodeDom.Compiler.CompilerParameters.
No puede usar los parámetros CompilerParameters y ReferencedAssemblies en el mismo comando.
| Tipo: | CompilerParameters |
| Alias: | CP |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-IgnoreWarnings
Pasa por alto las advertencias del compilador. Use este parámetro para evitar que Add-Type controle las advertencias del compilador como errores.
| Tipo: | SwitchParameter |
| Posición: | Named |
| Valor predeterminado: | False |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-Language
Especifica el idioma que se usa en el código fuente. El Add-Type cmdlet usa el valor de este parámetro para seleccionar el codeDomProvider adecuado. CSharp es el valor predeterminado. Los valores aceptables para este parámetro son los siguientes:
CSharpCSharpVersion2CSharpVersion3JScriptVisualBasic
| Tipo: | Language |
| Valores aceptados: | CSharp, CSharpVersion2, CSharpVersion3, JScript, VisualBasic |
| Posición: | Named |
| Valor predeterminado: | CSharp |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-LiteralPath
Especifica la ruta de acceso a los archivos de código fuente o los archivos DLL de ensamblado que contienen los tipos. A diferencia de Path, el valor del parámetro LiteralPath se usa exactamente como se escribe. Ninguno de los caracteres se interpreta como caracteres comodín. Si la ruta de acceso contiene caracteres de escape, escríbalos entre comillas simples. Las comillas simples indican a PowerShell que no interprete ningún carácter como secuencias de escape.
El uso de los parámetros Path o LiteralPath garantiza que está cargando el ensamblado que pretende cargar.
| Tipo: | String[] |
| Alias: | PSPath |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-MemberDefinition
Especifica las nuevas propiedades o métodos para la clase. Add-Type genera el código de plantilla necesario para admitir las propiedades o los métodos.
En Windows, puede usar esta característica para realizar llamadas de invocación de plataforma (P/Invoke) a funciones no administradas en PowerShell.
| Tipo: | String[] |
| Posición: | 1 |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-Name
Especifica el nombre de la clase que se va a crear. Este parámetro es necesario cuando se genera un tipo a partir de una definición de miembro.
El nombre y el espacio de nombres del tipo deben ser únicos dentro de una sesión. No se puede descargar un tipo ni cambiarlo. Para cambiar el código de un tipo, debe cambiar el nombre o iniciar una nueva sesión de PowerShell. De lo contrario, se produce un error en el comando.
| Tipo: | String |
| Posición: | 0 |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-Namespace
Especifica un espacio de nombres para el tipo.
Si este parámetro no se incluye en el comando, el tipo se crea en el espacio de nombres Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes . Si el parámetro se incluye en el comando con un valor de cadena vacío o un valor de , el tipo se genera en el espacio de $Nullnombres global.
| Tipo: | String |
| Alias: | NS |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-OutputAssembly
Genera un archivo DLL para el ensamblado con el nombre especificado en la ubicación. Escriba una ruta de acceso opcional y un nombre de archivo. Se permite el uso de caracteres comodín. De forma predeterminada, Add-Type genera el ensamblado solo en memoria.
| Tipo: | String |
| Alias: | OA |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | True |
-OutputType
Especifica el tipo de resultado del ensamblado de salida. De forma predeterminada, no se especifica ningún tipo de resultado. Este parámetro es válido solo si se especifica un ensamblado de salida en el comando. Para obtener más información sobre los valores, vea OutputAssemblyType (enumeración).
Los valores aceptables para este parámetro son los siguientes:
ConsoleApplicationLibraryWindowsApplication
| Tipo: | OutputAssemblyType |
| Alias: | OT |
| Valores aceptados: | ConsoleApplication, Library, WindowsApplication |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-PassThru
Devuelve un objeto System.Runtime que representa los tipos que se agregaron. De forma predeterminada, este cmdlet no genera ninguna salida.
| Tipo: | SwitchParameter |
| Posición: | Named |
| Valor predeterminado: | False |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-Path
Especifica la ruta de acceso a los archivos de código fuente o los archivos DLL de ensamblado que contienen los tipos.
Si envía archivos de código fuente, Add-Type compila el código en los archivos y crea un ensamblado en memoria de los tipos. La extensión de archivo especificada en el valor de Path determina el compilador que Add-Type usa.
Si envía un archivo de ensamblado, Add-Type toma los tipos del ensamblado. Para especificar un ensamblado en memoria o la caché global de ensamblados, use el parámetro AssemblyName .
| Tipo: | String[] |
| Posición: | 0 |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-ReferencedAssemblies
Especifica los ensamblados de los que depende el tipo. De forma predeterminada, Add-Type hace referencia a System.dll y System.Management.Automation.dll. Además de los ensamblados predeterminados, se hace referencia a los ensamblados que se especifican mediante este parámetro.
No puede usar los parámetros CompilerParameters y ReferencedAssemblies en el mismo comando.
| Tipo: | String[] |
| Alias: | RA |
| Posición: | Named |
| Valor predeterminado: | None |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-TypeDefinition
Especifica el código fuente que contiene las definiciones de tipo. Escriba el código fuente en una cadena o here-string, o especifique una variable que contenga el código fuente. Para obtener más información sobre las cadenas aquí, consulte about_Quoting_Rules.
Incluya una declaración de espacio de nombres en la definición de tipo. Si se omite la declaración de espacio de nombres, el tipo podría tener el mismo nombre que otro tipo o el método abreviado de otro tipo, y provocar una sobrescritura accidental. Por ejemplo, si define un tipo denominado Exception, se producirá un error en los scripts que usan Exception como acceso directo para System.Exception .
| Tipo: | String |
| Posición: | 0 |
| Valor predeterminado: | None |
| Requerido: | True |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
-UsingNamespace
Especifica otros espacios de nombres que son necesarios para la clase. Esto es muy parecido a la palabra clave de C#, Using.
De forma predeterminada, Add-Type hace referencia al espacio de nombres System . Cuando se usa el parámetro MemberDefinition , Add-Type también hace referencia al espacio de nombres System.Runtime.InteropServices de forma predeterminada. Se hace referencia a los espacios de nombres que se agregan mediante el parámetro UsingNamespace , además de los espacios de nombres predeterminados.
| Tipo: | String[] |
| Alias: | Using |
| Posición: | Named |
| Valor predeterminado: | System namespace |
| Requerido: | False |
| Aceptar entrada de canalización: | False |
| Aceptar caracteres comodín: | False |
Entradas
None
No se pueden canalizar objetos a este cmdlet.
Salidas
None
De forma predeterminada, este cmdlet no devuelve ninguna salida.
Cuando se usa el parámetro PassThru , este cmdlet devuelve un objeto System.Type que representa el nuevo tipo.
Notas
Los tipos que agregue solo existen en la sesión actual. Para usar los tipos de todas las sesiones, agréguelos al perfil de PowerShell. Para obtener más información sobre el perfil, consulte about_Profiles.
Los nombres de tipo y los espacios de nombres deben ser únicos dentro de una sesión. No se puede descargar un tipo ni cambiarlo. Si necesita cambiar el código de un tipo, debe cambiar el nombre o iniciar una nueva sesión de PowerShell. De lo contrario, se produce un error en el comando.
La clase CodeDomProvider para algunos lenguajes, como IronPython y J#, no genera resultados. Como resultado, los tipos escritos en estos lenguajes no se pueden usar con Add-Type.
Este cmdlet se basa en la clase CodeDomProvider de Microsoft .NET Framework.
