I've created a PowerShell module that includes wrapper functions, aliases, and various tools that I frequently use. However, this module has grown to about 2800 lines of code, making it quite cumbersome to manage. I'm looking to separate it into smaller, more manageable components, each containing related functions, which I've currently organized by regions within the original file.
I'm trying to load these separated functions using `Invoke-Expression`, but it seems they're not being recognized properly when I try to call them. Here's a snippet of my approach:
$moduleFolder = (Get-Module -ListAvailable MODULENAME).ModuleBase
$functionFiles = gci $moduleFolder -Recurse | ?{$_.Extension -eq ".ps1"}
foreach ($func in $functionFiles)
{
iex $func.FullName
}
When I call `SampleFunction`, I get an error saying it's not recognized as a command. What am I doing wrong?
4 Answers
Great news! I found a better solution. Instead of using `Invoke-Expression`, you should use `Import-Module` to import your `.ps1` files into the session. This way, they get properly registered as functions. Just a tip: don't import each individual `.ps1`; dot-source them or use a builder module to compile them into a single `.psm1` for cleaner management.
Yeah, if this is just for personal use, dot-sourcing is indeed the simplest way. Just make sure to set up your `.psm1` and `.psd1` correctly!
You might want to avoid using `Invoke-Expression`. Instead, try dot-sourcing the files. It should look something like this:
foreach ($file in $functionFiles) {
. $file.FullName
}
This way, the functions should load correctly.
When I work with larger modules, I split the functions between public and private categories. Each function gets its own `.ps1` file organized in either a 'Public' or 'Private' folder. Your module structure could look like this:
.MyModule
|- .Private
| └ PrivateFunc.ps1
|- .Public
| └ PublicFunc.ps1
|- MyModule.psm1
|- MyModule.psd1
That way, it’s easier to manage and maintain!
You should consider digging deeper into module development. There are several frameworks that can assist with building and maintaining PowerShell modules. For instance, using frameworks can help break down your module into individual function files and then compile them back into a single `.psm1` file for better performance. It’s worth checking out tools like PlatyPS for this purpose. A build process helps with loading efficiency and managing public/private function visibility.
It's better to avoid directly using `Import-Module` for individual `.ps1` files. Dot-source each file instead to keep it simple. Consider maintaining a structure with a single main `.psm1` file and a manifest. This approach speeds up performance and keeps things organized. You can also check out some great resources on building a PowerShell module online.