Add-Type

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

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)

Descripción
-----------
Estos comandos agregan la clase BasicTest a la sesión especificando código fuente que está almacenado en una variable. El tipo tiene un método estático denominado Add y un método no estático denominado Multiply.

El primer comando almacena el código fuente de la clase en la variable $source.

El segundo comando usa el cmdlet Add-Type para agregar la clase a la sesión. Dado que usa código fuente insertado, el comando utiliza el parámetro TypeDefinition para especificar el código en la variable $source.

Los comandos restantes utilizan la nueva clase.

El tercer comando usa el método estático Add de la clase BasicTest. Utiliza los caracteres de dos puntos dobles (::) para especificar un miembro estático de la clase.

El cuarto comando utiliza el cmdlet New-Object para crear una instancia de la clase BasicTest. Guarda el nuevo objeto en la variable $basicTestObject. 

El quinto comando utiliza el método Multiply de $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()

Descripción
-----------
Estos comandos utilizan el cmdlet Get-Member para examinar los objetos creados por los cmdlets Add-Type y New-Object en el ejemplo anterior.

El primer comando utiliza el cmdlet Get-Member para obtener el tipo y los miembros de la clase BasicTest agregada por Add-Type a la sesión. El comando Get-Member revela que es un objeto System.RuntimeType, que se deriva de la clase System.Object.

El segundo comando usa el parámetro Static de Get-Member para obtener los métodos y propiedades estáticos de la clase BasicTest. Los resultados indican que se incluye el método Add.

El tercer comando usa Get-Member para obtener los miembros del objeto almacenado en la variable $BasicTestObject. Se trata de la instancia de objeto que se creó usando el cmdlet New-Object con la clase $BasicType. 

Los resultados indican que el valor de la variable $basicTestObject es una instancia de la clase BasicTest y que incluye un miembro denominado Multiply.

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

Descripción
-----------
Este comando agrega las clases del ensamblado Accessibility a la sesión actual. El comando usa el parámetro AssemblyName para especificar el nombre del ensamblado. El carácter comodín permite obtener el ensamblado correcto, incluso si no está seguro del nombre o de su ortografía.

El comando utiliza el parámetro PassThru para generar objetos que representen las clases agregadas a la sesión y guarda los objetos en la variable $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

Descripción
-----------
En este ejemplo, se utiliza el cmdlet Add-Type para agregar a la sesión actual la clase VBFromFile que se define en el archivo Hello.vb. El texto del archivo Hello.vb se muestra en el resultado del comando.

El primer comando utiliza el cmdlet Add-Type para agregar a la sesión actual el tipo que se define en el archivo Hello.vb. El comando utiliza el parámetro Path para especificar el archivo de origen. 

El segundo comando llama a la función SayHello como un método estático de la clase 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)

Descripción
-----------
Los comandos de este ejemplo muestran cómo llamar a las API nativas de Windows en Windows PowerShell. Add-Type utiliza el mecanismo de invocación de plataforma (P/Invoke) para llamar a una función en User32.dll de Windows PowerShell.

El primer comando almacena la firma de C# de la función ShowWindowAsync en la variable $signature. (Para obtener más información, vea la función ShowWindowAsync en MSDN Library, en https://go.microsoft.com/fwlink/? LinkId=143643 (puede estar en inglés).) Para asegurar que se vea el método resultante en una sesión de Windows PowerShell, se ha agregado la palabra clave "public" a la firma estándar.

El segundo comando usa el cmdlet Add-Type para agregar la función ShowWindowAsync a la sesión de Windows PowerShell como un método estático de una clase creada por Add-Type. El comando utiliza el parámetro MemberDefinition para especificar la definición de método guardada en la variable $signature.
 
El comando utiliza los parámetros Name y Namespace para especificar un nombre y un espacio de nombres para la clase. Utiliza el parámetro PassThru para generar un objeto que represente los tipos y guarda el objeto en la variable $showWindowAsync.

El tercer y cuarto comando utilizan el nuevo método estático ShowWindowAsync. El método toma dos parámetros: el identificador de ventana y un entero que especifica cómo se va a mostrar la ventana.

El tercer comando llama a ShowWindowAsync. Utiliza el cmdlet Get-Process con la variable automática $pid para obtener el proceso que hospeda la actual sesión de Windows PowerShell. A continuación, utiliza la propiedad MainWindowHandle del proceso actual y el valor "2", que representa el valor SW_MINIMIZE.

Para restaurar la ventana, el cuarto comando usa el valor "4" para la posición de la ventana, el cual representa el valor SW_RESTORE. (SW_MAXIMIZE viene representado por el valor 3.)

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

Descripción
-----------
Este comando utiliza el cmdlet Add-Type para agregar a la sesión de Windows PowerShell un método de código JScript insertado. Utiliza el parámetro MemberDefinition para enviar el código fuente almacenado en la variable $jsMethod. Utiliza la variable Name para especificar el nombre de la clase creada por Add-Type para el método y usa el parámetro Language para especificar el lenguaje 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

Descripción
-----------
En este ejemplo se muestra cómo utilizar el cmdlet Add-Type para agregar un compilador de código de FSharp a una sesión de Windows PowerShell. Para poder ejecutar este ejemplo en Windows PowerShell, debe tener FSharp.Compiler.CodeDom.dll que se instala con el lenguaje FSharp.

El primer comando del ejemplo utiliza el cmdlet Add-Type con el parámetro Path para especificar un ensamblado. Add-Type obtiene los tipos del ensamblado.

El segundo comando usa el cmdlet New-Object para crear una instancia del proveedor de código de FSharp y guarda el resultado en la variable $provider.

El tercer comando guarda el código de FSharp que define el método Loop en la variable $FSharpCode.

El cuarto comando utiliza el cmdlet Add-Type para guardar en la variable $fSharpType 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 indica a Add-Type que devuelva un objeto Runtime que represente los tipos. Un operador de canalización (|) envía el objeto Runtime al cmdlet Where-Object, que devuelve únicamente los tipos públicos. Se utiliza el filtro Where-Object porque el proveedor de FSharp genera tipos no públicos para admitir el tipo público resultante.

El quinto comando llama al método Loop como método estático del tipo almacenado en la variable $fSharpType.