如何让IntPtr指向一块内存，以及托管内存与非托管内存的相互转化

IntPtr idp= IntPtr.Zero;
StringBuilder idata = new StringBuilder("000000");
string idata ="000000";
我这样建立的2个idata字符串，如何让idp指向他
我指向他的目的是为了传递给dll的某个函数，他需要传指针
还有我定义了一个结构如何向dll的函数传递其指针？

所有分了，解决一起结了

用GCHandle.Alloc（object obj)方法来给string分配一个指针！

using System;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Security.Permissions;

public delegate bool CallBack(int handle, IntPtr param);

public class LibWrap
{
	// passing managed object as LPARAM
	// BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam);

	[DllImport("user32.dll")]
	public static extern bool EnumWindows(CallBack cb, IntPtr param);
}

public class App
{
	public static void Main()
	{
		Run();
	}

        [SecurityPermission(SecurityAction.Demand, UnmanagedCode=true)]
	public static void Run()
        {
		TextWriter tw = System.Console.Out;
		GCHandle gch = GCHandle.Alloc(tw);

		CallBack cewp = new CallBack(CaptureEnumWindowsProc);

		// platform invoke will prevent delegate to be garbage collected
		// before call ends

		LibWrap.EnumWindows(cewp, GCHandle.ToIntPtr(gch));
		gch.Free();
        }

	private static bool CaptureEnumWindowsProc(int handle, IntPtr param)
	{
		GCHandle gch = GCHandle.FromIntPtr(param);
		TextWriter tw = (TextWriter)gch.Target;
		tw.WriteLine(handle);
		return true;
	}
}

http://technet.microsoft.com/zh-cn/library/a95009h1.aspx?cs-save-lang=1&cs-lang=csharp#code-snippet-1

http://technet.microsoft.com/zh-cn/library/system.runtime.interopservices.gchandle.aspx

http://technet.microsoft.com/zh-cn/library/system.runtime.interopservices.gchandle.free.aspx

 

用GCHandle.Alloc是将托管内存变为非托管内存，并分配一个GCHandle对象，也就是一个和指针把，用toIntptr可以将它转换成intptr指针。

但是要记住，因为把这块内存变成了非托管内存，所以垃圾回收机制就不会对他进行垃圾回收了，所以要手动的用GCHandle的free方法吧这块内存free掉。

 

还有另外一种方法就是用Marshal类的方法，可以开辟一块非托管内存，然后用一个intptr指向它。然后将托管内存中的内容复制到非托管内存中。

但是这也要记住是要free掉这块非托管内存的。

http://msdn.microsoft.com/zh-cn/library/system.runtime.interopservices.marshal%28v=vs.110%29.aspx

但是从他的API可以看到，一大片都是将数组复制到非托管内存中的函数，还有就是复制结构体的函数。所以不确定是不是可以复制对象。

c#中这样定义 
struct b 
{ 
  IntPtr sp； 
} 

然后在 
str_a  ss=new str_a(); 
IntPtr sp = Marshal.AllocCoTaskMem(Marshal.SizeOf(ss)); 
Marshal.StructureToPtr(ss, sp, false); 

额，目前对托管和非托管有了很清晰的认识了。

前几篇还有一篇是将托管内存和非托管内存的。有很大的看的价值

 

我们主要是使用Marshal类里的两个方法：

第一个是StructureToPtr，将数据从托管对象封送到非托管内存块。

第二个是PtrToStructure，将数据从非托管内存块封送到新分配的指定类型的托管对象。

只要有了这两个相互转换的方法，我们就可以实现序列化了。

首先我们先来看下序列化

序列化：
有一个前提条件，那就是我们必须要知道需要序列化对象的大小。

第一步：我们先求出对象的大小，然后在非托管内存中给它分配相应的内存大小。

第二步：接着我们就把这个对象封送到刚分配出来的内存中，之后我们会得到一个分配出来的内存块首地址指针。

第三步：最后我们可以通过这个首地址指针，从指针所指的位置处开始，拷贝数据到指定的byte[]数组中，拷贝的长度就是我们为这个对象分配出来的内存大小，得到byte[]数据后，下面的事情我就不用多说了，你可以保存到数据库或者文件中。

反序列化：
序列化的时候我们先将一个对象封送到了非托管内存块中，然后再把内存块中的数据读到byte[]数组中，

现在我们反序列化

第一步：我们先求出对象的大小，然后在非托管内存中给它分配相应的内存大小。

第二步：然后把这个byte[]数据拷贝到非托管内存块中。

第三步：最后再从内存块中封送指定大小的数据到对象中。

有一个地方需要注意，那就是因为引用类型的对象我们是无法求的它的实际大小的，所以这里的对象我们只能使用非托管对象，比如struct结构体。

所以，当我们只是用来存储数据，不涉及任何操作的对象，我们可以把它作为一个结构体来处理，这样我们在序列化的时候可以节省空间开销。

因为你如果你要是用平常的序列化方法去序列化一个类对象，他所需要的空间开销是要大于你去序列化一个具有相同结构的struct对象。

下面是代码： 

public static class MyConverter
{
/// <summary>
/// 由结构体转换为byte数组
/// </summary>
public static byte[] StructureToByte<T>(T structure)
{
int size = Marshal.SizeOf(typeof(T));
byte[] buffer = new byte[size];
IntPtr bufferIntPtr = Marshal.AllocHGlobal(size);
try
{
Marshal.StructureToPtr(structure, bufferIntPtr, true);
Marshal.Copy(bufferIntPtr, buffer, 0, size);
}
finally
{
Marshal.FreeHGlobal(bufferIntPtr);
}
return buffer;
}

/// <summary>
/// 由byte数组转换为结构体
/// </summary>
public static T ByteToStructure<T>(byte[] dataBuffer)
{
object structure = null;
int size = Marshal.SizeOf(typeof(T));
IntPtr allocIntPtr = Marshal.AllocHGlobal(size);
try
{
Marshal.Copy(dataBuffer, 0, allocIntPtr, size);
structure = Marshal.PtrToStructure(allocIntPtr, typeof(T));
}
finally
{
Marshal.FreeHGlobal(allocIntPtr);
}
return (T)structure;
}
}

//////////////////////////////////测试代码///////////////////////////////////
class Program
{
static void Main(string[] args)
{
Student student1 = new Student { Name = "胡昌俊", ID = 2 };
Console.WriteLine("序列化前=> 姓名:{0} ID:{1}", student1.ID, student1.Name);

byte[] bytes = MyConverter.StructureToByte<Student>(student1);
Student sudent2 = MyConverter.ByteToStructure<Student>(bytes);

Console.WriteLine("序列化后=> 姓名:{0} ID:{1}", sudent2.ID, sudent2.Name);
Console.Read();
}
}

public struct Student
{
public int ID { get; set; }
public string Name { get; set; }
}