Peço desculpas antecipadamente se o título não fizer sentido. Eu sou muito novo em domínios de aplicativos e carregamento de assembly e realmente não sei como declarar o que estou tentando perguntar.

Estou brincando com o carregamento de DLLs incorporadas em um aplicativo durante o tempo de execução e não consigo entender por que ele funciona de uma maneira, mas não da outra. Parece que, se você tentar carregar DLLs (de uma matriz de bytes) no domínio do aplicativo atual, qualquer objeto / thread criado depois poderá resolver as referências da biblioteca recém-carregada, mas os objetos no contexto original não serão resolvidos no diretório biblioteca recém-carregada.

Aqui está minha biblioteca de exemplo que será carregada como um recurso incorporado durante o tempo de execução (requer uma referência ao WPF PresentationFramework.dll for MessageBox):

namespace LoaderLibrary
{
    public class LoaderLibrary
    {
        public static void Test()
        {
            System.Windows.MessageBox.Show("success");
        }
    }
}

No arquivo .csproj do meu aplicativo de console, euadicione manualmente o seguinte recurso incorporado para esse projeto eincluir uma referência de projeto para LoaderLibrary também:

  <ItemGroup>
    <EmbeddedResource Include="..\LoaderLibrary\bin\$(Configuration)\LoaderLibrary.dll">
      <LogicalName>EmbeddedResource.LoaderLibrary.dll</LogicalName>
    </EmbeddedResource>
  </ItemGroup>

Aqui está o código para meu aplicativo de console que carrega essa biblioteca (requer uma referência de projeto ao csproj LoaderLibrary) ALÉM DISSO: Precisa definirCopyLocal parafalso para referência LoaderLibrary:

namespace AssemblyLoaderTest
{
    class Program
    {
        static void Main(string[] args)
        {
            EmbeddedAssembly.Load("EmbeddedResource.LoaderLibrary.dll");
            System.AppDomain.CurrentDomain.AssemblyResolve += (s, a) => { return EmbeddedAssembly.Get(a.Name); };

            var app = new TestApp();
        }
    }

    public class TestApp
    {
        public TestApp()
        {
            LoaderLibrary.LoaderLibrary.Test();            
        }
    }

    public class EmbeddedAssembly
    {
        static System.Collections.Generic.Dictionary<string, System.Reflection.Assembly> assemblies = new System.Collections.Generic.Dictionary<string, System.Reflection.Assembly>();
        public static void Load(string embeddedResource)
        {
            using (System.IO.Stream stm = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedResource))
            using (var mstream = new System.IO.MemoryStream())
            {
                stm.CopyTo(mstream);
                var assembly = System.Reflection.Assembly.Load(mstream.ToArray());
                assemblies.Add(assembly.FullName, assembly);
                return;
            }
        }

        public static System.Reflection.Assembly Get(string assemblyFullName)
        {
            return (assemblies.Count == 0 || !assemblies.ContainsKey(assemblyFullName)) ? null : assemblies[assemblyFullName];
        }
    }
}

Esse código é capaz de carregar e executar com êxito a função LoaderLibrary.LoaderLibrary.Test ().

Minha pergunta é por que o seguinte não funciona?

static void Main(string[] args)
{
    EmbeddedAssembly.Load("EmbeddedResource.LoaderLibrary.dll");
    System.AppDomain.CurrentDomain.AssemblyResolve += (s, a) => { return EmbeddedAssembly.Get(a.Name); };

    LoaderLibrary.LoaderLibrary.Test(); // very unhappy line of code
}

Isso também não funciona:

static void Main(string[] args)
{
    EmbeddedAssembly.Load("EmbeddedResource.LoaderLibrary.dll");
    System.AppDomain.CurrentDomain.AssemblyResolve += (s, a) => { return EmbeddedAssembly.Get(a.Name); };

    var app = new TestApp();
    LoaderLibrary.LoaderLibrary.Test(); // very unhappy line of code
}