zoukankan      html  css  js  c++  java
  • 【C#】 使用Gsof.Native 动态调用 C动态库

    【C#】 使用Gsof.Native 动态调用 C动态库

    一、背景

    使用C# 开发客户端时候,我们经常会调用一些标准的动态库或是C的类库。
    虽然C# 提供的PInvoke的方式,但因为使用的场景的多变,有些时候可能没办法,固定位置的调用,或是需要按需求调用不同的库。 设置当前目录的方式,有时会有加载不到的问题。
    CLI的方式又需要用C++做再次的封装。

    二、说明

    1. 支持根据路径动态加载DLL类库
    2. 支持using 销毁加载的类库
    3. 调用方便

    github: https://github.com/gaoshang212/gsof/tree/master/Gsof.Native

    nuget: https://www.nuget.org/packages/Gsof.Native/

    接口说明:

    NativeFactory 创建INative调用对象:

    /// <summary>
    /// 创建INative 对象
    /// </summary>
    /// <param name="p_fileName">文件路径</param>
    /// <returns></returns>
    public static INative Create(string p_fileName);
    
    /// <summary>
    /// 创建INative 对象
    /// </summary>
    /// <param name="p_fileName">文件路径</param>
    /// <param name="p_calling">调用转换方式(同PInvoke CallingConvention)/param>
    /// <returns></returns>
    public static INative Create(string p_fileName, CallingConvention _calling);
    
    /// <summary>
    /// 销毁INative, 也可以调用 Native的Dispose方法
    /// </summary>
    /// <param name="p_native"></param>
    public static void Free(INative p_native);
    

    INative:

    public interface INative : IDisposable
    {
        /// <summary>
        /// 获取函数委托
        /// </summary>
        /// <typeparam name="TDelegate"></typeparam>
        /// <returns></returns>
        TDelegate GetFunction<TDelegate>();
        /// <summary>
        /// 函数委托调用方式
        /// </summary>
        /// <typeparam name="TResult">返回值类型</typeparam>
        /// <typeparam name="TDelegate">函数对应的委托类型</typeparam>
        /// <param name="p_params">函数传参</param>
        /// <returns></returns>
        TResult Invoke<TResult, TDelegate>(params object[] p_params);
        /// <summary>
        /// 函数名调用
        /// </summary>
        /// <typeparam name="TResult">返回值类型</typeparam>
        /// <param name="p_funName">函数名</param>
        /// <param name="p_params">函数传参</param>
        /// <returns></returns>
        TResult Invoke<TResult>(string p_funName, params object[] p_params);
        /// <summary>
        /// 函数名调用
        /// </summary>
        /// <typeparam name="TResult">返回值类型</typeparam>
        /// <param name="p_funName">函数名</param>
        /// <param name="p_calling">调用转换方式(同PInvoke CallingConvention)</param>
        /// <param name="p_params">函数传参</param>
        /// <returns></returns>
        TResult Invoke<TResult>(string p_funName, CallingConvention p_calling, params object[] p_params);
        /// <summary>
        /// 函数名调用(非泛型)
        /// </summary>
        /// <param name="p_funName">函数名</param>
        /// <param name="p_retrunType">返回值类型</param>
        /// <param name="p_params">函数传参</param>
        /// <returns></returns>
        object Invoke(string p_funName, Type p_retrunType, params object[] p_params);
        /// <summary>
        /// 函数委托调用方式
        /// </summary>
        /// <typeparam name="TDelegate">函数对应的委托类型</typeparam>
        /// <param name="p_params">函数传参</param>
        void Call<TDelegate>(params object[] p_params);
        /// <summary>
        /// 函数名调用
        /// </summary>
        /// <param name="p_funName">函数名</param>
        /// <param name="p_params">函数传参</param>
        void Call(string p_funName, params object[] p_params);
        /// <summary>
        /// 函数名调用
        /// </summary>
        /// <param name="p_funName">函数名</param>
        /// <param name="p_calling">调用转换方式(同PInvoke CallingConvention)</param>
        /// <param name="p_params">函数传参</param>
        void Call(string p_funName, CallingConvention p_calling, params object[] p_params);
    }
    

    三、使用

    libtest.dll 为 中包括一个test函数

     int test(int input)
     {
         return input;
     }
    

    方法名调用

    
    int input = 0;
    int result = -1;
    using (var native = NativeFactory.Create(@"../../libtest.dll"))
    {
        result = native.Invoke<int>("test", input);
    }
    

    dynamic 方式调用

    • 优点:调用方便,简单类型调用时,不用做过多的定义。
    • 缺点:4.0下性能不理想,4.5+性能好很多,但相较于委托的方式,还差些。
    int input = 0;
    int result = -1;
    using (dynamic native = NativeFactory.Create(@"../../libtest.dll"))
    {
        result = native.test<int>(input);
    }
    

    委托方式调用

    • 优化:效率高,没有了第一次动态构造委托的消耗,可获取到函数委托增加 重复调用消耗
    • 缺点:如果函数较多,委托定义较为繁琐
    
    [NativeFuncton("test")]
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    delegate int Test(int p_sleep);
    
    public void DelegateFunction()
    {
        int input = 0;
        int result = -1;
        using (var native = NativeFactory.Create(@"../../libtest.dll"))
        {
            // 直接调用
            var result1 = native1.Invoke<int, Test>(input);
    
            // 获取函数委托调用 
            var test = native.GetFunction<Test>();
            result = test(input);
        }
    
        Assert.AreEqual(input, result);
    
    }
    
  • 相关阅读:
    vmware导出为ovf
    华三接入交换机推荐
    mysql root情况
    ospf精确宣告地址
    kubernetes k8s yum localinstall
    js判断邮箱、用户名、手机号码和电话号码是否输入正确?
    如何修改Oracle中表的字段长度?
    mybatis与hibernate区别
    SSM框架的优势?
    SSH框架的优势?
  • 原文地址:https://www.cnblogs.com/gaoshang212/p/8809360.html
Copyright © 2011-2022 走看看