平台调用 (P/Invoke)：托管代码（C#）调用非托管代码（C/C++）

标签：调用 int 代码 托管 System C++ C# linux

  首先，本文基于.net6来实现C#代码来调用C/C++程序（VS2022），主要从三个角度来说明：简单的调用实现、自定义类和结构体、回调函数。

  其次，C#调用C/C++一般是通过调用C/C++的动态连接库来实现的，而windows和linux、macos下的动态链接库是有区别的，后面再说，所以本文以动态链接库来实现调用

  最后，你可能会问，C#能调用C/C++，那么C/C++能反过来调用C#么？其实在一定条件下也是可以的，但是C/C++与C#原理差别太大，C#比C/C++更高级，所以一般不会反着来，其次，都用C/C++为什么还要用C#呢？

  本文Demo例子源码下载：https://pan.baidu.com/s/1YcvKbxmvub5yG69AkucIww （提取码：1qeb）

  准备

  介绍之前，我们需要先创建项目，首先，新建一个C#控制台项目，也可以是其它项目，取个名称，我这里叫CSharpConsole：

  

  为了后续的方便，我们可以直接引用C/C++的库，我们调整一下，右键项目=》【编辑项目文件】，输入下面的内容：  

	<ItemGroup>
		<None Include="..\lib\*.*" Link="lib\%(Filename)%(Extension)" />
	</ItemGroup>
	<ItemGroup>
		<None Update="..\lib\*.*">
			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
		</None>
	</ItemGroup>

  右键项目=》【属性】=》【生成】=》【常规】=》勾选不安全代码，或者【编辑项目文件】，在第一个PropertyGroup节点下添加一个节点：

  <AllowUnsafeBlocks>True</AllowUnsafeBlocks>

  这么做是因为后面会介绍一些指针的东西，完整的结果：

  

  注：这里修改项目文件是非必须的，主要为了后续的方便演示，当生成项目时，动态库文件会自动生成到../lib目录下，这样就可以直接引用加载了

  接着新建一个C++的项目，可以是空项目，也可以是一个动态链接库项目，这里以空项目介绍，空项目改一些配置就成了动态库项目：

  

  注：windows和linux使用的是不同的空项目

  这里我创建了window和linux的两种动态库项目，为了方便演示，分别取名Project-win和Project-linux。

  接着设置项目配置类型为动态库：右键项目=》【属性】=》【常规】=》【配置类型】

  为了方便，我们这里还设置了输出目录（$(SolutionDir)\lib），这样方便我们后续的使用，与上面CSharpConsole项目读取动态库对应起来

  

  注：windows下的动态库是以dll为后缀，linux则是以so为后缀，此外如果是linux的动态库项目，那么就需要在linux系统里面去编译，所以编译需要linux的环境，我们可以在【工具】=》【选项】=》【跨平台】=》【连接管理器】中添加一个linux系统的连接，或者在项目生成的时候，会弹框要求填写一个连接：

  

  此外，既然是编译，那么自然就还要求这个环境已经部署好了C++的编译环境，所以我们需要安装g++，我这边使用的是ubuntu20.04，所以我直接使用apt安装了：

    # ubuntu
    sudo apt install g++
    # centos
    sudo yum install gcc-c++

  最后分别在Project-win和Project-linux两个项目中添加一个源文件和头文件，比如我这里都叫demo.cpp和demo.h，然后生成项目，最后的项目结构是这个样子的：

  

  注：linux下的动态库文件只有一个.so文件，文件名默认是：lib[项目名].so，windows下的动态库文件有三个（.dll，.lib，.exp）,但是最终有用的只有.dll文件，文件名默认是：[项目名].dll，如果要修改生成的动态库文件名，右键项目=》【属性】=》【常规】=》【模板文件名】修改即可，但是不建议修改，如果要修改，也是建议修改成一样的名称

 

  简单的调用实现

  准备工作做完了，我们来实现一个简单的调用逻辑，也就实现一个加法计算吧！

  首先，我们编写头文件demo.h，如果是windows下的动态库，那么编辑Project-win下面的demo.h，linux的动态库则编辑Project-linux下面的demo.h:  

  Project-win:

    #pragma once

    extern "C" __declspec(dllexport) int Plus(int n1, int n2);

  Project-linux:  

    #pragma once

    extern "C"  int Plus(int n1, int n2);

  注：后续的demo.h中都是Project-win下的，Project-linux下的就是比Project-win少了__declspec(dllexport)部分

  然后分别在两个demo.cpp中编辑：

  demo.cpp：  

    #include "demo.h"

    int Plus(int n1, int n2)
    {
        return n1 + n2;
    }

  最后生成一遍，编译后的动态库就会放到我们解决方案的下的lib目录下，也就是前面创建项目时修改的输出目录，它也是CSharpConsole项目添加的一个链接目录，这样，我们动态库就编译好准备好了。

  注：这里有一个重点，而且目前还有一些疑惑

  先说说上面几个代码的含义：  

    #pragma once      //预编译指令，保证头文件只被编译一次，多以去掉也没关系
    extern        //extern置于变量或者函数前，以标示变量或者函数的定义在别的文件中，这里只是声明
    "C"          //完整的应该是extern "C"这种写法，表示采用C的标准，使用C的编译器来编译而不是C++的编译器
    __declspec(dllexport)  //__declspec是一种扩展属性的定义，一般在windows环境下使用，__declspec(dllexport)表示当前函数可以导出被其它库使用，与之对应的__declspec(dllimport)表示当前函数由外部导入
    
    这里我有一点疑惑，就是这里无论是__declspec(dllexport)还是__declspec(dllimport)都是可以的，可以正确的导出函数供外部调用。

  虽然我们可以通过一些预编译指令来简化这种写法，但是这三项是必须的（linux是两项）,如果缺少，则可能报：Unable to find an entry point named 'XXX' in DLL 'XXXX'

  当我们发现这种错误时，说明没有在指定的dll中没有找到对应名称的入口，这时，我们可以使用VS自带的命令行工具来检测：

  

  输入命令：dumpbin /exports 【动态库文件】

  比如我这里执行后的结果是：

  

  上图中的Plus就是导出的函数名，如果在demo.h中声明的函数没有"C"选项，那么导出函数名是：

  

  此时你会发现，导出的函数名是?Plus@@YAHHH@Z，这就是找不到指定名称入口的原因！其实，这就是C++编译的一个特性导致的。  

  好了，现在我们可以调用动态库了，我们使用DllImport特性来声明动态库的引入，CSharpConsole中Program完整的调用代码如下：  

    using System.Runtime.InteropServices;

    namespace CSharpConsole
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                if (OperatingSystem.IsWindows())
                {
                    var sum = WindowsPlus(1, 2);
                    Console.WriteLine("sum:" + sum);
                }
                else
                {
                    var sum = LinuxPlus(1, 2);
                    Console.WriteLine("sum:" + sum);
                }
            }

            //linux下的调用
            [DllImport("lib/Project-linux.so", EntryPoint = "Plus")]
            static extern int LinuxPlus(int n1, int n2);
            //windows下的调用
            [DllImport("lib/Project-win.dll", EntryPoint = "Plus")]
            static extern int WindowsPlus(int n1, int n2);
        }
    }

  运行即可查看到输出结果：sum:3

  这里使用到了DllImportAttribute，表示从动态库中加载函数调用，它有一个参数，表示动态库的路径，可以是一个相对路径，也可以是觉得路径，其它参数含义如下：  

    BestFitMapping：是否启用最佳映射，默认是true
    CallingConvention：指定用于传递方法参数的调用约定。 默认值为 WinAPI
    CharSet：控制名称重整以及将字符串参数封送到函数中的方式。 默认值为 CharSet.Ansi
    EntryPoint：指定要调用的 DLL 入口点
    ExactSpelling：指示是否应修改非托管 DLL 中的入口点的名称
    PreserveSig：控制托管方法签名是否应转换成返回 HRESULT 并且返回值有一个附加的 [out, retval] 参数的非托管签名，默认值为 true，即不应转换签名
    SetLastError：允许调用方使用 Marshal.GetLastWin32Error API 函数来确定执行该方法时是否发生了错误。 在 Visual Basic 中，默认值为 true；在 C# 和 C++ 中，默认值为 false。
    ThrowOnUnmappableChar：当Unicode 字符无法转换成一个 ANSI字符时，true则表示抛出异常，false则用?代替

  咋一看，这几个参数说的很迷糊，后面再开一篇博文来介绍吧，东西有点多，本文主要实现调用。

  到这里，简单的调用就基本上说完了，剩下的就是基本的类型映射，类型对上了，上面的基本调用就都能通了，这个类型的对应，有个专业的术语叫做类型封送，也就是说我们在托管代码（C#）和非托管代码之间的数据转换。

  常见类型的对应主要有：

C#类型或者关键字	C/C++类型
System.Byte、byte	uint8_t
System.SByte、sbyte	int8_t
System.Int16、short	int16_t
System.UInt16、ushort	uint16_t
System.Int32、int	int32_t
System.UInt32、uint	uint32_t
System.Int64、long	int64_t
System.UInt64、ulong	uint64_t
System.Char、char	char、char16_t、char*、char16_t*
System.IntPtr、nint	intptr_t
System.UIntPtr、nuint	uintptr_t
数组	指向数组开头的指针
System.Double	double_t
System.Text.StringBuilder	char*、char16_t*

  其实上面表格来着官方，看起来迷迷糊糊的，而且多数类型我们是不会用到的，所以现实使用时，我们可以按照下面的方式来对应，应该可以满足绝大多数的需求了：

C#类型或者关键字	C/C++类型
System.Int16、short	short
System.Int32、int	int
System.Int64、long	long
System.Single、float	float
System.Double、double	double
System.Char、char	char
System.Boolean、bool	bool
System.String、string	char*
数组	指针
委托	函数指针

  这几个是基本类型的对应，还有几点需要说明一下：

    1、C#中的bool其实就是一个整型，如果需要，可以使用int等代替
    2、C#中数组在C/C++中一般是作为一个指针接收的，比如int[]对应int*，double[]对应double*，如果是多维数组，那么就是指针的指针
    3、如果使用了数组，一般还需要一个数组的长度参数
    4、字符串的可以认为一个字符数组，所以可以使用char*接收
    5、对于C#的DateTime类型，一般来说我们是不能使用DateTime类型的，因为它不是一个简单的基础类型，解决办法有两个：
        一、将DateTime转换成tick，然后使用long类型来实现
        二、使用自定结构来实现，这个后文介绍

  一个完整的例子：

  demo.h:  

    extern "C" __declspec(dllexport) int Invoke(short s, int i, long l, float f, double d, char c, bool b, char* pc, int* pi, float* pf);

  demo.cpp:  

    #include "demo.h"
    #include "iostream"

    //..

    int Invoke(short s, int i, long l, float f, double d, char c, bool b, char* pc, int* pi, float* pf) 
    {
        printf("s=%d\n", s);
        printf("i=%d\n", i);
        printf("l=%d\n", l);
        printf("f=%g\n", f);
        printf("d=%g\n", d);
        printf("c=%c\n", c);
        printf("b=%d\n", b);
        printf("pc=%s\n", pc);
        printf("pi[0]=%d\n", pi[0]);
        printf("pf[0]=%g\n", pf[0]);
        return 0;
    }

  C#调用：

    using System.Runtime.InteropServices;

    namespace CSharpConsole
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                //..
                if (OperatingSystem.IsWindows())
                {
                    WindowsInvoke(1, 2, 3, 3.14f, 3.1415, 'A', true, "hello", new int[] { 1 }, new float[] { 3.14f });
                }
                else
                {
                    LinuxInvoke(1, 2, 3, 3.14f, 3.1415, 'A', true, "hello", new int[] { 1 }, new float[] { 3.14f });
                }
            }

            //..

            //linux下的调用
            [DllImport("lib/Project-linux.so", EntryPoint = "Invoke")]
            static extern int LinuxInvoke(short s, int i, long l, float f, double d, char c, bool b, string pc, int[] pi, float[] pf);
            //windows下的调用
            [DllImport("lib/Project-win.dll", EntryPoint = "Invoke")]
            static extern int WindowsInvoke(short s, int i, long l, float f, double d, char c, bool b, string pc, int[] pi, float[] pf);
        }
    }

 

  自定义类和结构体

  上面已经实现了C#调用C/C++的过程，但是实际开发过程中，我们会发现，调用的时候会传递很多参数，比如上面的Invoke函数的调用，这样一方面不方便使用，另一方面不方便拓展，幸运的是，C#允许我们自定义类或者结构体来实现封送，比如对于C#的DateTime，我们可以自定一个类或者结构体来实现：  

    using System.Runtime.InteropServices;

    namespace CSharpConsole
    {
        [StructLayout(LayoutKind.Sequential)]
        public class MyDateTime
        {
            public int Year { get; set; }
            public int Month { get; set; }
            public int Day { get; set; }
            public int Hour { get; set; }
            public int Minute { get; set; }
            public int Second { get; set; }
        }
    }

  自定义类型使用StructLayoutAttribute特性修饰，同时指定类型中的属性只是对应到C/C++中结构中字段的位置，有三个选择：  

    Sequential：表示顺序布局，调用时会将C#类或者结构体中的属性按照顺序放到C/C++中结构体的对应位置，这个时候，C/C++对应的结构只要类型对上就可以了，而名称可以随意
    Explicit：表示显式布局，这个时候我们需要对C#的每个字段用FieldOffsetAttribute特性来指定位置
    Auto：表示自动选择。

  这里一般都是使用顺序布局：Sequential

  接着我们需要使用C/C++定义对应的结构体和接口：

  demo.h:  

    #pragma once

    struct MyDateTime {
        int Year;
        int Month;
        int Day;
        int Hour;
        int Minute;
        int Second;
    };

    //..
    extern "C" __declspec(dllexport) int DateTime(MyDateTime myDateTime);

  demo.cpp实现接口：  

    #include "demo.h"
    #include "iostream"

    //..

    int DateTime(MyDateTime myDateTime)
    {
    	MyDateTime dt = myDateTime;
    	printf("%d-%d-%d %d:%d:%d\n", dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
    	return 0;
    }

  C#调用：

    using System.Runtime.InteropServices;

    namespace CSharpConsole
    {
        internal class Program
        {
            static unsafe void Main(string[] args)
            {
                //...
                var myDateTime = new MyDateTime() { Year = 2022, Month = 12, Day = 25, Hour = 12, Minute = 35, Second = 56 };
                if (OperatingSystem.IsWindows())
                {
                    WindowsDateTime(myDateTime);
                }
                else
                {
                    LinuxDateTime(myDateTime);
                }
            }

            //..

            //linux下的调用
            [DllImport("lib/Project-linux.so", EntryPoint = "DateTime")]
            static extern int LinuxDateTime(MyDateTime myDateTime);
            //windows下的调用
            [DllImport("lib/Project-win.dll", EntryPoint = "DateTime")]
            static extern int WindowsDateTime(MyDateTime myDateTime);
        }
    }

 

  回调函数

  上面介绍的都是对数据的操作，但是我们C#还有一个叫委托的东西，而委托本质上就是一个函数指针，这样我们同样可以使用委托来实现上述操作：

  同样，首先，我们需要定义一个C#委托类型：  

    namespace CSharpConsole
    {
        public delegate void MyDelegate(int year, MyDateTime MyDateTime);
    }

  接着我们需要使用C/C++定义对应的结构体和接口： 

  demo.h： 

    #pragma once

    struct MyDateTime {
    	int Year;
    	int Month;
    	int Day;
    	int Hour;
    	int Minute;
    	int Second;
    };

    typedef void(*MyDelegate)(int y, MyDateTime myDateTime);

    //...
    extern "C" __declspec(dllexport) int Run(int y, MyDelegate del);

  demo.cpp实现函数：  

    #include "demo.h"
    #include "iostream"

    //...

    int Run(int y, MyDelegate del)
    {
    	int i = 2020;
    	while (i <= y)
    	{
    		MyDateTime myDateTime = MyDateTime();
    		myDateTime.Year = i;
    		myDateTime.Month = 1;
    		myDateTime.Day = 1;
    		del(i, myDateTime);
    		i++;
    	}
    	return 0;
    }

  然后C#调用：

    using System.Runtime.InteropServices;

    namespace CSharpConsole
    {
        internal class Program
        {
            static unsafe void Main(string[] args)
            {
                //..
                if (OperatingSystem.IsWindows())
                {
                    WindowsRun(2023, (year, myDateTime) => Console.WriteLine($"Year:{year},DateTime:{myDateTime.Year}-{myDateTime.Month}-{myDateTime.Day}"));
                }
                else
                {
                    LinuxRun(2023, (year, myDateTime) => Console.WriteLine($"Year:{year},DateTime:{myDateTime.Year}-{myDateTime.Month}-{myDateTime.Day}"));
                }
            }

            //..

            //linux下的调用
            [DllImport("lib/Project-linux.so", EntryPoint = "Run")]
            static extern int LinuxRun(int n, MyDelegate del);
            //windows下的调用
            [DllImport("lib/Project-win.dll", EntryPoint = "Run")]
            static extern int WindowsRun(int n, MyDelegate del);
        }
    }

  这样，我们就实现了可以往C/C++程序中注册一个函数句柄，当需要的时候，函数的调用让C/C++去触发。

 

  总结

  其实，到这里基本上就已经说完了，应该能满足多数据的开发需求了，但是还有几点没有说道，这里也记一下，后续再写博客补充：

  1、DllImport各参数的使用说明，网上很多说的不清楚，每个字段的使用例子也没有，我觉得有需要的话，后续可以补充一下各个字段的使用demo

  2、跨平台支持，比如本文中的例子，有linux和windows两个版本，但是调用的时候，都是使用的if(OperatingSystem.IsWindows())来判断当前环境的系统，这种方式非常不友好！

  其实还有异常捕捉等没有讲到，但这是后话，可能就不说了，建议是C#处理C#的异常，C/C++按照自己的方式来处理，当然你可能回想，异常捕捉哪有那么麻烦，直接try-catch不就行了么?而且你调试也会发现，C/C++抛出的异常确实可以不做到，但是这些是依赖windows底层的api来实现的，想其它系统不一定有这种api支持，导致的结果就可能是非托管代码发生异常，导致我们整个进程就直接挂掉了！

 

  参考：

  https://learn.microsoft.com/en-us/dotnet/standard/native-interop/

 

标签：调用,int,代码,托管,System,C++,C#,linux
From： https://www.cnblogs.com/shanfeng1000/p/16992878.html