[PowerShell] Invoke modulbasierte Funktionen, die nicht global zur Verfügung stehen

$MaxThreads = 20 
$RunspacePool = [runspacefactory]::CreateRunspacePool(1 , $MaxThreads) 
$RunspacePool.Open() # Open runspace pool to be able to add runspaces    
 
[..someCode..]

$PowerShell = [powershell]::Create() # Create new powershell instance/runspace                                  
$PowerShell.RunSpacePool = $RunspacePool # Assign new instance/runspace to runspace pool  

[..someCode..]

[void] $PowerShell.AddCommand('<<<<MeineFunktionDieNichtGlobalZurVerfügungSteht>>>>').AddParameters($Parameters) 

[..someCode..]

RunSpace = $PowerShell.BeginInvoke() # Invoke ScriptBlock of the runspace

[void] $PowerShell.AddCommand("Import-Module $($PSCommandPath) -WarningAction Ignore")

Cannot convert argument "asyncResult", with value: "@{PowerShell=System.Management.Automation.PowerShell; RunSpace=System.Management.Automation.PowerShellAsyncResult}", for "EndInvoke" to type "System.IAsyncResult": "Cannot convert the 
"@{PowerShell=System.Management.Automation.PowerShell; RunSpace=System.Management.Automation.PowerShellAsyncResult}" value of type "System.Management.Automation.PSCustomObject" to type "System.IAsyncResult"."

Find-File 'D:\' '*.mp3'

Function Find-File { 
	[CmdletBinding()] 
	Param (
		[Parameter(Position = 0)] 
		[string] $RootPath , 
		[Parameter(Position = 1)] 
		[string] $SearchPattern 
	) 
	
	Begin { 
		$SearchOption = [System.IO.SearchOption]::TopDirectoryOnly # Do not change!              
		$Result = @() 
		Try { 
			$RootDir = [System.IO.DirectoryInfo]::new($RootPath) 
		} Catch { 
			$null 
		} 
		[System.Collections.ArrayList] $RunspaceCollection = @() 
		$MaxThreads = 30
		$InitialSessionState = [initialsessionstate]::CreateDefault() 
		$InitialSessionState.ImportPSModule($PSCommandPath) 
		
		$RunspacePool = [runspacefactory]::CreateRunspacePool(1 , $MaxThreads , $InitialSessionState , $Host) 
		$RunspacePool.Open() # Open runspace pool to be able to add runspaces          
	} 
	
	Process { 
		Try { 
			$RootDirFolders = [System.IO.Directory]::EnumerateDirectories($RootDir.FullName , '*' , $SearchOption) 
			[System.IO.Directory]::EnumerateFiles($RootDir.FullName , $SearchPattern , $SearchOption) 
			
			Foreach ($RootDirFolder In $RootDirFolders) { 
				$PowerShell = [powershell]::Create($InitialSessionState) # Create new powershell instance/runspace                                   
				$PowerShell.RunSpacePool = $RunspacePool # Assign new instance/runspace to runspace pool        
				
				$Parameters = @{ # Define parameters for the runspace                     
					RootPath = $RootDirFolder 
					SearchPattern = $SearchPattern 
				} 
				
				#[void] $PowerShell.AddCommand("Import-Module",$false).AddParameter("Name",$PSCommandPath).Invoke()  
				#[void] $PowerShell.AddCommand('Import-Module').AddParameters(@{$PSCommandPath).BeginInvoke()  
				[void] $PowerShell.AddCommand("Find-File").AddParameter($Parameters) 
				
				
				$RunspaceCollection+= New-Object PSObject -Property @{ 
					PowerShell = $PowerShell 
					RunSpace = $PowerShell.BeginInvoke() # Invoke ScriptBlock of the runspace                                  
				} 
				
			} 
		} Catch { 
			write-host($_) -ForegroundColor Red 
		} 
	} 
	
	End { 
		While ($RunspaceCollection) { # While collection is not $null/$empty                              
			$RunspacesNotYetReturned = $RunspaceCollection | ? { $_.Runspace.IsCompleted -eq $true } # Filter by already completed runspaces    
			Foreach ($Runspace In $RunspacesNotYetReturned) { 
				$Runspace.PowerShell.EndInvoke($Runspace) # Return result of the runspace = ScriptBlock result                                  
				$Runspace.PowerShell.Dispose() # Dispose runspace                              
				$RunspaceCollection.Remove($Runspace) # Remove runspace from the collection                           
			} 
		} 
	} 
}

Function Find-File { 
  [CmdletBinding()] 
  Param
  (
    [Parameter(Position = 0,Mandatory)] 
    [validatescript({ $d = $_|Get-Item; $d.Exists})]
    [string] $RootPath , 
    [Parameter(Position = 1,Mandatory)] 
    [string] $SearchPattern 
  ) 
	
  Begin { 
    # Remember ErrorActionPreference, then switch to STOP mode
    [System.Management.Automation.ActionPreference] $eaP = $ErrorActionPreference
    #$ErrorActionPreference = [System.Management.Automation.ActionPreference]::Stop
    
  
    [System.IO.SearchOption] $SearchOption = [System.IO.SearchOption]::TopDirectoryOnly # Do not change!              
    [object[]] $Result = @() 
    Try 
    { 
      $RootDir = [System.IO.DirectoryInfo]::new($RootPath) 
    }
    Catch # "Eigentlich" sollte es dank Parametervalidierung hier nichts mehr geben, aber...
    { 
      write-warning -Message ('{0}' -f $_.exception.message)
    } 
    [System.Collections.ArrayList] $RunspaceCollection = [System.Collections.ArrayList]::new()
    $MaxThreads = 30
    [initialsessionstate] $InitialSessionState = [initialsessionstate]::CreateDefault() 
    $InitialSessionState.ImportPSModule($PSCommandPath) 
		
    [System.Management.Automation.Runspaces.RunspacePool]$RunspacePool = [runspacefactory]::CreateRunspacePool(1 , $MaxThreads , $InitialSessionState , $Host) 
    $RunspacePool.Open() # Open runspace pool to be able to add runspaces          
  } 
	
  Process { 
    Try { 
      [System.Collections.Generic.IEnumerable[string]]$RootDirFolders = [System.IO.Directory]::EnumerateDirectories($RootDir.FullName , '*' , $SearchOption) 
      [System.IO.Directory]::EnumerateFiles($RootDir.FullName , $SearchPattern , $SearchOption) 
			
      Foreach ($RootDirFolder In $RootDirFolders) { 
        [powershell]$PowerShell = [powershell]::Create($InitialSessionState) # Create new powershell instance/runspace                                   
        $PowerShell.RunSpacePool = $RunspacePool # Assign new instance/runspace to runspace pool        
				
        [hashtable]$Parameters = @{ # Define parameters for the runspace                     
          RootPath = $RootDirFolder 
          SearchPattern = $SearchPattern 
        } 
				
        #[void] $PowerShell.AddCommand("Import-Module",$false).AddParameter("Name",$PSCommandPath).Invoke()  
        #[void] $PowerShell.AddCommand('Import-Module').AddParameters(@{$PSCommandPath).BeginInvoke()  
        [void] $PowerShell.AddCommand("Find-File").AddParameters($Parameters) 
				
        [System.IAsyncResult] $Thread = $PowerShell.BeginInvoke()
				
        $RunspaceCollection+= New-Object PSObject -Property @{ 
          PowerShell = $PowerShell 
          RunSpace = $Thread # Invoke ScriptBlock of the runspace                                  
        } 
				
      } 
    } Catch { 
      write-warning -message ('{0}' -f$_.exception.message) 
    } 
        
  } # Process
	
  End { 
    While ($RunspaceCollection) { # While collection is not $null/$empty                              
      $RunspacesNotYetReturned = $RunspaceCollection | ? { $_.Runspace.IsCompleted } # Filter by already completed runspaces    
      Foreach ($Runspace In $RunspacesNotYetReturned) { 

        [System.IAsyncResult] $Thread = $Runspace.Runspace
        
        
        $Runspace.PowerShell.EndInvoke($Thread) # Return result of the runspace = ScriptBlock result                                  
        $Runspace.PowerShell.Dispose() # Dispose runspace                              
        $RunspaceCollection.Remove($Runspace) # Remove runspace from the collection                           
      } 
      
      $RunspacePool.Close()
    } 
  } # end 
} #find-file

$subtasks = $problem | split-subtasks
 #zerlegt das Gesamtproblem in Teilaufgaben => split-subtasks ist notwendigerweise anwendungsspezifisch

$taskCollection = $subtasks | start-thread
 # $subtasks ist irgendwas IEnumerable, damit start-Thread für jeden einzelnen Subtasks in PROCESS{} was zu tun bekommt; $taskCollection hält dann die Sammlung von (PowerShell; RunSpace)-Zuordnungen

 sync-Thread -TaskCollection $taskCollection
# sync-thread verändert die TaskCollection nicht, sondern wartet nur darauf, daß alle Tasks abgeschlossen werden - Statusinfo in Sync-Thread optional. Das ist der Punkt, wo man das nicht an die Pipeline verfüttern sollte; der einzelne Task ist uninteressant, es interessiert nur, daß am Ende keiner mehr läuft und individuelle Abarbeitung per Pipeline würde nur stören
$results = $taskCollection | End-Thread
# $taskCollection ist nach wie vor die Sammlung aller Tasks; entsprechend wird PROCESS{} wieder einen Task nach dem anderen abarbeiten und sein individuelles Ergebnis zurückliefern

$finalResult = $results | Join-Subtasks
# Funktion, welche die Teilergebnisse zusammensetzt (optional); das wäre dann wieder anwendungsspezifisch, genau wie Split-Tasks oben.