• 关于C#UDP接收缓冲区溢出处理方案


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    
    namespace LAN
    {
        /// <summary>
        /// UdpSocket使用方法:
        /// 1:首先实例化UdpSocket(本机ip,本机端口) UdpSocket udpSocket = new UdpSocket(xx,xx);
        /// 2:然后执行初始化 udpSocket.Init(Rev3232)。Rev3232为需要用到的进程方法名
        /// 3:注意例程带//********//位置的操作。
        /// 4:关闭时先执行_threadFlag3232 = false;然后执行udpSocket.Close();
        /// 例程:
            //UdpSocket udpSocket = new UdpSocket(xx,xx); 
            //_threadFlag3232 = true;
            //udpSocket.Init(Rev3232);
            //
            // private void Rev3232()
            //{
            //    //接收数据处理线程 
            //    string msg = "";
            //    MyInvoke_3232 myI = new MyInvoke_3232(UpdateMsg_3232);
            //    while (_threadFlag3232)
            //    {
            //        if (udpSocket.RevQueue.Count == 0)//********//
            //        {
            //            Thread.Sleep(1);
            //            continue;
            //        }
            //        else
            //        {
                        
            //            byte[] data;
            //            lock (udpSocket.Lock)//********//
            //            {
            //                _test2 = udpSocket.RevQueue.Count;//********//
            //                data = udpSocket.RevQueue.Dequeue();//********//
            //            }
            //            int rlen = data.Length;
            //            int[] intDataBuff = new int[rlen / 4];
            //            for (int i = 0; i < rlen / 4; i++)
            //            {
            //                intDataBuff[i] = BitConverter.ToInt32(data, i * 4);
            //            }
    
            //            if ((intDataBuff[0] == 0x48449880) && ((intDataBuff[1] == 0x21111996) || (intDataBuff[1] == 0x21111997)))
            //            {
            //                _revFlag = 1;
            //            }
            //            BeginInvoke(myI, new object[] { data });
            //        }
            //    }
            //}
        /// </summary>
        public class  UdpSocket
        {
            #region 私有变量
            private EndPoint _sendIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            private readonly byte[] _revDataBuffBytes = new byte[2048];
            private readonly AsyncCallback ReceiveCallback;
            private bool _closeFlag;
            #endregion
    
            #region 公有变量
            public Queue<byte[]> RevQueue = new Queue<byte[]>();
            public Socket MySocket;
            public readonly object Lock = new object();
            public string MyIpAddr ;
            public int MyPortNum;
            public Thread RevThread;
            public delegate void InvokeFun();
            
            #endregion
            /// <summary>
            /// 实例化UdpSocket
            /// </summary>
            /// <param name="myIpAddr">本机IP地址</param>
            /// <param name="myPortNum">本机需要打开的端口</param>
            public UdpSocket(string myIpAddr, int myPortNum)
            {
                ReceiveCallback = new AsyncCallback(OnDataReceived);
                MySocket = null;
                MyIpAddr = myIpAddr;
                MyPortNum = myPortNum;
    
            }
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="revFun">线程功能函数(不带参数)</param>
            /// <returns>返回初始化成功的Socket</returns>
            public Socket Init(InvokeFun revFun)
            {
                try
                {
                    IPAddress lip;
                    IPAddress.TryParse(MyIpAddr, out lip);
                    //初始化socket,定义网络类型,数据连接类型与网络协议UDP
                    MySocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                    MySocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
                    IPEndPoint ipLocalPoint = new IPEndPoint(lip, MyPortNum);
                    //绑定网络地址
                    MySocket.Bind(ipLocalPoint);
                    MySocket.ReceiveBufferSize = 64 * 1024;
                    _closeFlag = true;
                    RevThread = new Thread(new ThreadStart(revFun));
                    RevThread.Start();
                    MySocket.BeginReceive(_revDataBuffBytes, 0, _revDataBuffBytes.Length, SocketFlags.None, ReceiveCallback, MySocket);
                    return MySocket;
                }
                catch
                {
                    return null;
                }
            }
            /// <summary>
            /// 初始化
            /// </summary>
            /// <returns>返回初始化成功的Socket</returns>
            public Socket Init()
            {
                try
                {
                    IPAddress lip;
                    IPAddress.TryParse(MyIpAddr, out lip);
                    //初始化socket,定义网络类型,数据连接类型与网络协议UDP
                    MySocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                    MySocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
                    IPEndPoint ipLocalPoint = new IPEndPoint(lip, MyPortNum);
                    //绑定网络地址
                    MySocket.Bind(ipLocalPoint);
                    MySocket.ReceiveBufferSize = 64 * 1024;
                    _closeFlag = true;
                    MySocket.BeginReceive(_revDataBuffBytes, 0, _revDataBuffBytes.Length, SocketFlags.None, ReceiveCallback, MySocket);
                    return MySocket;
                }
                catch
                {
                    return null;
                }
            }
            private void OnDataReceived(IAsyncResult ar)
            {
                try
                {
                    if (_closeFlag == true)
                    {
                        Socket udpSocket = ar.AsyncState as Socket;
                        int bytesRecved = udpSocket.EndReceive(ar);
                        byte[] data = new byte[bytesRecved];
                        Array.Copy(_revDataBuffBytes, data, bytesRecved);
                        lock (Lock)
                        {
                            RevQueue.Enqueue(data);
                        }
                        MySocket.BeginReceive(_revDataBuffBytes, 0, _revDataBuffBytes.Length, SocketFlags.None, ReceiveCallback, MySocket);
                    }
                    
                }
                catch 
                {
                   
                }
            }
    
            public void Close()
            {
                _closeFlag = false;
                if (RevThread != null)
                {
                    RevThread.Abort();
                }
                MySocket.Close();
                RevQueue.Clear();
            }
        }
    }
  • 相关阅读:
    Spring 中众多的的Initializer
    Spring Factories
    spring 的各种context
    @import和@Bean的区别,以及ImportSelector和ImportBeanDefinitionRegistrar两个接口的简单实用
    Spring 配置的方式
    记一次JAVA FULL GC问题处理【3】
    关于String, StringBuilder,StringBuffer 的一些测试数据
    记一次JAVA FULL GC问题处理【2】
    ThreadLocal 结构
    记一次JAVA FULL GC问题处理【1】
  • 原文地址:https://www.cnblogs.com/karl-wu/p/4359907.html
Copyright © 2020-2023  润新知