Calling AppDomain.DoCallback from Powershell

First thought: Don't fool AppDomains at all and don't use an entirely separate process. They are (relatively) easy to run from PowerShell, at least. The downside is that it is potentially much slower if you are doing this for a lot of files.

$myAssemblyPath = "C:\..." 
$getImageRuntimeVersion = {
    [Reflection.Assembly]::ReflectionOnlyLoadFrom($input).ImageRuntimeVersion
}
$encodedCommand = [Convert]::ToBase64String(
    [Text.Encoding]::Unicode.GetBytes($getImageRuntimeVersion)
)
$imageRuntimeVersion = $myAssemblyPath | powershell -EncodedCommand $encodedCommand

      

        
        
        
      

    

So, isn't there a general way to do this with AppDomains in PowerShell? Well, there is, but it's ugly. You can't use AppDomain.DoCallBack

because, as you discovered, PowerShell can't remove delegates this way (because under the covers, it creates dynamic methods).

However, it's easy to host the PowerShell runtime, and all PowerShell objects know how to serialize (a requirement for cross-domain remoting), so calling a PowerShell script on a different AppDomain is pretty simple (but still ugly):

$scriptInvokerAssembly = [System.IO.Path]::GetTempFileName() + ".dll"
Add-Type -OutputAssembly $tempAssembly -TypeDefinition @"
  using System;
  using System.Reflection;
  using System.Collections.Generic;
  using System.Management.Automation;

  public class ScriptInvoker : MarshalByRefObject {
    public IEnumerable<PSObject> Invoke(ScriptBlock scriptBlock, PSObject[] parameters) {
      using (var powerShell = PowerShell.Create()) {
        powerShell.Commands.AddScript(scriptBlock.ToString());
        if (parameters != null) {
          powerShell.AddParameters(parameters);
        }
        return powerShell.Invoke();
      }
    }
  }
"@
[Reflection.Assembly]::LoadFile($scriptInvokerAssembly) | Out-Null

Function Invoke-CommandInTemporaryAppDomain([ScriptBlock] $s, [object[]] $arguments) {
  $setup = New-Object System.AppDomainSetup
  $setup.ApplicationBase = Split-Path ([ScriptInvoker].Assembly.Location) -Parent
  $domain = [AppDomain]::CreateDomain([Guid]::NewGuid(), $null, $setup)
  $scriptInvoker = $domain.CreateInstanceAndUnwrap(
     [ScriptInvoker].Assembly.FullName, [ScriptInvoker]
  );
  $scriptInvoker.Invoke($s, $arguments)
  [AppDomain]::Unload($domain)
}

      

        
        
        
      

    

And now you can do

Invoke-CommandInTemporaryAppDomain { 
  [Reflection.Assembly]::ReflectionOnlyLoadFrom($args[0]).ImageRuntimeVersion 
} $myAssemblyPath

      

        
        
        
      

    

Please note that we need to create a temporary assembly on disk and AppDomain

load it there. It's ugly, but you can't create the Add-Type

assembly in memory, and even if you end up getting byte[]

to load it in a different AppDomain, it's nothing but trivial because you can't intercept AppDomain.AssemblyResolve

in PowerShell. If this command was packaged into a module, you have prebuilt the assembly containing it ScriptInvoker

, so I do not consider it a priority.