71

这是情况,我在我的 dot.net 应用程序中使用基于 C 的 dll。有 2 个 dll,一个是 32 位的,称为 MyDll32.dll,另一个是 64 位的版本,称为 MyDll64.dll。

有一个静态变量保存 DLL 文件名:字符串 DLL_FILE_NAME。

它的使用方式如下:

[DllImport(DLL_FILE_NAME, CallingConvention=CallingConvention.Cdecl, EntryPoint=Func1")]
private static extern int is_Func1(int var1, int var2);

到目前为止很简单。

可以想象,软件是在“Any CPU”开启的情况下编译的。

我也有以下代码来确定系统应该使用 64 位文件还是 32 位文件。

#if WIN64
        public const string DLL_FILE_NAME = "MyDll64.dll";
#else
        public const string DLL_FILE_NAME = "MyDll32.dll";        
#endif

现在您应该看到问题了。DLL_FILE_NAME 是在编译时定义的,而不是在执行时定义的,因此不会根据执行上下文加载正确的 dll。

处理这个问题的正确方法是什么?我不想要两个执行文件(一个用于 32 位,另一个用于 64 位)?如何在 DllImport 语句中使用DLL_FILE_NAME之前设置它?

4

9 回答 9

70

我发现最简单的方法是导入具有不同名称的两种方法,然后调用正确的方法。在调用之前不会加载 DLL,所以没关系:

[DllImport("MyDll32.dll", EntryPoint = "Func1", CallingConvention = CallingConvention.Cdecl)]
private static extern int Func1_32(int var1, int var2);

[DllImport("MyDll64.dll", EntryPoint = "Func1", CallingConvention = CallingConvention.Cdecl)]
private static extern int Func1_64(int var1, int var2);

public static int Func1(int var1, int var2) {
    return IntPtr.Size == 8 /* 64bit */ ? Func1_64(var1, var2) : Func1_32(var1, var2);
}

当然,如果你有很多导入,手动维护会变得相当麻烦。

于 2012-06-01T15:08:28.610 回答
67

这是另一种选择,它要求两个 DLL 具有相同的名称并放置在不同的文件夹中。例如:

  • win32/MyDll.dll
  • win64/MyDll.dll

LoadLibrary诀窍是在 CLR 执行之前手动加载 DLL 。然后它会看到 aMyDll.dll已经加载并使用它。

这可以在父类的静态构造函数中轻松完成。

static class MyDll
{
    static MyDll()
    {            
        var myPath = new Uri(typeof(MyDll).Assembly.CodeBase).LocalPath;
        var myFolder = Path.GetDirectoryName(myPath);

        var is64 = IntPtr.Size == 8;
        var subfolder = is64 ? "\\win64\\" : "\\win32\\";

        LoadLibrary(myFolder + subfolder + "MyDll.dll");
    }

    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibrary(string dllToLoad);

    [DllImport("MyDll.dll")]
    public static extern int MyFunction(int var1, int var2);
}

编辑 2017/02/01Assembly.CodeBase即使启用了影子复制,也可以使用它。

于 2015-06-04T14:07:31.040 回答
17

在这种情况下,我应该这样做(制作 2 个文件夹,x64 和 x86 + 将相应的 dll 同名放在两个文件夹中):

using System;
using System.Runtime.InteropServices;
using System.Reflection;
using System.IO;

class Program {
    static void Main(string[] args) {
        var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
        path = Path.Combine(path, IntPtr.Size == 8 ? "x64" : "x86");
        bool ok = SetDllDirectory(path);
        if (!ok) throw new System.ComponentModel.Win32Exception();
    }
    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern bool SetDllDirectory(string path);
}
于 2015-06-29T12:24:33.870 回答
8

有一个静态变量保存 DLL 文件名

它不是静态变量。这是一个常数,在编译时。您不能在运行时更改编译时间常数。

处理这个问题的正确方法是什么?

老实说,我建议只针对 x86 而忘记 64 位版本,让您的应用程序在 WOW64 上运行,除非您的应用程序迫切需要以 x64 运行。

如果需要 x64,您可以:

  • 将 DLL 更改为具有相同名称,例如MyDll.dll,并在安装/部署时,将正确的名称放在适当的位置。(如果操作系统是 x64,部署 DLL 的 64 位版本,否则部署 x86 版本)。

  • 总共有两个单独的构建,一个用于 x86,一个用于 x64。

于 2012-06-01T15:02:04.260 回答
2

您所描述的内容被称为“并行程序集”(同一程序集的两个版本,一个是 32 位,另一个是 64 位)...我认为您会发现这些很有帮助:

在这里,您可以找到适合您的方案的演练(.NET DLL 包装 C++/CLI DLL 引用本机 DLL)。

推荐:

只需将其构建为 x86 并完成它......或者有 2 个构建(一个 x86 和一个 x64)......因为上述技术相当复杂......

于 2012-06-01T15:03:56.420 回答
2

另一种方法可能是

public static class Sample
{
    public Sample()
    {

        string StartupDirEndingWithSlash = System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName) + "\\";
        string ResolvedDomainTimeFileName = StartupDirEndingWithSlash + "ABCLib_Resolved.dll";
        if (!File.Exists(ResolvedDomainTimeFileName))
        {
            if (Environment.Is64BitProcess)
            {
                if (File.Exists(StartupDirEndingWithSlash + "ABCLib_64.dll"))
                    File.Copy(StartupDirEndingWithSlash + "ABCLib_64.dll", ResolvedDomainTimeFileName);
            }
            else
            {
                if (File.Exists(StartupDirEndingWithSlash + "ABCLib_32.dll"))
                    File.Copy(StartupDirEndingWithSlash + "ABCLib_32.dll", ResolvedDomainTimeFileName);
            }
        }
    }

    [DllImport("ABCLib__Resolved.dll")]
    private static extern bool SomeFunctionName(ref int FT);
}
于 2015-07-01T14:20:55.730 回答
0

我使用了 vcsjones 所指的一种方法:

“将 DLL 更改为具有相同名称,例如 MyDll.dll,并在安装/部署时,将正确的名称放在适当的位置。”

这种方法需要维护两个构建平台,但请参阅此链接了解更多详细信息:https ://stackoverflow.com/a/6446638/38368

于 2012-06-03T10:12:32.610 回答
0

我用于V8.Net的技巧是这样的:

  1. 使用所有定义创建一个新的 C#“代理接口”项目,以在不同的体系结构之间切换。在我的情况下,该项目被命名为V8.Net-ProxyInterface;例子:
 public unsafe static class V8NetProxy
    {
    #if x86
            [DllImport("V8_Net_Proxy_x86")]
    #elif x64
            [DllImport("V8_Net_Proxy_x64")]
    #else
            [DllImport("V8_Net_Proxy")] // (dummy - NOT USED!)
    #endif
            public static extern NativeV8EngineProxy* CreateV8EngineProxy(bool enableDebugging, void* debugMessageDispatcher, int debugPort);

这是您将参考的项目。不要参考接下来的两个:

  1. 再创建两个项目以生成库的 x64 和 x86 版本。这很简单:只需复制粘贴即可将.csproj文件复制到同一文件夹中并重命名它们。在我的情况下,项目文件被重命名为V8.Net-ProxyInterface-x64and V8.Net-ProxyInterface-x86,然后我将项目添加到我的解决方案中。在 Visual Studio 中打开每个项目的项目设置,并确保Assembly Name名称中包含 x64 或 x86。此时您有 3 个项目:第一个“占位符”项目和 2 个特定于架构的项目。对于 2 个新项目:

    a) 打开 x64 接口项目设置,进入选项卡,在顶部Build选择All Platformsfor ,然后输入.Platformx64Conditional compilation symbols

    b) 打开 x86 接口项目设置,进入选项卡,在顶部Build选择All Platformsfor ,然后输入.Platformx86Conditional compilation symbols

  2. 打开Build->Configuration Manager...并确保它x64被选为 x64 项目的平台,并被x86选为 x86 项目的 BOTH DebugANDRelease配置。

  3. 确保 2 个新的接口项目(用于 x64 和 x86)输出到宿主项目的相同位置(参见项目设置Build->Output path)。

  4. 最后的魔法:在我的引擎的静态构造函数中,我快速附加到程序集解析器:

static V8Engine()
{
    AppDomain.CurrentDomain.AssemblyResolve += Resolver;
}

在该Resolver方法中,我只是根据当前进程指示的当前平台加载文件(注意:此代码是精简版,未经测试):

var currentExecPath = Assembly.GetExecutingAssembly().Location;
var platform = Environment.Is64BitProcess ? "x64" : "x86";
var filename = "V8.Net.Proxy.Interface." + platform + ".dll"
return Assembly.LoadFrom(Path.Combine(currentExecPath , fileName));

最后,在解决方案资源管理器中转到您的宿主项目,展开References,选择您在步骤 1 中创建的第一个虚拟项目,右键单击它以打开属性,然后设置Copy Localfalse. 这允许您为每个 P/Invoke 函数使用一个名称进行开发,同时使用解析器来确定实际加载哪个名称。

请注意,程序集加载器仅在需要时运行。它仅在第一次访问引擎类时由 CLR 系统自动触发(在我的情况下)。这如何转化为您取决于您​​的宿主项目的设计方式。

于 2019-03-04T21:08:17.860 回答
-1

我认为这有助于动态加载 DLL:

   #if X64    
    [DllImport("MyDll64.dll", CallingConvention=CallingConvention.Cdecl, EntryPoint=Func1")]
    #else
    [DllImport("MyDll32.dll", CallingConvention=CallingConvention.Cdecl, EntryPoint=Func1")]
    #endif
    private static extern int is_Func1(int var1, int var2);
于 2020-06-18T05:57:43.437 回答