C#学习笔记——CopyMemory
Socket接收到的byte []要转换成自定义的struct / 自定义Struct转换成byte []都相当麻烦
用循环去转换太浪费时间了……于是想到用CopyMemory，Google一圈终于搞定
下面的代码是在Snippet Compiler里编译通过的
C#代码
#region Imports
using System;
using System.IO;
using System.Net;
using System.Xml;
using System.Text;
using System.Data;
using System.Drawing;
using System.Threading;
using System.Reflection;
using System.Collections;
using System.Net.Sockets;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing.Imaging;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
#endregion
#region Assembly Info
[assembly: AssemblyTitle("Test Application by eglic")]
[assembly: AssemblyDescription("Test Application by eglic")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("eGlic.Com")]
[assembly: AssemblyProduct("Test Application by eglic")]
[assembly: AssemblyCopyright("Copyright (C) eGlic.Com 2007")]
[assembly: AssemblyTrademark("eGlic.Com")]
[assembly: AssemblyCulture("")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
#endregion
namespace eGlic
{
#region Application Entrance
public class Test{
[STAThread]
public static void Main() {
byte [] buffer=new byte [20];
DataGraphHeader header=new DataGraphHeader();
string data="ABCDEFGH";
header.Signature=0xFF;
header.Protocol.Type=1;
header.Protocol.Version=1;
header.Type=99;
header.SerialID=1234567;
header.Size=8;
Win32API.CopyMemoryEx(buffer,ref header);
Win32API.CopyMemoryEx(buffer,12,System.Text.Encoding.ASCII.GetBytes(data),0,8);
string o="";
for(int i=0;i<buffer.Length;i++){
if(buffer[i]<10) o+="0";
o+=String.Format("{0:X}",buffer[i]);
o+=" ";
}
MessageBox.Show(o,"转成Byte []之后的数据包",MessageBoxButtons.OK,MessageBoxIcon.Information);
DataGraphHeader h=new DataGraphHeader();
byte [] buf;
string d="";
Win32API.CopyMemoryEx(ref h,buffer);
buf=new byte [h.Size];
Win32API.CopyMemoryEx(buf,buffer,12,h.Size);
o="h.Signature=" +h.Signature.ToString()+"/r/n";
o+="h.Protocol.Type=" +h.Protocol.Type.ToString()+"/r/n";
o+="h.Protocol.Version=" +h.Protocol.Version.ToString()+"/r/n";
o+="h.Type=" +h.Type.ToString()+"/r/n";
o+="h.SerialID=" +h.SerialID.ToString()+"/r/n";
o+="h.Size=" +h.Size.ToString()+"/r/n";
o+="附加数据为："+System.Text.Encoding.ASCII.GetString(buf);
MessageBox.Show(o,"解析后数据包",MessageBoxButtons.OK,MessageBoxIcon.Information);
}
}
#endregion
#region Win32API
public class Win32API {
[DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory", CharSet = CharSet.Ansi)]
public extern static long CopyMemory(IntPtr dest, IntPtr source, int size);
#region CopyMemoryEx
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">目标缓存区</param>
/// <param name="source">DataGraphPackage</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(byte[] dest, ref DataGraphHeader source) {
return CopyMemoryEx(dest, 0,ref source);
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">目标缓存区</param>
/// <param name="DestStart">目标缓存区中的开始位置</param>
/// <param name="source">DataGraphPackage</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(byte[] dest,int DestStart, ref DataGraphHeader source) {
IntPtr dp;
IntPtr sp;
fixed (byte* ds = &dest[DestStart]) {
fixed (DataGraphHeader* sr = &source) {
dp = (IntPtr)ds;
sp = (IntPtr)sr;
return CopyMemory(dp, sp, sizeof(DataGraphHeader));
}
}
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">DataGraphPackage</param>
/// <param name="source">源数据缓存</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(ref DataGraphHeader dest, byte[] source) {
return CopyMemoryEx(ref dest, source, 0);
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">DataGraphPackage</param>
/// <param name="source">源数据缓存</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(ref DataGraphHeader dest, byte[] source,int SourceStart) {
IntPtr dp;
IntPtr sp;
fixed (DataGraphHeader* ds = &dest) {
fixed (byte* sr = &source[SourceStart]) {
dp = (IntPtr)ds;
sp = (IntPtr)sr;
return CopyMemory(dp, sp, sizeof(DataGraphHeader));
}
}
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">目标缓存</param>
/// <param name="source">源数据</param>
/// <param name="size">要从源数据中复制的长度</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(byte[] dest, byte[] source, int size) {
return CopyMemoryEx(dest, 0, source, 0, size);
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">目标缓存</param>
/// <param name="source">源数据</param>
/// <param name="SourceStart">源数据缓存中开始位置</param>
/// <param name="size">要从源数据中复制的长度</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(byte[] dest, byte[] source, int SourceStart,int size) {
return CopyMemoryEx(dest, 0, source, SourceStart, size);
}
/// <summary>
/// CopyMemoryEx
/// </summary>
/// <param name="dest">目标缓存</param>
/// <param name="DestStart">目标缓存中开始复制的位置</param>
/// <param name="source">源数据</param>
/// <param name="SourceStart">源数据缓存中开始位置</param>
/// <param name="size">要从源数据中复制的长度</param>
/// <returns></returns>
public unsafe static long CopyMemoryEx(byte[] dest,int DestStart, byte[] source, int SourceStart, int size) {
IntPtr dp;
IntPtr sp;
fixed (byte* ds = &dest[DestStart]) {
fixed (byte* sr = &source[SourceStart]) {
dp = (IntPtr)ds;
sp = (IntPtr)sr;
return CopyMemory(dp, sp, size);
}
}
}
#endregion
}
#endregion
[StructLayout(LayoutKind.Sequential)]
public struct ProtocolInfo {
public byte Type;
public byte Version;
}
[StructLayout(LayoutKind.Sequential)]
public struct DataGraphHeader {
public byte Signature; //包头： 1字节
public ProtocolInfo Protocol; //协议： 2字节
public byte Type; //包类型： 1字节
public uint SerialID; //包序号 4字节
public int Size; //包尺寸 4字节
}
}
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Python/archive/2007/08/24/1757002.aspx
