C#与C++代码互相调用

C# 托管代码与C++非托管代码互相调用

一. C# 中静态调用C++动态链接

 

1. 建立VC工程CppDemo,建立的时候选择Win32 Console(dll),选择Dll。

2. 在DllDemo.cpp文件中添加这些代码。

Code
extern “C” __declspec(dllexport) int Add(int a,int b)
{

return a+b;
}

3. 编译工程。

4. 建立新的C#工程,选择Console应用程序,建立测试程序InteropDemo
5. 在Program.cs中添加引用:using System.Runtime.InteropServices;

6. 在pulic class Program添加如下代码:

 

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace InteropDemo
{
class Program
{
[DllImport(“CppDemo.dll”, EntryPoint = “Add”, ExactSpelling = false, CallingConvention = CallingConvention.Cdecl)]
public static extern int Add(int a, int b); //DllImport请参照MSDN

static void Main(string[] args)
{
Console.WriteLine(Add(1, 2));
Console.Read();
}
}
}

好了,现在您可以测试Add程序了,是不是可以在C# 中调用C++动态链接了,当然这是静态调用,需要 将CppDemo编译生成的Dll放在DllDemo程序的Bin目录下

二. C# 中动态调用C++动态链接

在第一节中,讲了静态调用C++动态链接,由于Dll路径的限制,使用的不是很方便,C#中我们经常通过配置动态的调用托管Dll,例如常用的一 些设计模式:Abstract Factory, Provider, Strategy模式等等,那么是不是也可以这样动态调用C++动态链接呢?只要您还记得在C++中,通过LoadLibrary, GetProcess, FreeLibrary这几个函数是可以动态调用动态链接的(它们包含在kernel32.dll中),那么问题迎刃而解了,下面我们一步一步实验

1.  将kernel32中的几个方法封装成本地调用类NativeMethod

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace InteropDemo
{
public static class NativeMethod
{
[DllImport(“kernel32.dll”, EntryPoint = “LoadLibrary”)]
public static extern int LoadLibrary(
[MarshalAs(UnmanagedType.LPStr)] string lpLibFileName);

[DllImport(“kernel32.dll”, EntryPoint = “GetProcAddress”)]
public static extern IntPtr GetProcAddress(int hModule,
[MarshalAs(UnmanagedType.LPStr)] string lpProcName);

[DllImport(“kernel32.dll”, EntryPoint = “FreeLibrary”)]
public static extern bool FreeLibrary(int hModule);
}
}

2. 使用NativeMethod类动态读取C++Dll,获得函数指针,并且将指针封装成C#中的委托。原因很简单,C#中已经不能使用指针了,如下
int hModule = NativeMethod.LoadLibrary(@”c:”CppDemo.dll”);

IntPtr intPtr = NativeMethod.GetProcAddress(hModule, “Add”);

详细请参见代码

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace InteropDemo
{
class Program
{
//[DllImport(“CppDemo.dll”, EntryPoint = “Add”, ExactSpelling = false, CallingConvention = CallingConvention.Cdecl)]
//public static extern int Add(int a, int b); //DllImport请参照MSDN

static void Main(string[] args)
{
//1. 动态加载C++ Dll
int hModule = NativeMethod.LoadLibrary(@”c:\CppDemo.dll”);
if (hModule == 0) return;

//2. 读取函数指针
IntPtr intPtr = NativeMethod.GetProcAddress(hModule, “Add”);

//3. 将函数指针封装成委托
Add addFunction = (Add)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(Add));

//4. 测试
Console.WriteLine(addFunction(1, 2));
Console.Read();
}

/// <summary>
/// 函数指针
/// </summary>
/// <param name=”a”></param>
/// <param name=”b”></param>
/// <returns></returns>
delegate int Add(int a, int b);

}
}
原文链接:http://www.cnblogs.com/Jianchidaodi/archive/2009/03/09/1407270.html

C#计算阶乘空间

因为阶乘的结果很容就超出了以有数据类型的范围,即使是Long数据类型。
所以我们要另找一个方案,比如用数组来储存算的结果,这样就可以算到Max(long)位
原理网上很多,找了一个原理大家看看:
假设数组为int[] array = new int[10000],因为1! = 1,所以首先置a[0] = 1,分别乘以2、3,得到3! = 6,此时仍只需要一个元素a[0];然后乘以4得到24,我们把个位数4放在a[0],十位数2放在a[1],这样存放结果就需要两个元素;乘以5的时 候,我们可以这样进行:用5与各元素由低到高逐一相乘,先计算个位数(a[0])4 × 5,结果为20,这样将a[0]置为0,注意要将2进到十位数,然后计算原来的十位数(a[1])2 × 5,结果为10加上刚才进的2 为12,这样十位数是2,而1则进到百位,这样就得到5! = 120;以此类推……

根据网上的原理自己封装了一个函数
List<int> GetFactorial(int a)
{
int m = 0, n = 0, nl = 0;
//超过1000计算时间会很慢,并不是不能算,建议加上多线程。
if (a < 1 || a > 1000) return new List<int>();
List<int> lst = new List<int>(a);
List<int> result = new List<int>();
for (int i = 0; i < a – 1; i++)
lst.Add(i + 2);
result.Add(1);
lst.ForEach(delegate(int c)
{
for (int d = 0; d < result.Count; d++)
{
a = c * result[d] + n;
m = a % 10;
result[d] = m;
if (a > 9)
{
n = a / 10;

}
else
{
n = 0;
}

}
if (n > 0)
{
char[] cs = n.ToString().ToCharArray();
nl = cs.GetLength(0) – 1;
for (int ii = nl; ii >= 0; ii–)
{
result.Add(Convert.ToInt32(cs[ii].ToString()));
}
n = 0;
}

});
result.Reverse();
return result;
}
希望能给大家带来帮助