UDP通信是一种高效率的通信协议，虽然会出现丢包现象，但我们可以通过更上层的协议或者其他方法来实现重发，所以，被广泛的用户Socket的通信中。下面介绍下C#中，UDP的实现。

/// <summary>
    /// 远程端点（IP和端口）
    /// </summary>
    private IPEndPoint mIPEndPoint;
    /// <summary>
    /// socket
    /// </summary>
    private Socket mSocket;
    /// <summary>
    /// 运行标记
    /// </summary>
    private bool mUDPRunningFlag = false;
    /// <summary>
    /// 接收线程
    /// </summary>
    private Thread mUDPReceiveThread;
    /// <summary>
    /// 监听端口号
    /// </summary>
    private int mUDPMonitorPort = 9527;
/// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="port">监听端口</param>
    public UDPHandler(int port)
    {
        mDictionary = new Dictionary<string, string>();

        mUDPMonitorPort = port;

        mIPEndPoint = new IPEndPoint(IPAddress.Any, this.mUDPMonitorPort);

        mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

        long IOC_IN = 0x80000000;

        long IOC_VENDOR = 0x18000000;

        long SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;

        byte[] optionInValue = { Convert.ToByte(false) };

        byte[] optionOutValue = new byte[4];

        mSocket.IOControl((int)SIO_UDP_CONNRESET, optionInValue, optionOutValue);
    }
 /// <summary>
    /// 启动监听线程
    /// </summary>
    public void StartUDPMonitor()
    {
        if (mUDPReceiveThread != null)
        {
            Thread.Sleep(30);

            mUDPReceiveThread.Abort();
        }

        mUDPRunningFlag = true;

        mSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

        //绑定网络地址
        mSocket.Bind(mIPEndPoint);

        //启动监听线程
        mUDPReceiveThread = new Thread(new ThreadStart(ReceiveData));

        mUDPReceiveThread.ApartmentState = ApartmentState.STA;

        mUDPReceiveThread.IsBackground = true;

        mUDPReceiveThread.Start();
    }
/// <summary>
    /// 接收数据
    /// </summary>
    private void ReceiveData()
    {
        EndPoint mRemoteEndPoint = new IPEndPoint(IPAddress.Any, mUDPMonitorPort);

        int dataLength = 0;

        while (mUDPRunningFlag)
        {
            //在有数据到达时接收
            if (mSocket.Poll(-1, SelectMode.SelectRead))
            {
                byte[] receiveData = null;

                try
                {
                    byte[] data = new byte[mSocket.Available];

                    dataLength = mSocket.ReceiveFrom(data, data.Length, SocketFlags.None, ref mRemoteEndPoint);

                    //数据到达
                    receiveData = data;

                    //数据处理
                    DataHandler(data, mRemoteEndPoint);

                    data = null;

                }
                catch (Exception ex)
                {
                    string ss = ex.ToString();
                    throw ex;
                }
            }
        }
    }
 /// <summary>
    /// 处理过程
    /// </summary>
    /// <param name="recByte"></param>
    /// <param name="mEndPoint"></param>
    private void DataHandler(byte[] recByte, EndPoint mEndPoint)
    {
        int head = recByte[0];

        int cmd = recByte[1];

        byte deviceType = recByte[2];

        //判断头是否符合
        if (head == ComminicationType.DEF_PROTOCOL_STORAGE_HEAD)
        {
            CommunicateRecProtoclData mCommunicateRecProtoclData = new CommunicateRecProtoclData();

            mCommunicateRecProtoclData.head = head;

            mCommunicateRecProtoclData.cmd = cmd;

            mCommunicateRecProtoclData.remoteEndPoint = mEndPoint;

            mCommunicateRecProtoclData.mComminicationType = deviceType;

            CommunicateRecDataEventArgs mCommunicateRecDataEventArgs = new CommunicateRecDataEventArgs(mCommunicateRecProtoclData);

            switch (cmd)
            {
               
            }
        }
    }

    /// <summary>
    /// 发送消息(到指定地址)
    /// </summary>
    public bool SendUDPMsg(byte[] data, EndPoint remotePoint)
    {
        bool flag = false;

        while (true)
        {

            if (mSocket.Poll(-1, SelectMode.SelectWrite))
            {
                try
                {
                    int sendUDPDataLength = mSocket.SendTo(data, data.Length, SocketFlags.None, remotePoint);

                    if (sendUDPDataLength >= data.Length)
                    {
                        flag = true;
                    }
                    else
                    {
                        flag = false;
                    }

                    break;
                }
                catch (Exception ex)
                {
                    flag = false;

                    throw ex;
                }

            }
            else if (mSocket.Poll(-1, SelectMode.SelectError))
            {
                flag = false;
                break;
            }
            else
            {
                continue;
            }
        }
        return flag;
    }

上面就是实现UDP通信的一个简单的代码。