本文引见

UdpClient 类在同步壅塞形式中为发送和吸收无衔接的 UDP 数据包而供应了简朴的要领。由于 UDP 是一种无衔接的传输协定，所以你不须要在发送和吸收数据之前竖立任何长途主机衔接。你只须要根据以下体式格局来竖立默许的长途主机选项：
运用长途主机称号和端口号作为参数来建立 UdpClient 类的实例。
建立 UdpClient 类的实例然后挪用 Connect 要领。
你能够运用任何由 UdpClient 所供应的发送要领把数据发送给长途装备。然后运用 Receive 要领来吸收来自于长途主机的数据。
提醒：假如你已指定了一个默许的长途主机，就不要运用主机称号或许 IPEndPoint 来挪用 Send 要领。假如你如许做，那末 UdpClient 将会抛出一个非常。

UdpClient 要领一样许可你发送和吸收多点传送的数据包。而运用 JoinMulticastGroup 要领能够把 UdpClient 定阅到多点传送分组。也能够运用 DropMulticastGroup 要领把 UdpClient 从多点传送分组的定阅中作废。

本节引见运用UdpClient完成一个同步的UDP服务器

UdpClient同步UDP服务器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace NetFrame.Net.UDP.Listener.Synchronous
{
    /// <summary>
    /// UdpClient 完成同步UDP服务器
    /// </summary>
    public class UDPServer
    {
        #region Fields
        /// <summary>
        /// 服务器顺序许可的最大客户端衔接数
        /// </summary>
        private int _maxClient;

        /// <summary>
        /// 当前的衔接的客户端数
        /// </summary>
        //private int _clientCount;

        /// <summary>
        /// 服务器运用的异步UdpClient
        /// </summary>
        private UdpClient _server;

        /// <summary>
        /// 客户端会话列表
        /// </summary>
        //private List<UDPState> _clients;

        private bool disposed = false;

        /// <summary>
        /// 数据接收缓冲区
        /// </summary>
        private byte[] _recvBuffer;

        #endregion

        #region Properties

        /// <summary>
        /// 服务器是不是正在运转
        /// </summary>
        public bool IsRunning { get; private set; }
        /// <summary>
        /// 监听的IP地点
        /// </summary>
        public IPAddress Address { get; private set; }
        /// <summary>
        /// 监听的端口
        /// </summary>
        public int Port { get; private set; }
        /// <summary>
        /// 通讯运用的编码
        /// </summary>
        public Encoding Encoding { get; set; }

        #endregion

        #region 组织函数

        /// <summary>
        /// 同步UdpClient UDP服务器
        /// </summary>
        /// <param name="listenPort">监听的端口</param>
        public UDPServer(int listenPort)
            : this(IPAddress.Any, listenPort,1024)
        {
        }

        /// <summary>
        /// 同步UdpClient UDP服务器
        /// </summary>
        /// <param name="localEP">监听的终结点</param>
        public UDPServer(IPEndPoint localEP)
            : this(localEP.Address, localEP.Port,1024)
        {
        }

        /// <summary>
        /// 同步UdpClient UDP服务器
        /// </summary>
        /// <param name="localIPAddress">监听的IP地点</param>
        /// <param name="listenPort">监听的端口</param>
        /// <param name="maxClient">最大客户端数目</param>
        public UDPServer(IPAddress localIPAddress, int listenPort, int maxClient)
        {
            this.Address = localIPAddress;
            this.Port = listenPort;
            this.Encoding = Encoding.Default;

            _maxClient = maxClient;
            //_clients = new List<AsyncUDPSocketState>();
            _server = new UdpClient(new IPEndPoint(this.Address, this.Port));

            _recvBuffer=new byte[_server.Client.ReceiveBufferSize];
        }

        #endregion

        #region Method
        /// <summary>
        /// 启动服务器
        /// </summary>
        /// <returns>异步TCP服务器</returns>
        public void Start()
        {
            if (!IsRunning)
            {
                IsRunning = true;
                _server.EnableBroadcast = true;
                new Thread(ReceiveData).Start();
            }
        }

        /// <summary>
        /// 住手服务器
        /// </summary>
        public void Stop()
        {
            if (IsRunning)
            {
                IsRunning = false;
                _server.Close();
                //TODO 封闭对一切客户端的衔接

            }
        }

        /// <summary>
        /// 同步吸收数据的要领
        /// </summary>
        /// <param name="ar"></param>
        private void ReceiveData()
        {
            IPEndPoint remote = null;
            while (true)
            {
                byte[] buffer = null;
                try
                {
                    buffer = _server.Receive(ref remote);
                }
                catch (Exception)
                {
                    //非常处置惩罚操纵
                    return;
                }
                if (buffer == null || buffer.Length == 0) return;
                //TODO 数据包收到触发事宜
                RaiseDataReceived(null);
            }
        }

        /// <summary>
        /// 同步发送数据
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="remote"></param>
        public void Send(string msg, IPEndPoint remote)
        {
            byte[] data = Encoding.Default.GetBytes(msg);
            try
            {
                _server.Send(data, data.Length, remote);
            }
            catch (Exception)
            {
                //TODO 非常处置惩罚
                RaiseOtherException(null);
            }
        }

        #endregion

        #region 事宜
        /// <summary>
        /// 吸收到数据事宜
        /// </summary>
        public event EventHandler<UDPEventArgs> DataReceived;

        private void RaiseDataReceived(UDPState state)
        {
            if (DataReceived != null)
            {
                DataReceived(this, new UDPEventArgs(state));
            }
        }

        /// <summary>
        /// 数据发送终了事宜
        /// </summary>
        public event EventHandler<UDPEventArgs> CompletedSend;

        /// <summary>
        /// 触发数据发送终了的事宜
        /// </summary>
        /// <param name="state"></param>
        private void RaiseCompletedSend(UDPState state)
        {
            if (CompletedSend != null)
            {
                CompletedSend(this, new UDPEventArgs(state));
            }
        }

        /// <summary>
        /// 收集毛病事宜
        /// </summary>
        public event EventHandler<UDPEventArgs> NetError;
        /// <summary>
        /// 触发收集毛病事宜
        /// </summary>
        /// <param name="state"></param>
        private void RaiseNetError(UDPState state)
        {
            if (NetError != null)
            {
                NetError(this, new UDPEventArgs(state));
            }
        }

        /// <summary>
        /// 非常事宜
        /// </summary>
        public event EventHandler<UDPEventArgs> OtherException;
        /// <summary>
        /// 触发非常事宜
        /// </summary>
        /// <param name="state"></param>
        private void RaiseOtherException(UDPState state, string descrip)
        {
            if (OtherException != null)
            {
                OtherException(this, new UDPEventArgs(descrip, state));
            }
        }
        private void RaiseOtherException(UDPState state)
        {
            RaiseOtherException(state, "");
        }
        #endregion

        #region Close
        /// <summary>
        /// 封闭一个与客户端之间的会话
        /// </summary>
        /// <param name="state">须要封闭的客户端会话对象</param>
        public void Close(UDPState state)
        {
            if (state != null)
            {
                //_clients.Remove(state);
                //_clientCount--;
                //TODO 触发封闭事宜
            }
        }
        /// <summary>
        /// 封闭一切的客户端会话,与一切的客户端衔接会断开
        /// </summary>
        public void CloseAllClient()
        {
            //foreach (AsyncUDPSocketState client in _clients)
            //{
            //    Close(client);
            //}
            //_clientCount = 0;
            //_clients.Clear();
        }

        #endregion

        #region 开释
        /// <summary>
        /// Performs application-defined tasks associated with freeing, 
        /// releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release 
        /// both managed and unmanaged resources; <c>false</c> 
        /// to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    try
                    {
                        Stop();
                        if (_server != null)
                        {
                            _server = null;
                        }
                    }
                    catch (SocketException)
                    {
                        //TODO
                        RaiseOtherException(null);
                    }
                }
                disposed = true;
            }
        }
        #endregion
    }
}

用户状况封装类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;

namespace NetFrame.Net.UDP.Listener.Synchronous
{
    public class UDPState
    {
        // Client   socket.
        public UdpClient udpClient = null;
        // Size of receive buffer.
        public const int BufferSize = 1024;
        // Receive buffer.
        public byte[] buffer = new byte[BufferSize];
        // Received data string.
        public StringBuilder sb = new StringBuilder();

        public IPEndPoint remote = new IPEndPoint(IPAddress.Any, 0);
    }
}

服务器事宜参数类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NetFrame.Net.UDP.Listener.Synchronous
{
    /// <summary>
    /// UdpClient 同步UDP服务器事宜类
    /// </summary>
    public class UDPEventArgs : EventArgs
    {
        /// <summary>
        /// 提醒信息
        /// </summary>
        public string _msg;

        /// <summary>
        /// 客户端状况封装类
        /// </summary>
        public UDPState _state;

        /// <summary>
        /// 是不是已处置惩罚过了
        /// </summary>
        public bool IsHandled { get; set; }

        public UDPEventArgs(string msg)
        {
            this._msg = msg;
            IsHandled = false;
        }
        public UDPEventArgs(UDPState state)
        {
            this._state = state;
            IsHandled = false;
        }
        public UDPEventArgs(string msg, UDPState state)
        {
            this._msg = msg;
            this._state = state;
            IsHandled = false;
        }
    }
}

以上就是C#收集编程系列文章(八)之UdpClient完成同步UDP服务器的内容，更多相关内容请关注ki4网（www.ki4.cn）！