Uso de ensamblajes lado a lado para cargar la versión x64 o x32 de una DLL

He creado una solución simple que es capaz de cargar el ensamblaje específico de la plataforma desde un ejecutable compilado como AnyCPU. La técnica utilizada se puede resumir de la siguiente manera:

1. Asegúrese de que el mecanismo de carga predeterminado del ensamblaje. NET (motor"Fusion") no pueda encontrar la versión x86 o x64 del ensamblaje específico de la plataforma
2. Antes de que la aplicación principal intente cargar el ensamblado específico de la plataforma, instale un solucionador de ensamblado personalizado en el AppDomain actual
3. Ahora cuando la aplicación principal necesita el ensamblaje específico de la plataforma, Fusion engine se rendirá (debido al paso 1) y llamará a nuestro solucionador personalizado (debido al paso 2); en el solucionador personalizado determinamos la plataforma actual y usamos la búsqueda basada en directorios para cargar la DLL adecuada.

Para demostrar esta técnica, adjunto un breve tutorial basado en la línea de comandos. Probé los binarios resultantes en Windows XP x86 y luego Vista SP1 x64 (copiando los binarios, al igual que su despliegue).

Nota 1 : "csc.exe " es un compilador C-sharp. Este tutorial asume que está en su camino (mis pruebas estaban usando "C:\WINDOWS\Microsoft.NET\Framework\v3.5\csc.exe")

Nota 2 : Le recomiendo que cree una carpeta temporal para las pruebas y ejecute la línea de comandos (o powershell) cuyo directorio de trabajo actual esté establecido en esta ubicación, por ejemplo,

(cmd.exe)
C:
mkdir \TEMP\CrossPlatformTest
cd \TEMP\CrossPlatformTest

Paso 1: El ensamblado específico de la plataforma está representado por una clase C# simple biblioteca:

// file 'library.cs' in C:\TEMP\CrossPlatformTest
namespace Cross.Platform.Library
{
    public static class Worker
    {
        public static void Run()
        {
            System.Console.WriteLine("Worker is running");
            System.Console.WriteLine("(Enter to continue)");
            System.Console.ReadLine();
        }
    }
}

Paso 2 : Compilamos ensamblados específicos de la plataforma utilizando comandos simples de línea de comandos:

(cmd.exe from Note 2)
mkdir platform\x86
csc /out:platform\x86\library.dll /target:library /platform:x86 library.cs
mkdir platform\amd64
csc /out:platform\amd64\library.dll /target:library /platform:x64 library.cs

Paso 3: El programa principal se divide en dos partes. "Bootstrapper" contiene el punto de entrada principal para el ejecutable y registra un solucionador de ensamblado personalizado en appdomain actual:

// file 'bootstrapper.cs' in C:\TEMP\CrossPlatformTest
namespace Cross.Platform.Program
{
    public static class Bootstrapper
    {
        public static void Main()
        {
            System.AppDomain.CurrentDomain.AssemblyResolve += CustomResolve;
            App.Run();
        }

        private static System.Reflection.Assembly CustomResolve(
            object sender,
            System.ResolveEventArgs args)
        {
            if (args.Name.StartsWith("library"))
            {
                string fileName = System.IO.Path.GetFullPath(
                    "platform\\"
                    + System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")
                    + "\\library.dll");
                System.Console.WriteLine(fileName);
                if (System.IO.File.Exists(fileName))
                {
                    return System.Reflection.Assembly.LoadFile(fileName);
                }
            }
            return null;
        }
    }
}

"Programa" es la implementación "real" de la aplicación (tenga en cuenta que la aplicación.Run fue invocado al final de Bootstrapper.Principal):

// file 'program.cs' in C:\TEMP\CrossPlatformTest
namespace Cross.Platform.Program
{
    public static class App
    {
        public static void Run()
        {
            Cross.Platform.Library.Worker.Run();
        }
    }
}

Paso 4: Compilar la aplicación principal en la línea de comandos:

(cmd.exe from Note 2)
csc /reference:platform\x86\library.dll /out:program.exe program.cs bootstrapper.cs

Paso 5: Hemos terminado. La estructura del directorio que hemos creado debe ser la siguiente:

(C:\TEMP\CrossPlatformTest, root dir)
    platform (dir)
        amd64 (dir)
            library.dll
        x86 (dir)
            library.dll
    program.exe
    *.cs (source files)

Si ahora ejecuta programa.exe en una plataforma de 32 bits, platform \ x86 \ library.dll se cargará; si ejecuta el programa.exe en una plataforma de 64 bits, platform \ amd64 \ library.dll se cargará. Tenga en cuenta que he añadido Consola.ReadLine() al final del Worker.Ejecutar método para que pueda utilizar el administrador de tareas / explorador de procesos para investigue las DLL cargadas, o puede usar Visual Studio/Depurador de Windows para adjuntarlas al proceso para ver la pila de llamadas, etc.

Cuando programa.se ejecuta exe, nuestro solucionador de ensamblaje personalizado se adjunta al appdomain actual. Tan pronto como. NET comienza a cargar la clase Program, ve una dependencia en el ensamblado 'library', por lo que intenta cargarlo. Sin embargo, no se encuentra tal ensamblaje (porque lo hemos escondido en los subdirectorios platform/*). Afortunadamente, nuestro solucionador personalizado conoce nuestro truco y se basa en plataforma actual intenta cargar el ensamblado desde el subdirectorio platform/* apropiado.