DllImport或LoadLibrary以获得最佳性能

您的DLL可能是python或c++，无论如何，执行相同的操作。

这是你在c++中的DLL文件。

头:

extern "C" __declspec(dllexport) int MultiplyByTen(int numberToMultiply);

源代码文件

#include "DynamicDLLToCall.h"
int MultiplyByTen(int numberToMultiply)
{
    int returnValue = numberToMultiply * 10;
    return returnValue;
} 

看看下面的c#代码:

static class NativeMethods
{
    [DllImport("kernel32.dll")]
    public static extern IntPtr LoadLibrary(string dllToLoad);
    [DllImport("kernel32.dll")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    public static extern bool FreeLibrary(IntPtr hModule);
}
class Program
{
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate int MultiplyByTen(int numberToMultiply);
    static void Main(string[] args)
    {
            IntPtr pDll = NativeMethods.LoadLibrary(@"PathToYourDll.DLL");
            //oh dear, error handling here
            //if (pDll == IntPtr.Zero)
            IntPtr pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "MultiplyByTen");
            //oh dear, error handling here
            //if(pAddressOfFunctionToCall == IntPtr.Zero)
            MultiplyByTen multiplyByTen = (MultiplyByTen)Marshal.GetDelegateForFunctionPointer(
                                                                                    pAddressOfFunctionToCall,
                                                                                    typeof(MultiplyByTen));
            int theResult = multiplyByTen(10);
            bool result = NativeMethods.FreeLibrary(pDll);
            //remaining code here
            Console.WriteLine(theResult);
    }
} 

假设您的目标平台与上述本机dll相同。您可以使用DLLImport来pinvoke LoadLibrary，并使用LoadLibrary将本机dll加载到您的进程中。然后使用DllImport调用GetProcAddress。

然后您可以为您想要调用的dll中导出的所有方法定义委托。

接下来使用Marshal。GetDelegateForFunctionPointer从GetProcAddress设置委托。

创建一个静态类，在构造函数中只做一次。然后，您可以调用委托来调用dll中的本机导出函数，而无需对所有内容都使用DllImport。更干净，我很确定它更快，可能会完全绕过前面提到的参数检查。

所以你会有一个缓慢的初始化，但一旦加载，将运行得很快。

这是我的博客来源。

http://blogs.msdn.com/b/jonathanswift/archive/2006/10/03/dynamically-calling-an-unmanaged-dll-from-.net-_2800_c_23002900_.aspx

我认为DLLImport和LoadLibrary有不同的目标。如果使用本机.dll，则应该使用DllImport。如果你使用。net程序集，你应该使用LoadAssembly。

实际上，你也可以动态加载本机程序集，见下面的例子:dynamically-calling-an-unmanaged-dll-from -.net

回答这个问题的唯一方法是计算两个选项的时间，这是一项非常简单的任务。在没有时间的情况下进行性能预测是没有意义的。

因为我们没有你的代码，所以只有你能回答你的问题。

做了一个快速测试。向下滚动查看结论

头:

struct Vector2
{
public:
    float X;
    float Y;
    float GetMagnitude() const;
};
extern "C" __declspec(dllexport) float GetMagnitude(const Vector2& InVector);

来源:

#include <cmath>
float Vector2::GetMagnitude() const
{
    return sqrt((X * X) + (Y * Y));
}

管理:

// #define IMPORT // <-- comment/uncomment this to switch
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
namespace InteropTest
{
    public struct Vector2
    {
        public Vector2(float x, float y)
        {
            (_x, _y) = (x, y);
        }
    
        private float _x;
        private float _y;
    }
    [SuppressUnmanagedCodeSecurity]
    internal class Program
    {
#if IMPORT        
        [DllImport("InteropLibrary", CallingConvention = CallingConvention.Cdecl,
            CharSet = CharSet.Ansi)]
        private static extern float GetMagnitude(ref Vector2 vector);
#else
        [DllImport("kernel32")]
        public static extern IntPtr LoadLibrary(
            string path);
        [DllImport("kernel32")]
        public static extern IntPtr GetProcAddress(
            IntPtr libraryHandle,
            string symbolName);
        [DllImport("kernel32")]
        public static extern bool FreeLibrary(
            IntPtr libraryHandle);
        private static IntPtr LibraryHandle;
        [UnmanagedFunctionPointer(CallingConvention.Cdecl,
            CharSet = CharSet.Ansi)]
        private delegate float GetMagnitudeDelegate(ref Vector2 vector2);
        private static GetMagnitudeDelegate GetMagnitude;
#endif
        public static void Main(string[] args)
        {
#if !IMPORT
            LibraryHandle = LoadLibrary("./InteropLibrary.dll");
            IntPtr symbol = GetProcAddress(LibraryHandle, "GetMagnitude");
            GetMagnitude = Marshal.GetDelegateForFunctionPointer(
                symbol,
                typeof(GetMagnitudeDelegate)) as GetMagnitudeDelegate;
#endif
            var random = new Random(234);
            var sw = new Stopwatch();
            sw.Start();
            {
                for (var i = 0; i < 1000000; i++)
                {
                    var vector = new Vector2(random.Next(400), random.Next(400));
                    GetMagnitude(ref vector);
                }
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
            sw = null;
            random = null;
#if !IMPORT
            CloseLibrary(LibraryHandle);
            LibraryHandle = IntPtr.Zero;
            GetMagnitude = null;
#endif
        }
    }
}

结论

手动加载/卸载DLL的速度大约慢20%。在不同的尝试中，DllImport大约需要99-105毫秒。元帅。GetDelegateForFuncitonPointer在不同的尝试中大约需要120-125毫秒。