LegacyWrapper uses a wrapper process to call dlls from a process of the opposing architecture (X86 or AMD64).

Since you can't load a dll of another architecture directly, the wrapper utilizes a named pipe to abstract the call. You won't notice this though, because all the magic is hidden behind a single static method.

There is a NuGet package available here: Codefoundry.LegacyWrapper @ nuget.org

If you want to compile the LegacyWrapper yourself, make sure to place both the wrapper executable, LegacyWrapperClient.dll and LegacyWrapper.Common.dll in your directory.

// Define a proxy interface with matching method names and signatures
// The interface must be derived from IDisposable!
[LegacyDllImport("User32.dll")]
public interface IUser32Dll : IDisposable
{
 [LegacyDllMethod(CallingConvention = CallingConvention.Winapi)]
 int GetSystemMetrics(int nIndex);
}
// Create configuration
IWrapperConfig configuration = WrapperConfigBuilder.Create()
 .TargetArchitecture(TargetArchitecture.X86)
 .Build();
// Create new Wrapper client providing the proxy interface
// Remember to ensure a call to the Dispose()-Method!
using (var client = WrapperProxyFactory<IUser32Dll>.GetInstance(configuration))
{
 // Make calls - it's that simple!
 int x = client.GetSystemMetrics(0);
 int y = client.GetSystemMetrics(1);
}

Please note that loading a 64bit dll will only work on 64bit operating systems.

View this blog post to obtain a basic understanding of how the library works internally.

• There is also a blog post about the dynamic method call feature in LegacyWrapper 3.0.
• There is also a blog post about the new 64bit feature in LegacyWrapper 2.1.

Feel free to submit any suggestions/issues and contribute to LegacyWrapper.

Copyright (c) 2019, Franz Wimmer. (MIT License)

See LICENSE for more info.