C#中使用OpenGL：（六）C#中调用C函数时的参数传递问题
C#中调用C函数，除了需要在C#中声明被调函数之外，还要考虑到参数传递的问题。虽然我在之前两篇文章中已经提到过如在C#中向C函数传递参数，但是在调用OpenGL函数时，仍然遇到不少难题，特别是关于指针方面。我试图在网络上搜索相关的方法，然而让人失望是，很多人的给出的是“为什么一定要在C#中使用指针呢？”之类的答案。额…，不是我偏爱指针，如果不是迫不得已，谁会在C#中使用指针呢！ 为了解决C#调用OpenGL函数时的参数传递问题，我特地研究了两天，下面是一些成果。我的方法也许不是最好的，但基本能解决大部分问题。
C# OpenGL接口源码、C# OpenGL编程例子可在百度网盘下载：链接：https://pan.baidu.com/s/1dnIo1s-l6aqlE3IgaMJA5g
提取码：wc0x
OpenGL函数的参数类型
总结了一下，OpenGL函数的参数类型有如下：
1.基本数据类型
int 、unsigned int、long long、unsigned long long、short、unsigned short、char、unsigned char、float、double。
2.复杂数据类型
数组、指针、二重指针、字符串、结构体、函数指针、空类型指针（void*）、句柄。
基本数据类型作为参数传递
基本数据类型作为参数传递比较简单，只要用C#相对应的数据类型替换即可。下表是C语言基本数据类型与C#基本数据类型的对应关系。
| C语言 | C#语言 |
|---|---|
| int | int |
| unsigned int | uint |
| long long | Int64 |
| unsigned long long | UInt64 |
| short | short/char |
| unsigned short | ushort |
| char | sbyte |
| unsigned char | byte |
| float | float |
| double | double |
复杂数据类型作为参数传递
1.被调C函数参数为数组
C语言的数组与C#数组是相对应的。C语言函数以一维数组为参数，则C#也是传递一维数组；若C语言函数以二维数组为参数，则C#要传递二维数组。
例如：
C语言函数
//以一维数组为参数
_declspec(dllexport)void FUNC1(int A[])
{
int n=sizeof(A)/4;
for (int i = 0;i< n;i++)
{
printf("%d ", A[i]);
}
}
//以二维数组为参数
_declspec(dllexport)void FUNC2(int A[][2])
{
for(int i=0;i<2;i++)
for(int j=0;j<2;j++)
printf("%d ", A[i][j]);
}
C#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;//调用C语言的dll需要引用此命名空间
namespace Csharp调用C函数的参数传递
{
class Program
{
//外部函数声明
[DllImport("mydll.dll", EntryPoint = "FUNC1", ,CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC1(int[] A);
[DllImport("mydll.dll", EntryPoint = "FUNC2", CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC2(int[,] A);
static void Main(string[] args)
{
int[] A1 = new int[4] { 1, 2, 2, 3 };
int[,] A2 = new int[2, 2] { { 1,2}, { 3,4} };
FUNC1(A1);
FUNC2(A2);
}
}
}
2.被调C函数的参数为普通指针
当C函数的参数为普通指针时，有两种情况，分别是“指向一般变量的指针”和“指向内存块的指针”。当然，这两种类型在C语言是没有区别的，都是指向首地址嘛。在C#中调用C函数时，才有稍稍的不同。
（1）指向一个变量的指针
指向单个变量的指针，通常用于接收函数中的返回值，比较常见的函数有glGet***之类的。针对这样的指针参数，在C#中可以将一个变量的引用（ref）传递过去，或者把一个只有一个元素的数组传过去。
例如：
C函数代码
_declspec(dllexport)void FUNC3(int *A)
{
int c;
c = *A;
printf("%d ", c);
}
C#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;//调用C语言的dll需要引用此命名空间
namespace Csharp调用C函数的参数传递
{
class Program
{
//传递变量的引用
[DllImport("mydll.dll", EntryPoint = "FUNC3", ,CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC3(ref int A);
/*传递单个元素的数组
[DllImport("mydll.dll", EntryPoint = "FUNC3", CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC3(int[] A);
*/
static void Main(string[] args)
{
int[] A = new int[1]{1};
int d=1;
FUNC3(ref d);
/*或者
FUNC3(A);
*/
}
}
}
（2）指向一块内存的指针
C语言的普通指针可用C#的一维数组替代。int *p 作为参数，则C#中调用要传递int[] A。当然，使用IntPtr类型来代替指针也是可以的，不过需要用到不安全代码。
例如：
C语言函数代码
_declspec(dllexport)void FUNC4(int *A,int n)
{
for(int i=0;iC#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;//调用C语言的dll需要引用此命名空间
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport("mydll.dll", EntryPoint = "FUNC4", ,CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC4(int[] A,int n);
static void Main(string[] args)
{
int[] A = new int[4]{1,2,3,4};
FUNC3(A,4);
}
}
}
3.被调C函数的参数为结构体
如果被调C函数的参数是简单的结构体（不含数组和指针成员），那么和C#的结构体也是可以对应的。如果结构体包含了数组和指针成员，则要用到不安全代码才能解决。
例如：
C函数代码
struct MyStruct
{
int x;
double y;
}
_declspec(dllexport)void FUNC5(struct MyStruct s)
{
printf("%d %lf", s.x,s.y);
}
C#调用C语言函数
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;//调用C语言的dll需要引用此命名空间
namespace Csharp调用C函数的参数传递
{
struct myStruct
{
public int x;
public double y;
};
class Program
{
[DllImport("mydll.dll", EntryPoint = "FUNC5", ,CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC5(int[] A,int n);
static void Main(string[] args)
{
myStruct S;
s.x=1;
s.y=12.0;
FUNC5(S);
}
}
}
如果结构体包含数组成员，需要使用不安全代码。VS编译器要先勾选“允许使用不安全”才能编译通过。先在VS的菜单栏上的“项目->属性->生成”页面勾选“允许不安全代码”，然后在代码中使用unsafe关键字对不安全代码块进行标识。
例如：
C函数代码
struct myStruct
{
int n;
int data[10];
};
_declspec(dllexport)void FUNC6(struct myStruct s)
{
for(int i=0;iC#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;//调用C语言的dll需要引用此命名空间
namespace Csharp调用C函数的参数传递
{
unsafe struct myStruct
{
public int n;
public fixed int data[10];//fixed关键字表示分配固定的空间
}
class Program
{
[DllImport("mydll.dll", EntryPoint = "FUNC6", ,CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC6(myStruct s);
static void Main(string[] args)
{
unsafe//不安全代码块
{
myStruct S;
S.n=10;
for(inti=0;i<10;i++)S.data[i];
FUNC6(S);
}
}
}
4.被调C函数的参数为二重指针
C语言的普通指针，在C#中可用一维数组替代(int[] A)，但C语言的二重指针，在C#中不能用二维数组替代（int[,] A）。C语言的二重指针应该用C#的“数组的数组”，即交错数组来替代（int[][] A）。C#调用含有二重指针的C函数，我没有发现更好的办法，只能使用不安全代码，使用指针，即使是是这样，仍然感觉很麻烦。下面用一个例子来说明。
C函数代码
_declspec(dllexport)void FUNC7(int **A, int row,int col)
{
for (int i = 0;iC#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport("mydll.dll", EntryPoint = "FUNC7", CallingConvention = CallingConvention.Cdecl)]
public static extern void FUNC7(IntPtr[] p,int row,int col);
static void Main(string[] args)
{
//交错数组
int[][] a = new int[2][] { new int[2] { 1, 2 }, new int[2] { 3, 4 } };
unsafe
{
//IntPtr类型可等同于指针
IntPtr[] ptr = new IntPtr[2];
//循环将数组的指针存到IntPtr类型的数组中
for (int i = 0; i < 2; i++)
{
fixed (int* p = a[i])//取得数组指针必须要用fixed关键字先将数组内存固定
{
ptr[i] = (IntPtr)p;
}
}
FUNC7(ptr, 2, 2);
}
}
}
}
5.被调C函数的参数为空类型的指针（void）*
在C语言中，参数为空类型的指针，意味可以接受任何类型的指针。由于C语言没有函数重载这种功能，不能定义几个同名的函数，只能使用空类型的指针来接收任意类型的指针，以实现类似于C++中的函数重载的功能。在OpenGL中，有好多函数都是以空类型指针作为参数的。如：
//C语言函数
void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
参数pixels事实上可以是char类型的，也可以是float类型的，具体是什么类型的，由参数type决定。如果type为GL_CHAR，则函数按照char类型指针处理，如果是GL_FLOAT,则按照float类型处理。因为指针的类型不确定，比较难用确定类型的数组来传参。这种情况，有两种方案：第一是函数重载，即根据type的值不同而采用不同的函数；第二，用IntPtr类型来代表指针类型（需要用到不安全代码）。事实上，Intptr类型可以替代所有类型的指针、句柄和结构体。
C函数代码
//pixels可以是char、float或者short类型的指针
void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
C#调用C函数
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
//函数重载一
[DllImport("opengl32.dll", EntryPoint = "glGetTexImage ",CallingConvention=CallingConvention.StdCall)]
public static extern void glGetTexImage (uint target,int level,uint format,uint type,byte[] pixels);
//函数重载二
[DllImport("opengl32.dll", EntryPoint = "glGetTexImage",CallingConvention=CallingConvention.StdCall)]
public static extern void glGetTexImage (uint target,int level,uint format,uint type,short[] pixels);
//函数重载三
[DllImport("opengl32.dll", EntryPoint = "glGetTexImage ",CallingConvention=CallingConvention.StdCall)]
public static extern void glGetTexImage (uint target,int level,uint format,uint type,float[] pixels);
static void Main(string[] args)
{
int[] A = new int[100];
short[] B = new short[100];
float[] C = new float[100];
glGetTexImage(1,0,1,0,A);
glGetTexImage(1,0,2,1,B);
glGetTexImage(1,0,3,2,C);
}
}
}
或者如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport("opengl32.dll", EntryPoint = "glGetTexImage ",CallingConvention=CallingConvention.StdCall)]
public static extern void glGetTexImage (uint target,int level,uint format,uint type,IntPtr pixels)；
static void Main(string[] args)
{
byte[] A = new byte[1000];
IntPtr poniter;
unsafe{
fixed(byte* p=&A[0])poiter=(Intptr)p;
}
glGetTexImage(1,0,1,0,pointer);
}
}
}
**6.被调C函数的参数为函数指针**
C#中接收和传递函数指针都可以用Intptr类型的变量。即使是取得函数指针，也不能直接在C#中通过函数指针调用函数，而要通过委托来执行。关于函数指针，在OpenGL函数的参数中出现机会很少，但在调用高版本的OpenGL函数（1.3版本以上）总是需要通过函数指针来调用，后面会经常用到，所以要好好研究研究。下面的例子是通过wglGetAddress函数获取OpenGL函数指针，然后在C#中调用。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport(“opengl32.dll”, EntryPoint= “wglGetAddress”,CharSet=CharSet.Ansi CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr wglGetAddress(string funcName);
//声明一个委托
delegate void Color3f(float r,float g,float b);
static void Main(string[] args)
{
//定义函数指针
IntPtr funcPointer;
//定义委托
delegate glColor3f;
//获得glColor3f的函数指针呢
funcPointer=wglGetAdress("glColor3f");
Type t=typeof(Color3f);
//将函数指针转变为委托
glColor3f=Marshal.GetDelegateForFunctionPointer(funcPointer,t);
//通过委托来执行函数
glColor3f(0.5f,0.5f,0.5f)；
}
}
}
**7.被调函数的参数或返回值为对象句柄**
这个对象句柄，可能是函数指针，或者窗口句柄，或者其他的模块句柄。在winAPI中，经常用到的是窗句柄（HWND），设备上下文句柄（HDC）等等。这种句柄类的变量，都可以用IntPtr类型来接收。例如：
winAPI
HDC GetDC（HWND win）;
C#调用winAPI
//声明外部函数
[DllImport(“gdi32.dll”, EntryPoint = “GetDC”,CallingConvention=CallingConvention.StdCall)]
public static extern IntPtr GetDC(IntPtr handle);
//获得pictureBox的设备上下文
IntPtr hdc;
hdc=GetDC(pictureBox1.handle);
**8.被调C函数的参数为字符串**
C语言的字符串一般用const char*或者char str[]表示，C#中表示字符串的是string或者char[]。由于C语言的char类型是一个字节的(Ansi），而C#的char类型是两个字节的，string类型的元素也是两个字节的（Unicode），因此不能直接将C#的char[]和string直接作为参数传到C函数中。要想正确传递字符串，可以有以下两种方法。
（1）使用string和char[]作为参数传递
string类型和char[]字符数组是可以将字符串传递给C函数的，只不过在传递的时候需要在C#中将字符集（CharSet）设定为ansi，这样系统就知道应当把char类型处理成一个字节的，而不是两个字节。
例子：
C函数代码
_declspec(dllexport)void FUNC8(const char* str)
{
printf("%s", str);
}
C#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport(“mydll.dll”,EntryPoint=“FUNC8”,CharSet=CharSet.Ansi,CallingConvention=CallingConvention.cdecl)]
public static extern void FUNC8 (sting str);
static void Main(string[] args)
{
string str="hello world";
FUNC8(str);
}
}
}
（2）使用byte类型的数组作为字符串传递（byte[]）
C#的byte类型是一个字节的，与C语言的char类型刚好对应，因此完全可以用byte替代C的char。在C#中可以先将string，char[]转为byte[]，然后再往C函数中传送。
例子：
C函数代码
_declspec(dllexport)void FUNC8(const char* str)
{
printf("%s", str);
}
C#调用C函数代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace Csharp调用C函数的参数传递
{
class Program
{
[DllImport(“mydll.dll”,EntryPoint=“FUNC8”,CallingConvention=CallingConvention.cdecl)]
public static extern void FUNC8 (byte[] str);
static void Main(string[] args)
{
string str=“hello world”;
byte[] s=Encoding.UTF8.GetBytes(str);
FUNC8(s);
}
}
}
结语
--
整整花了两天才把参数传递这个问题搞定，耽误了不少时间，但也为以后的项目扫清了道路。下一步的工作是在C#中搭建OpenGL渲染环境。
上一篇：[C#中使用OpenGL：（五）1.1版本的OpenGL函数](http://blog.csdn.net/qq_28249373/article/details/78076406)
下一篇：[C#中使用OpenGL：（七）创建OpenGL渲染环境](http://blog.csdn.net/qq_28249373/article/details/78835336)