C/S模型之Socket通讯 服务侦听端

   本篇文章讲述Socket的通讯,为基于Socket通讯的C/S模型提供基础.

   Socket通讯通常由两部份组成,一个服务侦听端,一个客户连接端,服务端侦听进站的消息,客户端发送出站的消息,二者不可或缺,下面先讲服务端侦听,该类定义为TcpIpListener(一个抽象类):

1.侦听Socket的创建:CreateListenSocket

  该过程比较简单:在该过程中初始化了侦听Socket(g_ListenSocket),使用IP地址族,流类型,Tcp传输控制协义三个参数创建Socket,并且将其关联到侦听端口(对于侦听Socket这个一定要),另外在该过程中还处始化了一个信号量g_MaxSemaphore,该信号量是为了控制同时在线连接数用的.

2.启动侦听器:StartListen

  在该过程中首先对侦听Socket(g_ListenSocket)调用Listen以开始侦听连接请求,之后调用StartAccept方法开始接受异步连接.

  StartAccept方法:该方法首先g_MaxSemaphore.WaitOne(),等待信号,如果已连接数超过信号量则会阻止,否则通过,

之后的一段代码是获取异步接受连接的必需参数SocketAsyncEventArgs(对该类型不熟的请自行参阅MSN),应该比较容易理解,即:如果有传进不为null的参数,则说明有已使用过的SocketAsyncEventArgs,那么就对其进行必要的设置后(重设SocketError,AcceptSocket这两个属性)使用,否则就去缓冲池中取一个,并设置Completed事件处理程序OnAcceptCompleted,这里的缓冲池就是回收使用过的SocketAsyncEventArgs的类,由于SocketAsyncEventArgs类比较大且使用又频繁,所以使用缓冲池,当然你也可以不使用,直接new一个.完成准备工作后就对侦听Socket调用AcceptAsync,该方法是一个使用SocketAsyncEventArgs类的异步接受传入的连接的方法,该方法返回True则说明在等待接受的连接,一旦接受到连接则会引发SocketAsyncEventArgs的Completed事件,如果返回False,则说明连接已同步接受,此时可以直接处理接受的连接,本过程是直接调用OnAcceptCompleted来处理接受的连接,不论返回True或Fasle接受到的连接都存储在SocketAsyncEventArgs的AcceptSocket属性中

3.连接处理例程:OnAcceptCompleted

该例程仅处理SocketAsyncOperation.Accept类型的事件,其实在本例中也只会有该类型的事件,首先,如果是因为关闭侦听Socket而引发的则会收参数后返回,否则启动一个线程(StartingOnAcceptedConnection)处理已连接的Socket,再后使用已有的参数调用StartAccept以便等待下一个连接

4.已连接的处理:StartingOnAcceptedConnection

  该方法简单,只是保存了已连接的Socket并且调用必需重载的方法OnAcceptedConnection通知继承者有连接已接收,右继承者来使用已连接的Socket进行收发数据的操作(并由使用者负责关闭),只是继承者操作完毕后一定要调用基类的OverOneConnection方法来通知已连接的Socket已使用完毕,否则当连接数到达信号量水平时会阻塞新进的连接

5.关闭侦听器:StopListen

该方法关闭侦听Socket并关闭信号量,清空接受连接的Socket列表

以下是该类的完整代码:

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

namespace YZKStdLibrary.Network.Transe
{
    public abstract class TcpIpListener
    {

        protected TcpIpListener()
        {
             g_ListenSocket = null;
            g_MaxSemaphore = null;
            g_Stop = false;
            g_StartAsyncObject = new object();
            g_AcceptedSocket = new List<Socket>();
        }

        #region 私有变量

        private Socket g_ListenSocket;

        private Semaphore g_MaxSemaphore;

        private bool g_Stop;

        private object g_StartAsyncObject;

        private List<Socket> g_AcceptedSocket;
        #endregion

        #region 私有方法

        private bool CreateListenSocket(IPEndPoint localEndPoint, int maxclientcount)
        {
            try
            {
                g_Stop = false;
                g_MaxSemaphore = new Semaphore(maxclientcount, maxclientcount);
                g_ListenSocket = new Socket(localEndPoint.AddressFamily,
                     SocketType.Stream, ProtocolType.Tcp);
                g_ListenSocket.Bind(localEndPoint);
                return true;
            }
            catch { return false; }
        }

        private void CloseSocket(Socket socket)
        {
            if (socket != null)
            {
                try
                {
                    if (!g_Stop)
                        socket.Shutdown(SocketShutdown.Both);
                }
                catch { }
                try
                {
                    socket.Close();
                }
                catch { }
            }
        }

        private bool StartAccept(SocketAsyncEventArgs arg)
        {
            Socket s = g_ListenSocket;
            if (s != null)
            {
                g_MaxSemaphore.WaitOne();
                SocketAsyncEventArgs x = arg;
                if (x == null)
                {
                    x = TcpIpTranseInterface.SocketArgPools.GetItem();
                    x.SocketError = SocketError.Success;
                    x.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
                }
                else
                {
                    x.SocketError = SocketError.Success;
                    x.AcceptSocket = null;
                }
                bool isasync = false;
                try
                {
                    isasync = s.AcceptAsync(x);
                }
                catch (Exception err)
                {
                    if (!g_Stop)
                        OnUnkownError(err);
                    return false;
                }
                if (!isasync)
                {
                    OnAcceptCompleted(s, x);
                }
                return true;
            }
            return false;
        }

        private void OnAcceptCompleted(object sender, SocketAsyncEventArgs e)
        {
            if (e.LastOperation == SocketAsyncOperation.Accept)
            {
                
                if (g_Stop)
                {
                    RecyArg(e);
                    return;
                }
                Socket soekct = e.AcceptSocket;
                e.AcceptSocket = null;
                if (e.SocketError == SocketError.Success)
                {
                    System.Threading.Tasks.Task.Factory.StartNew(StartingOnAcceptedConnection, soekct);
                }
                int failcount = 0;
                while (!StartAccept(e))
                {
                    failcount++;
                    if (g_Stop)
                        break;
                    if (failcount > 10)
                        break;
                }
            }
        }

        private void RecyArg(SocketAsyncEventArgs e)
        {
            e.AcceptSocket = null;
            e.Completed -= new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
            TcpIpTranseInterface.SocketArgPools.RecyItem(e);
        }

        private void StartingOnAcceptedConnection(object socket)
        {
            Socket s = socket as Socket;
            AddAcceptedSocket(s);
            try
            {
                OnAcceptedConnection(s);
            }
            catch (Exception err)
            {
                RemoveAcceptSocket(s);
                try
                {
                    OnUnkownError(err);
                }
                catch { }
            }
        }

        private bool StartListen(int backlog)
        {
            g_ListenSocket.Listen(backlog);
            return StartAccept(null);
        }

        private void CloseListenSocket()
        {
            if (g_ListenSocket != null)
            {
                try
                {
                    g_ListenSocket.Shutdown(SocketShutdown.Both);
                }
                catch { }
                try
                {
                    g_ListenSocket.Close();
                }
                catch { }
            }
        }

        private void StopListen()
        {
            g_Stop = true;
            CloseListenSocket();
            g_ListenSocket = null;
            if (g_MaxSemaphore != null)
            {
                try
                {
                    g_MaxSemaphore.Close();
                }
                catch { }
                try
                {
                    g_MaxSemaphore.Dispose();
                }
                catch { }
                g_MaxSemaphore = null;
            }
            lock (g_AcceptedSocket)
            {
                g_AcceptedSocket.Clear();
            }
        }

        private void AddAcceptedSocket(Socket s)
        {
            lock (g_AcceptedSocket)
            {
                g_AcceptedSocket.Add(s);
            }
        }

        private void RemoveAcceptSocket(Socket s)
        {
            lock (g_AcceptedSocket)
            {
                if (g_AcceptedSocket.Contains(s))
                {
                    if (g_AcceptedSocket.Remove(s))
                    {
                        try
                        {
                            g_MaxSemaphore.Release();
                        }
                        catch { }
                    }
                }
            }
        }
        #endregion

        #region 受保护方法

        protected bool Start(
            int backlog, 
            IPEndPoint localEndPoint, 
            int maxclientcount)
        {
            lock (g_StartAsyncObject)
            {
                if (g_ListenSocket != null)
                    return true;
                if (CreateListenSocket(localEndPoint, maxclientcount))
                {
                    if (StartListen(backlog))
                        return true;
                    else
                    {
                        StopListen();
                        return false;
                    }
                }
                return false;
            }
        }

        protected void Stop()
        {
            lock (g_StartAsyncObject)
            {
                StopListen();
            }
        }

        protected void OverOneConnection(Socket s)
        {
            RemoveAcceptSocket(s);
        }

        protected EndPoint LocalEndPoint
        {
            get
            {
                if (g_ListenSocket != null)
                    return g_ListenSocket.LocalEndPoint;
                return null;
            }
        }
        #endregion

        #region 可重载成员

        protected virtual void OnUnkownError(Exception error)
        {
        }

        #endregion

        #region 必需重载成员

        protected abstract void OnAcceptedConnection(Socket socket);

        #endregion
    }
}