以前写的一个C#读取UDP协议数据包程序

　　现在需要进一步学习多线程的知识，11年年初的时候写的程序，测试可以使用，但是对于多线程的机制还是不十分清楚，所以再拿出来看看。

1.读取Udp协议数据服务器端程序（图2）：

 （1） （2）

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace ServerUdp
{
    public partial class Serverfrm : Form
    {
        UdpClient udpReceive;
        private Thread myThread;
        private delegate void SetlistBoxCallBack(string str);//委托，
        private SetlistBoxCallBack setlistbox;
       
        public Serverfrm()
        {
            InitializeComponent();
        }

        private void Serverfrm_Load(object sender, EventArgs e)
        {
            setlistbox = new SetlistBoxCallBack(SetListBox);
        }
        private void ReceiveMessage()
        {
           // mDB_means.Open();
            byte[] ReceiveBytes = null;
            IPEndPoint remoteIpEndIPoint = new IPEndPoint(IPAddress.Any, 29527);
            udpReceive = new UdpClient(remoteIpEndIPoint);
            IPEndPoint iep = new IPEndPoint(IPAddress.Any, 0);
            while (true)
            {
                try
                {
                    ReceiveBytes = udpReceive.Receive(ref iep);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                    return;
                }
                finally
                {
                }
                int pPoint = 0;
                string message = "来自" + iep.ToString() + "的消息";
                Head phead = new Head();
                System.Type ptype = phead.GetType();
                phead = (Head)BytesToStruct(ReceiveBytes, ptype, 0);
                pPoint +=Marshal.SizeOf(phead);

                StationID apid = new StationID();
                System.Type ptype1 = apid.GetType();
                apid = (StationID)BytesToStruct(ReceiveBytes, ptype1, pPoint);
                pPoint +=Marshal.SizeOf(apid );

                listBox1.Invoke(setlistbox, message);
                
                int p=0;
                foreach (byte flg in phead.flag)
                {
                    if (flg != '\0')
                        p++;
                }
                byte[] tempbyte = new byte[p];
                for (int i = 0; i < p; i++)
                    tempbyte[i] = phead.flag[i];

                string export =Encoding.UTF8.GetString (tempbyte ) + " " + phead.len.ToString() + " " + phead.type.ToString() + " " + phead.cmd.ToString() + " " + phead.rc.ToString();
                listBox1.Invoke(setlistbox, export);
                listBox1.Invoke(setlistbox, Encoding.UTF8.GetString(apid.serial));
                
                if (phead.cmd  == 2)
                {
                    PacketData pPacketData = new PacketData();
                    int ind=Convert.ToInt16 ((phead.len -pPoint)/Marshal.SizeOf (pPacketData )) ;
                    System.Type ptype2 = pPacketData.GetType();
                   
                    for (int i = 1; i <= ind; i++)
                    {
                        pPacketData = (PacketData)BytesToStruct(ReceiveBytes, ptype2, pPoint);
                        pPoint += Marshal.SizeOf(pPacketData);
                         string addrstr1 = "";
                    foreach (byte tele in pPacketData.Kid )
                    {
                        addrstr1 += Convert.ToString(tele);
                    }
                        listBox1.Invoke(setlistbox, addrstr1 + " " + pPacketData.rssi.ToString() + " " + pPacketData.time.ToString());
                       // listBox1.Invoke(setlistbox, pPacketData.Kid + " " + pPacketData.rssi.ToString() + " " + pPacketData.time.ToString());
                      
                    }
                }
                else if (phead.cmd  == 1)
                {
                    WifiData pWifiData = new WifiData();
                    int ind = Convert.ToInt16((phead.len - pPoint) / Marshal.SizeOf(pWifiData));
                    System.Type ptype3 = pWifiData.GetType();
                    for (int i = 1; i <= ind; i++)
                    {
                        pWifiData = (WifiData)BytesToStruct(ReceiveBytes, ptype3, pPoint);
                        pPoint += Marshal.SizeOf(pWifiData);
                        string addrstr = "";
                        foreach (byte bele in  pWifiData.addr)
                        {
                            addrstr +=bele.ToString("X")+":" ;
                        }
                        listBox1.Invoke(setlistbox, addrstr + " " + pWifiData.rssi.ToString() + " " + pWifiData.rate.ToString() + " " + pWifiData.time.ToString());
                        try
                        {

                            //  string SQL = "insert into 接收AP信息 values('" + Encoding.UTF8.GetString(pPacketData.Kid) + "','" + pPacketData.rssi + "','" + pPacketData.time + "','" + Encoding.UTF8.GetString(apid.serial) + "')";
                            // int ii = mDB_means.Operate(SQL);

                        }
                        catch (Exception ex)
                        {

                        }
                        finally
                        {
                            //continue;
                        }
                    }
                }
                
                //AddKaoQ(list1, phead);//将接收的数据转换成需要的考勤信息数组和位置解算数组
                //Store(list1);
            }
           
        }
        private void SetListBox(string str)
        {
            listBox1.Items.Add(str);
            listBox1.SelectedIndex = listBox1.Items.Count - 1;
            listBox1.ClearSelected();
        }
        private void btnStop_Click(object sender, EventArgs e)
        {
           
            btnStart.Enabled = true;
            udpReceive.Close ();
            myThread.Abort();
        }

        private void Serverfrm_FormClosed(object sender, FormClosedEventArgs e)
        {
            udpReceive.Close();
            myThread.Abort();
        }
        public object BytesToStruct(byte[] bytes, Type type, int p)
        {
            //得到结构的大小
            int size = Marshal.SizeOf(type);
            //Log(size.ToString(), 1);
            //byte数组长度小于结构的大小
            if (size > bytes.Length)
            {
                //返回空
                return null;
            }
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将byte数组拷到分配好的内存空间
            Marshal.Copy(bytes, p, structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回结构
            return obj;
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            btnStart.Enabled = false;
            
            myThread = new Thread(new ThreadStart(ReceiveMessage));
            myThread.Start();
           
        }

      

       
    }
}

数据结构如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
//System.Runtime.InteropServices 命名空间提供各种各样支持 COM interop 及平台调用服务的成员
//此命名空间提供了多种类别的功能，如下表所示。
//属性可控制封送行为，例如如何安排结构或表示字符串。
//其中最重要的属性有 DllImportAttribute（可以用来定义用于访问非托管 API 的平台调用方法）和 
//MarshalAsAttribute（可以用来指定如何在托管内存与非托管内存之间封送数据）。
namespace ServerUdp
{
    struct Head
    {
        //head头长为12 字节
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] flag;        //AQD,用来标志数据，默认值为“AQD”,4个字节
        public uint len;    //all transimit len,用来表示整个数据头和数据部分的总,长度4个字节
        public byte type;   //packet type, 0: request 1: respond 2:report,数据类型,1个字节
        //packet command1：代表 wifi 手机的数据2：代表 人员定位卡的数据
        public sbyte cmd;   //1个字节
       
        //return code, 0 correct, other error
        //用于说明本次数据是否有效，主要是用于被动模式下，当服务器请求数据，而AP应答时，说明数据是否请求成功，或者表示错误的代码，
        //主动模式下没有意义。此值为两个字节长，默认值为0。
        public UInt16  rc;//2 个字节

        
    }
    public struct PacketData//人员定位卡数据
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public byte[] Kid;//人员定位卡号码,3个字节
        public byte  rssi;//信号强度1字节
        public uint time;//获取信号的时间,4个字节,其中时间的表示为从2010-1-1-0:00到取得信号时的间隔秒数
        
    }
    struct StationID
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
        public byte[] serial;
    }
    public struct WifiData//Wifi手机数据
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
        public Byte[] addr;//WIFI 模块MAC，6字节
        public sbyte    rssi;//信号强度，1字节
        public byte rate;//模块的通讯速度，1字节
        public uint time;//获取信号的时间，4字节,其中时间的表示为从2010-1-1-0:00到取得信号时的间隔秒数
       
    }
}

 2.发送数据测试程序（图1）：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;

namespace ApUdp
{
    public partial class Apfrm : Form
    {
        UdpClient udpSend;
        public Apfrm()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //DateTime pdatetime = new DateTime();
            //DateTime PdateTime = new DateTime(2010, 1, 1);
            //pdatetime = DateTime.Now;
            //TimeSpan   aa = pdatetime - PdateTime;
            //MessageBox.Show(aa.TotalDays.ToString() + " " + aa.TotalHours.ToString() + " " + Convert .ToString (aa.TotalDays *24) + " " + aa.TotalSeconds.ToString());
            
            timer1.Enabled = !timer1.Enabled;
            
        }
        
        private void timer1_Tick(object sender, EventArgs e)
        {        
            //基站编号
            StationID apid = new StationID();
            //apid.serial =new byte[]{1,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0};
            apid.serial = Encoding.UTF8.GetBytes(new char[] { 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'a', 'p', '0', '1' });

            DateTime pNowTime = new DateTime();
            DateTime pDateTime = new DateTime(2010, 1, 1);
            pNowTime = DateTime.Now;
            TimeSpan pTimeSpan = pNowTime - pDateTime;//时间间隔

            //定位卡数据2份
            PacketData pPacketData1 = new PacketData();
            pPacketData1.Kid = Encoding.UTF8.GetBytes("k01");
            pPacketData1.rssi = 1;
            pPacketData1.time =Convert .ToUInt32 ( pTimeSpan.TotalSeconds);

            PacketData pPacketData2 = new PacketData();
            pPacketData2.Kid = Encoding.UTF8.GetBytes("k02");
            pPacketData2.rssi = 1;
            pPacketData2.time =Convert.ToUInt32 ( pTimeSpan.TotalSeconds);

            PacketData pPacketData3 = new PacketData();
            pPacketData3.Kid = Encoding.UTF8.GetBytes("k03");
            pPacketData3.rssi = 2;
            pPacketData3.time = Convert.ToUInt32(pTimeSpan.TotalSeconds);

            //头数据
            Head headap1 = new Head();
            //headap1.flag = new byte[] { (byte)'A', (byte)'P', 0, 1 };
            headap1.flag = Encoding.UTF8.GetBytes(new char[] { 'A', 'D', 'Q', ' ' });
            headap1.len = Convert.ToUInt32( Marshal.SizeOf(headap1)+Marshal.SizeOf (apid )+2*Marshal.SizeOf (pPacketData1)) ;
            headap1.type = 2;//标识主动上报
            headap1.cmd = 2;//表示Wifi手机
            headap1.rc = 0;//默认为0

            byte[] aa = StructToBytes(headap1);//转换成字节数组
            byte[] bb = StructToBytes(apid  );//转换成字节数组
            byte[] cc = StructToBytes(pPacketData1);//转换成字节数组
            byte[] dd = StructToBytes(pPacketData2);//转换成字节数组

            byte[] SendBytes =new byte[headap1.len ];//转换成字节数组
            aa.CopyTo(SendBytes, 0);
            bb.CopyTo(SendBytes, aa.Length );
            cc.CopyTo(SendBytes, aa.Length  + bb.Length );
            dd.CopyTo(SendBytes, aa.Length +cc.Length  + bb.Length );

            System.Type ptype = headap1.GetType();
            Head TestBytesbb = (Head)BytesToStruct(SendBytes, ptype,0);
            System.Type ptype1 =apid.GetType();
            StationID TestBytes = (StationID)BytesToStruct(SendBytes, ptype1, Marshal.SizeOf (TestBytesbb));
            #region 利用Arraylist尝试
            //ArrayList parraylist = new ArrayList();
            //parraylist.Add(headap1);
            //parraylist.Add(apid);
            //parraylist.Add(pPacketData1);
            //parraylist.Add(pPacketData2);

            //byte[] aa = StructToBytes(headap1);//转换成字节数组
            //System.Type ptype1 = headap1.GetType();
            //Head bb = (Head)BytesToStruct(aa, ptype1);

            //byte[] SendBytes = StructToBytes(parraylist );//转换成字节数组
            //System.Type ptype = parraylist.GetType();
            //Head TestBytes = (Head)BytesToStruct(SendBytes, ptype);

            //MessageBox.Show(headap1.len .ToString ()+" "+SendBytes.Length .ToString ());
            #endregion
            try
            {
                udpSend = new UdpClient();
                IPAddress remoteIPAddress = IPAddress.Parse("127.0.0.1");
                IPEndPoint remoteIPEndPoint = new IPEndPoint(remoteIPAddress, 29527);
                udpSend.Send(SendBytes, SendBytes.Length, remoteIPEndPoint);

                listBox1.Items.Add(Encoding.UTF8.GetString(TestBytesbb.flag) + " " + TestBytesbb.len.ToString() + " " + TestBytesbb.type.ToString() + " " + TestBytesbb.cmd.ToString() + " " + TestBytesbb.rc.ToString());
                listBox1.Items.Add(Encoding.UTF8 .GetString(TestBytes.serial));
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
                return;
            }
            finally
            {
            }
        }
        /// <summary>
        /// 将结构转换为字节数组
        /// </summary>
        /// <param name="obj">结构对象</param>
        /// <returns>字节数组</returns>
        public byte[] StructToBytes(object obj)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(obj);
            //创建byte数组
            byte[] bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷到分配好的内存空间
            Marshal.StructureToPtr(obj, structPtr, false);
            //从内存空间拷到byte数组
            Marshal.Copy(structPtr, bytes, 0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回byte数组
            return bytes;
        }
        /// <summary>
        /// byte数组转结构
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <param name="type">结构类型</param>
        // <returns>转换后的结构</returns>
        public object BytesToStruct(byte[] bytes,Type type ,int p)
        {
            //得到结构的大小
            int size = Marshal.SizeOf(type);
            //Log(size.ToString(), 1);
            //byte数组长度小于结构的大小
            if (size > bytes.Length)
            {
                //返回空
                return null;
            }
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将byte数组拷到分配好的内存空间
            Marshal.Copy (bytes, p, structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回结构
            return obj;
        }

    }
}