New-Module

New-Module
    [-ScriptBlock] <ScriptBlock>
    [-Function <String[]>]
    [-Cmdlet <String[]>]
    [-ReturnResult]
    [-AsCustomObject]
    [-ArgumentList <Object[]>]
    [<CommonParameters>]

New-Module
    [-Name] <String>
    [-ScriptBlock] <ScriptBlock>
    [-Function <String[]>]
    [-Cmdlet <String[]>]
    [-ReturnResult]
    [-AsCustomObject]
    [-ArgumentList <Object[]>]
    [<CommonParameters>]

El cmdlet New-Module crea un módulo dinámico a partir de un bloque de script. Los miembros del módulo dinámico, como funciones y variables, están disponibles inmediatamente en la sesión y permanecen disponibles hasta que cierre la sesión.

Al igual que los módulos estáticos, de forma predeterminada, los cmdlets y las funciones de un módulo dinámico se exportan y no se exportan las variables y alias. Sin embargo, puede usar el cmdlet Export-ModuleMember y los parámetros de New-Module para invalidar los valores predeterminados.

También puede usar el parámetro AsCustomObject de New-Module para devolver el módulo dinámico como un objeto personalizado. Los miembros de los módulos, como las funciones, se implementan como métodos de script del objeto personalizado en lugar de importarse en la sesión.

Los módulos dinámicos solo existen en memoria, no en el disco. Al igual que todos los módulos, los miembros de los módulos dinámicos se ejecutan en un ámbito de módulo privado que es un elemento secundario del ámbito global. Get-Module no puede obtener un módulo dinámico, pero Get-Command puede obtener los miembros exportados.

Para que un módulo dinámico esté disponible para Get-Module, canalice un comando New-Module a Import-Module o canalice el objeto de módulo que New-Module vuelve a Import-Module. Esta acción agrega el módulo dinámico a la lista de Get-Module, pero no guarda el módulo en el disco ni lo hace persistente.

New-Module -ScriptBlock {function Hello {"Hello!"}}

Name              : __DynamicModule_2ceb1d0a-990f-45e4-9fe4-89f0f6ead0e5
Path              : 2ceb1d0a-990f-45e4-9fe4-89f0f6ead0e5
Description       :
Guid              : 00000000-0000-0000-0000-000000000000
Version           : 0.0
ModuleBase        :
ModuleType        : Script
PrivateData       :
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Hello, Hello]}
ExportedVariables : {}
NestedModules     : {}

Este comando crea un nuevo módulo dinámico con una función denominada Hello. El comando devuelve un objeto de módulo que representa el nuevo módulo dinámico.

new-module -scriptblock {function Hello {"Hello!"}}

Name              : __DynamicModule_2ceb1d0a-990f-45e4-9fe4-89f0f6ead0e5
Path              : 2ceb1d0a-990f-45e4-9fe4-89f0f6ead0e5
Description       :
Guid              : 00000000-0000-0000-0000-000000000000
Version           : 0.0
ModuleBase        :
ModuleType        : Script
PrivateData       :
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Hello, Hello]}
ExportedVariables : {}
NestedModules     : {}

Get-Module

Get-Command Hello

CommandType     Name   Definition
-----------     ----   ----------
Function        Hello  "Hello!"

En este ejemplo se muestra que los módulos dinámicos no los devuelve el cmdlet Get-Module. El cmdlet Get-Command devuelve los miembros que exportan.

New-Module -ScriptBlock {$SayHelloHelp="Type 'SayHello', a space, and a name."; function SayHello ($name) { "Hello, $name" }; Export-ModuleMember -function SayHello -Variable SayHelloHelp}
$SayHelloHelp

Type 'SayHello', a space, and a name.

SayHello Jeffrey

Hello, Jeffrey

Este comando usa el cmdlet Export-ModuleMember para exportar una variable a la sesión actual. Sin el comando Export-ModuleMember, solo se exporta la función.

La salida muestra que tanto la variable como la función se exportaron a la sesión.

New-Module -ScriptBlock {function Hello {"Hello!"}} -name GreetingModule | Import-Module
Get-Module

Name              : GreetingModule
Path              : d54dfdac-4531-4db2-9dec-0b4b9c57a1e5
Description       :
Guid              : 00000000-0000-0000-0000-000000000000
Version           : 0.0
ModuleBase        :
ModuleType        : Script
PrivateData       :
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Hello, Hello]}
ExportedVariables : {}
NestedModules     : {}

Get-Command hello

CommandType     Name                                                               Definition
-----------     ----                                                               ----------
Function        Hello                                                              "Hello!"

Este comando muestra que puede hacer que un módulo dinámico esté disponible para Get-Module canalizando el módulo dinámico a Import-Module.

El primer comando usa un operador de canalización (|) para enviar el objeto de módulo que New-Module genera al cmdlet Import-Module. El comando usa el parámetro Name de New-Module para asignar un nombre descriptivo al módulo. Dado que import-Module no devuelve ningún objeto de forma predeterminada, no hay ninguna salida de este comando.

El segundo comando usa Get-Module para obtener los módulos de la sesión. El resultado muestra que get-module puede obtener el nuevo módulo dinámico.

El tercer comando usa el cmdlet Get-Command para obtener la función Hello que exporta el módulo dinámico.

$m = New-Module -ScriptBlock {function Hello ($name) {"Hello, $name"}; function Goodbye ($name) {"Goodbye, $name"}} -AsCustomObject
$m
$m | Get-Member

TypeName: System.Management.Automation.PSCustomObject

Name        MemberType   Definition
----        ----------   ----------
Equals      Method       bool Equals(System.Object obj)
GetHashCode Method       int GetHashCode()
GetType     Method       type GetType()
ToString    Method       string ToString()
Goodbye     ScriptMethod System.Object Goodbye();
Hello       ScriptMethod System.Object Hello();

$m.goodbye("Jane")

Goodbye, Jane

$m.hello("Manoj")

Hello, Manoj

En este ejemplo se muestra cómo usar el parámetro AsCustomObject de New-Module para generar un objeto personalizado que tenga métodos de script que representen las funciones exportadas.

El primer comando usa el cmdlet New-Module para generar un módulo dinámico con dos funciones, Hello y Goodbye. El comando usa el parámetro AsCustomObject para generar un objeto personalizado en lugar del objeto PSModuleInfo que new-Module genera de forma predeterminada. El comando guarda el objeto personalizado en la variable $m.

El segundo comando intenta mostrar el valor de la variable $m. No aparece contenido.

El tercer comando usa un operador de canalización para enviar el objeto personalizado al cmdlet Get-Member, que muestra las propiedades y los métodos del objeto personalizado. La salida muestra que el objeto tiene métodos de script que representan las funciones Hello y Goodbye.

Los comandos cuarto y quinto usan el formato del método de script para llamar a las funciones Hello y Goodbye.

New-Module -ScriptBlock {function SayHello {"Hello, World!"}; SayHello} -ReturnResult

Hello, World!

Este comando usa el parámetro ReturnResult para solicitar los resultados de ejecutar el bloque de script en lugar de solicitar un objeto de módulo.

El bloque de script del nuevo módulo define la función SayHello y, a continuación, llama a la función .

Este cmdlet admite los parámetros comunes: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction y -WarningVariable. Para obtener más información, vea about_CommonParameters.

Puede canalizar un nombre de módulo a este cmdlet.

Este cmdlet genera un objeto PSModuleInfo de forma predeterminada. Si usa el parámetro AsCustomObject, genera un objeto PSCustomObject. Si usa el parámetro ReturnResult, devuelve el resultado de evaluar el bloque de script en el módulo dinámico.

• También puede hacer referencia a New-Module por su alias, nmo. Para más información, vea about_Aliases.