public class UDPSocketService
    {

        //private  static Socket          ServerSocketSender;
        private static int ServerUDPPortSend = 6790; // 
        private static Socket ServerSocketReceiver;
        private static AsyncCallback UDPReceiveCallback;             //udp回调函数 
        private static byte[] dataBuffers;                    //udp字节缓存  
        private static EndPoint ServerEndPoint;
        private static IPAddress svrIPAddress;

        public static IPAddress ServerIPAddress
        {
            get { return UDPSocketService.svrIPAddress; }
            set { UDPSocketService.svrIPAddress = value; }
        }
        private static int svrUDPPortReceive = 9051; //  

        internal static int ServerUDPPortReceive
        {
            get { return UDPSocketService.svrUDPPortReceive; }
            set { UDPSocketService.svrUDPPortReceive = value; }
        }


        ///// <summary>
        ///// 取安装本软件的服务器ip
        ///// </summary>
        ///// <returns></returns>
        //public static IPAddress GetLocalIP()
        //{
        //    IPHostEntry iphostentry = Dns.GetHostByName(Dns.GetHostName());
        //    IPAddress HostIP = null;
        //    if (iphostentry.AddressList.Length > 0)
        //    { HostIP = iphostentry.AddressList[0]; }
        //    return HostIP;
        //}
        public static void UDPDataSend(byte[] data)
        {
            try
            {

                Socket ServerSocketSender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                IPEndPoint iepBroadcast = new IPEndPoint(IPAddress.Broadcast, ServerUDPPortSend);//255.255.255.255

                ServerSocketSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
                ServerSocketSender.SendTo(data, iepBroadcast);  //An operation was attempted on something that is not a socket
                ServerSocketSender.Close();
            }
            catch (Exception se)
            {
                BizLogic.LogWriter.AddSystemException(se);
            }

        }
        public static void UDPDataSendTo(byte[] data, string IPAdd)
        {
            try
            {
                if (string.IsNullOrEmpty (IPAdd) == true  || IPAdd == "N/A")
                { return; }
                Socket ServerSocketSender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                IPEndPoint iepBroadcast = new IPEndPoint(IPAddress.Parse(IPAdd), ServerUDPPortSend);//255.255.255.255

                ServerSocketSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
                ServerSocketSender.SendTo(data, iepBroadcast);
                ServerSocketSender.Close();
            }
            catch (Exception se)
            {
                BizLogic.LogWriter.AddSystemException(se);
            }

        }

        /// <summary>
        /// 后台监听接收
        /// </summary>
        public static void UDPOnListen()
        {
            try
            {
                 
                    dataBuffers = new byte[2048];
                    //svrIPAddress = GetLocalIP();
                    //System.Windows.Forms.MessageBox.Show(svrIPAddress.ToString(), svrUDPPortReceive.ToString());

                    ServerEndPoint = new IPEndPoint(svrIPAddress, svrUDPPortReceive);

                    UDPReceiveCallback = new AsyncCallback(UDPDataReceived);

                    ServerSocketReceiver = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                    ServerSocketReceiver.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
                   
                    //ServerSocketReceiver.Bind(ServerEndPoint);//不允许运行第二个该下载工具,在这会报异常
                    try
                    {
                        ServerSocketReceiver.Bind(ServerEndPoint);//不允许运行第二个该下载工具,在这会报异常
                    }
                    catch (System.Net.Sockets.SocketException ex)
                    {
                        if (ex.SocketErrorCode == System.Net.Sockets.SocketError.AddressAlreadyInUse)
                        {
                            System.Windows.Forms.MessageBox.Show("监听端口已被其他程序占用，不能正确获得在线播放器信息，请退出程序？",
                          "端口占用错误", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                           
                        }
                        throw ex;

                    }

                    ServerSocketReceiver.ReceiveTimeout = 5;
                    ServerSocketReceiver.ReceiveBufferSize = 2048;

                    ServerSocketReceiver.BeginReceiveFrom(dataBuffers, 0, dataBuffers.Length, SocketFlags.None,
                        ref   ServerEndPoint, UDPReceiveCallback, ServerSocketReceiver);
                 

            }
            catch (Exception ex)
            {
                BizLogic.LogWriter.AddSystemException(ex);
            }

        }


        /// <summary>
        /// UDP回调
        /// </summary>
        /// <param name="ar"></param>
        private static void UDPDataReceived(IAsyncResult ar)
        {
            try
            {
                Socket udpSocket = ar.AsyncState as Socket;
                //070128  退出时异常：由于线程退出或应用程序请求，已放弃 I/O 操作
                int bytesRecved = udpSocket.EndReceiveFrom(ar, ref   (EndPoint)ServerEndPoint);
                //当收到数据后，数据已在dataBuffers，把dataBuffers转换成可识别的结构体，依据命令类型Type

                //接收到的package是来自哪个ipaddress，把dataBuffers，ipaddress传过去，在第一次刷新时显示


                BizLogic.DataProcessor.DataFilter(dataBuffers);


                System.Threading.Thread.Sleep(5);
                ServerSocketReceiver.BeginReceiveFrom(dataBuffers, 0, dataBuffers.Length, SocketFlags.None,
                    ref  ServerEndPoint, UDPReceiveCallback, ServerSocketReceiver);
            }
            catch (Exception ex)
            {
                BizLogic.LogWriter.AddSystemException(ex);
            }
        }


        public static bool IsUDPConnected()
        {
            if (ServerSocketReceiver.Connected == true)//判断UDP接受的状态
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        public static void Close()
        {
            if (ServerSocketReceiver == null)
                return;
            if (ServerSocketReceiver.Connected == true)
            { ServerSocketReceiver.Close(); }
        }


 

    }

 /// <summary>
    /// 分析截获UDP数据包
    /// </summary>
    public class DataProcessor
    {




        #region" 结构体struct与字节数组 byte[] 的转换 "

        /// 结构体转byte数组
        /// </summary>
        /// <param name="structObj">要转换的结构体</param>
        /// <returns>转换后的byte数组</returns>
        public static byte[] StructToBytes(object structObj)
        {
            byte[] bytes;
            try
            {
                //得到结构体的大小
                int size = Marshal.SizeOf(structObj);
                //创建byte数组
                bytes = new byte[size];
                //分配结构体大小的内存空间
                IntPtr structPtr = Marshal.AllocHGlobal(size);
                //将结构体拷到分配好的内存空间
                Marshal.StructureToPtr(structObj, structPtr, false);
                //从内存空间拷到byte数组
                Marshal.Copy(structPtr, bytes, 0, size);
                //释放内存空间
                Marshal.FreeHGlobal(structPtr);
                //返回byte数组
                return bytes;
            }
            catch (Exception ex)
            {
                BizLogic.LogWriter.AddSystemException(ex);
                return bytes = null;
            }

        }

        /// byte数组转结构体
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <param name="type">结构体类型</param>
        /// <returns>转换后的结构体</returns>
        public static object BytesToStuct(byte[] bytes, Type type)
        {
            object obj;
            try
            {
                //得到结构体的大小
                //mbox.msgbox(type.FullName);
                int size = Marshal.SizeOf(type);
                //byte数组长度小于结构体的大小
                if (size > bytes.Length)
                {
                    //返回空
                    return obj = null;
                }
                //分配结构体大小的内存空间
                IntPtr structPtr = Marshal.AllocHGlobal(size);
                //将byte数组拷到分配好的内存空间
                Marshal.Copy(bytes, 0, structPtr, size);
                //将内存空间转换为目标结构体
                obj = Marshal.PtrToStructure(structPtr, type);
                //释放内存空间
                Marshal.FreeHGlobal(structPtr);
                //返回结构体
                return obj;
            }
            catch (Exception ex)
            {
                BizLogic.LogWriter.AddSystemException(ex);
                return obj = null;
            }
        }



        #endregion

        /// <summary>
        /// 数据包接收过滤器
        /// </summary>
        public static void DataFilter(byte[] packets)
        {

            switch (packets[1])
            {
                case 0x01:
                    switch (packets[2])
                    {
                        case 0x01:
                            //"packets Server rec RefreshResponse"
                            //System.Windows.Forms.MessageBox.Show("packets Server rec RefreshResponse");
                            DTOProcess.RefreshResponseProcessor(packets);
                            break;
                       。。。。。。。。。
                        default:
                            break;
                    }
                    break;
                case 0x02:
                    switch (packets[2])
                    {
                        case 0x01:
                            //System.Windows.Forms.MessageBox.Show("packets Server rec 08-02-01");////FTP传完文件返回的消息确认？
                            DTOProcess.GetMediaFile_TResponseProcessor(packets);
                            break;
                        。。。。。
                        default:
                            break;
                    }
                    break;
                case 0x03:
                    switch (packets[2])
                    {
                        case 0x01:
                            //System.Windows.Forms.MessageBox.Show("packets Server rec 03-02-01");////FTP传完文件返回的消息确认？
                           
                            break;
                     。。。。                    }
                    break;
                case 0x04:
                    switch (packets[2])
                    {
                        case 0x01:
                            //System.Windows.Forms.MessageBox.Show("packets Server rec 04-02-01");////FTP传完文件返回的消息确认？
 
                         。。。。。。                    }
                    break;
                default:
                    break;
                
            }

        }


    }

using ICSharpCode.SharpZipLib.Core;
using ICSharpCode.SharpZipLib.Zip;

using System;
using System.IO;
using System.Text;


        #region 常量定义
        //压缩的级别;    压缩级别有1 - 9
        private const int COMPRESS_LEVEL = 6;
        #endregion

               /// <summary>
        /// 将指定文件生成压缩文件
        /// </summary>
        /// <param name="pSourceFiles">
        /// 待压缩文件列表串
        /// 每个文件必须是完整路径，文件与文件之间使用","半角逗号分隔
        /// 压缩处理是先生成压缩文件，然后以文件流的方式依次添加待压缩的文件至压缩文件中
        /// </param>
        /// <param name="pDestinationFileName">生成的压缩文件名</param>
        /// <param name="pPassword">解压密码</param>
        /// <param name="pInformation">操作提示信息，用于记录错误信息</param>
        /// <returns>如果解压成功返回true,否则返回false</returns>
        public bool ZipFile(string pSourceFiles, string pDestinationFileName, string pPassword, ref string pInformation)
        {
            bool isSuccess = false;

            try
            {
                string[] fileList = pSourceFiles.Split(',');

                //创建zip文件
                if(CreateFile(pDestinationFileName))
                {
                
                    using(FileStream zipFileStream = File.OpenWrite(pDestinationFileName))
                    {
                        ZipOutputStream zipStream = new ZipOutputStream(zipFileStream);

                        //设置压缩密码
                        zipStream.Password = pPassword;
                        //设置压缩级别
                        zipStream.SetLevel(COMPRESS_LEVEL);
                        
                        foreach(string srcFileName in fileList)
                        {
                            //添加文件至zip文件中
                            ZipFileIntoZip(srcFileName, ref zipStream);
                        }

                        zipStream.Finish();
                        zipStream.Close();
                        isSuccess = true;
                    }
                }
            }
            catch(Exception e)
            {    
                isSuccess = false;
                //删除失败的zip文件
                DeleteFile(pDestinationFileName);

                mErrorInfo = string.Format("文件压缩失败!\r\n详细信息:{0}",e.Message);
                
            }
            
            pInformation = mErrorInfo;

            return isSuccess;
        }

        /// <summary>
        /// 解压缩指定文件
        /// </summary>
        /// <param name="pSourceFile">待解压缩的文件全路径</param>
        /// <param name="pPassword">解压密码</param>
        /// <param name="pZipTempPath">解压临时目录</param>
        /// <param name="pFileList">
        /// 解压后的文件名串
        /// 每个文件名都是全路径表示,文件名之间用半角逗号","分隔</param>
        /// <param name="pInformation">操作提示信息，用于记录错误信息</param>
        /// <returns>解压成功时返回true,否则返回false</returns>
        public bool UnZipFile(string pSourceFile, string pPassword, string pZipTempPath, ref string pFileList, 
                            ref string pInformation)
        {
            bool isSuccess = false;
            
            StringBuilder fileListBuilder = new StringBuilder();

            try
            {
                if(File.Exists(pSourceFile))
                {
                    if(CreateFolder(pZipTempPath))
                    {    
                        using(FileStream zipFileStream = File.OpenRead(pSourceFile))
                        {
                            ZipInputStream zipStream = new ZipInputStream(zipFileStream);
                            //设置压缩密码
                            zipStream.Password = pPassword;
                            
                            ZipEntry fileEntry;
                            while ((fileEntry = zipStream.GetNextEntry()) != null)
                            {
                                string directoryName = Path.GetDirectoryName(fileEntry.Name);
                                string fileName      = Path.GetFileName(fileEntry.Name);

                                if(directoryName.Length > 0)
                                {
                                    string unZipFolder = Path.Combine(pZipTempPath, directoryName);
                                    if(!Directory.Exists(unZipFolder))
                                    {
                                        Directory.CreateDirectory(unZipFolder);
                                    }
                                }
                                
                                if (fileName != String.Empty)
                                {
                                    string unZipFileName = Path.Combine(pZipTempPath, fileEntry.Name);
                                    unZipFileName = unZipFileName.Replace("/", @"\");
                                    //逐个文件解压缩
                                    UnZipFileFromZip(unZipFileName, ref zipStream);

                                    if(fileListBuilder.Length > 0)
                                    {
                                        fileListBuilder.Append(",");
                                    }
                                    fileListBuilder.Append(unZipFileName);
                                }
                            }
                            
                            zipStream.Close();
                            pFileList = fileListBuilder.ToString();
                            isSuccess = true;
                        }
                    }
                }
                else
                {
                    mErrorInfo = "待压缩的文件不存在!";
                }
            }
            catch(Exception e)
            {
                isSuccess = false;
                mErrorInfo = string.Format("文件解压缩失败!\r\n详细信息:{0}",e.Message);
            }

            pInformation = mErrorInfo;

            return isSuccess;
        }