GJM : Socket TCP 通信连接（一）

最新推荐文章于 2022-03-18 09:40:11 发布

Tdou

最新推荐文章于 2022-03-18 09:40:11 发布

阅读量239

点赞数

本文链接：https://blog.csdn.net/gjmvvv/article/details/81300139

版权

本文章将讲解基于TCP连接的Socket通讯，使用Socket异步功能，并且无粘包现象，通过事件驱动使用。

在编写Socket代码之前，我们得要定义一下Socket的基本功能。

作为一个TCP连接，不论是客户端还是服务器端，它都得有以下接口：

public interface ISocket
{
    /// <summary>
    /// 获取是否已连接。
    /// </summary>
    bool IsConnected { get; }
    /// <summary>
    /// 发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    void Send(byte[] data);
    /// <summary>
    /// 异步发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    void SendAsync(byte[] data);
    /// <summary>
    /// 断开连接。
    /// </summary>
    void Disconnect();
    /// <summary>
    /// 异步断开连接。
    /// </summary>
    void DisconnectAsync();        
    /// <summary>
    /// 断开完成时引发事件。
    /// </summary>
    event EventHandler<SocketEventArgs> DisconnectCompleted;
    /// <summary>
    /// 接收完成时引发事件。
    /// </summary>
    event EventHandler<SocketEventArgs> ReceiveCompleted;
    /// <summary>
    /// 发送完成时引发事件。
    /// </summary>
    event EventHandler<SocketEventArgs> SendCompleted;
}

用到的事件参数SocketEventArgs。

/// <summary>
/// Socket事件参数
/// </summary>
public class SocketEventArgs : EventArgs
{
    /// <summary>
    /// 实例化Socket事件参数
    /// </summary>
    /// <param name="socket">相关Socket</param>
    /// <param name="operation">操作类型</param>
    public SocketEventArgs(ISocket socket, SocketAsyncOperation operation)
    {
        if (socket == null)
            throw new ArgumentNullException("socket");
        Socket = socket;
        Operation = operation;
    }

    /// <summary>
    /// 获取或设置事件相关数据。
    /// </summary>
    public byte[] Data { get; set; }

    /// <summary>
    /// 获取数据长度。
    /// </summary>
    public int DataLength { get { return Data == null ? 0 : Data.Length; } }

    /// <summary>
    /// 获取事件相关Socket
    /// </summary>
    public ISocket Socket { get; private set; }

    /// <summary>
    /// 获取事件操作类型。
    /// </summary>
    public SocketAsyncOperation Operation { get; private set; }
}

因为作为客户端只管收发，比较简单，所以这里从客户端开始做起。

定义类TCPClient继承接口ISocket和IDisposable

/// <summary>
/// TCP客户端
/// </summary>
public class TCPClient : ISocket, IDisposable
{
    /// <summary>
    /// 获取是否已连接。
    /// </summary>
    public bool IsConnected { get; }
    /// <summary>
    /// 发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    public void Send(byte[] data)
    {

    }
    /// <summary>
    /// 异步发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    public void SendAsync(byte[] data)
    {

    }
    /// <summary>
    /// 断开连接。
    /// </summary>
    public void Disconnect()
    {

    }
    /// <summary>
    /// 异步断开连接。
    /// </summary>
    public void DisconnectAsync()
    {

    }      
    /// <summary>
    /// 断开完成时引发事件。
    /// </summary>
    public event EventHandler<SocketEventArgs> DisconnectCompleted;
    /// <summary>
    /// 接收完成时引发事件。
    /// </summary>
    public event EventHandler<SocketEventArgs> ReceiveCompleted;
    /// <summary>
    /// 发送完成时引发事件。
    /// </summary>
    public event EventHandler<SocketEventArgs> SendCompleted;

    /// <summary>
    /// 释放资源。
    /// </summary>
    public void Dispose()
    {

    }
}

并在此之上，增加以下方法

    /// <summary>
    /// 连接至服务器。
    /// </summary>
    /// <param name="endpoint">服务器终结点。</param>
    public void Connect(IPEndPoint endpoint)
    {

    }

    /// <summary>
    /// 异步连接至服务器。
    /// </summary>
    /// <param name="endpoint"></param>
    public void ConnectAsync(IPEndPoint endpoint)
    {

    }

下面我们开始编写构造函数，实例化一个Socket并保存到私有变量里。

把IsConnected指向Socket.Connected。

    private Socket Socket;
    private Stream Stream;
    /// <summary>
    /// 实例化TCP客户端。
    /// </summary>
    public TCPClient()
    {
        Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    }

    /// <summary>
    /// 获取是否已连接。
    /// </summary>
    public bool IsConnected { get { return Socket.Connected; } }

因为接下来我们开始编写Socket的异步功能，所以在此之前，我们要做一个状态类，用来保存异步状态。

internal class SocketAsyncState
{
    /// <summary>
    /// 是否完成。
    /// </summary>
    public bool Completed { get; set; }

    /// <summary>
    /// 数据
    /// </summary>
    public byte[] Data { get; set; }
/// <summary>
    /// 是否异步
    /// </summary>
    public bool IsAsync { get; set; }
}

下面我们开始编写TCP连接功能。

    /// <summary>
    /// 连接至服务器。
    /// </summary>
    /// <param name="endpoint">服务器终结点。</param>
    public void Connect(IPEndPoint endpoint)
    {
        //判断是否已连接
        if (IsConnected)
            throw new InvalidOperationException("已连接至服务器。");
        if (endpoint == null)
            throw new ArgumentNullException("endpoint");
        //锁定自己，避免多线程同时操作
        lock (this)
        {
            SocketAsyncState state = new SocketAsyncState();
            //Socket异步连接
            Socket.BeginConnect(endpoint, EndConnect, state).AsyncWaitHandle.WaitOne();
            //等待异步全部处理完成
            while (!state.Completed) { }
        }
    }

    /// <summary>
    /// 异步连接至服务器。
    /// </summary>
    /// <param name="endpoint"></param>
    public void ConnectAsync(IPEndPoint endpoint)
    {
        //判断是否已连接
        if (IsConnected)
            throw new InvalidOperationException("已连接至服务器。");
        if (endpoint == null)
            throw new ArgumentNullException("endpoint");
        //锁定自己，避免多线程同时操作
        lock (this)
        {
            SocketAsyncState state = new SocketAsyncState();
            //设置状态为异步
            state.IsAsync = true;
            //Socket异步连接
            Socket.BeginConnect(endpoint, EndConnect, state);
        }
    }

    private void EndConnect(IAsyncResult result)
    {
        SocketAsyncState state = (SocketAsyncState)result.AsyncState;
    
        try
        {
            Socket.EndConnect(result);
        }
        catch
        {
            //出现异常，连接失败。
            state.Completed = true;
            //判断是否为异步，异步则引发事件
            if (state.IsAsync && ConnectCompleted != null)
                ConnectCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Connect));
            return;
        }
    
        //连接成功。
        //创建Socket网络流
        Stream = new NetworkStream(Socket);
        //连接完成
        state.Completed = true;
        if (state.IsAsync && ConnectCompleted != null)
        {
            ConnectCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Connect));
        }
        
        //开始接收数据
        Handler.BeginReceive(Stream, EndReceive, state);
    }

    /// <summary>
    /// 连接完成时引发事件。
    /// </summary>
    public event EventHandler<SocketEventArgs> ConnectCompleted;

以上为连接服务器的代码，EndConnect中最后的Handler为一个处理IO收发的类，这留到后面再说。

接下来我们开始做断开服务器的方法。

    /// <summary>
    /// 断开与服务器的连接。
    /// </summary>
    public void Disconnect()
    {
        //判断是否已连接
        if (!IsConnected)
            throw new InvalidOperationException("未连接至服务器。");
        lock (this)
        {
            //Socket异步断开并等待完成
            Socket.BeginDisconnect(true, EndDisconnect, true).AsyncWaitHandle.WaitOne();
        }
    }

    /// <summary>
    /// 异步断开与服务器的连接。
    /// </summary>
    public void DisconnectAsync()
    {
        //判断是否已连接
        if (!IsConnected)
            throw new InvalidOperationException("未连接至服务器。");
        lock (this)
        {
            //Socket异步断开
            Socket.BeginDisconnect(true, EndDisconnect, false);
        }
    }

    private void EndDisconnect(IAsyncResult result)
    {
        try
        {
            Socket.EndDisconnect(result);
        }
        catch
        {

        }
        //是否同步
        bool sync = (bool)result.AsyncState;
        
        if (!sync && DisconnectCompleted!=null)
        {
            DisconnectCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Disconnect));
        }
    }

    //这是一个给收发异常准备的断开引发事件方法
    private void Disconnected(bool raiseEvent)
    {
        if (raiseEvent && DisconnectCompleted != null)
            DisconnectCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Disconnect));
    }

至此，我们已经完成了客户端的连接于断开功能。

现在我们开始写客户端的发送接收功能。

对于Socket的发送与接收，在大量数据吞吐的时候，容易造成粘包问题，要解决这个问题，我们先定义一个ISocketHandler接口。

该接口定义了Socket的发送与接收。

public interface ISocketHandler
{
    /// <summary>
    /// 开始接收
    /// </summary>
    /// <param name="stream">Socket网络流</param>
    /// <param name="callback">回调函数</param>
    /// <param name="state">自定义状态</param>
    /// <returns>异步结果</returns>
    IAsyncResult BeginReceive(Stream stream, AsyncCallback callback, object state);
    /// <summary>
    /// 结束接收
    /// </summary>
    /// <param name="asyncResult">异步结果</param>
    /// <returns>接收到的数据</returns>
    byte[] EndReceive(IAsyncResult asyncResult);
    /// <summary>
    /// 开始发送
    /// </summary>
    /// <param name="data">要发送的数据</param>
    /// <param name="offset">数据偏移</param>
    /// <param name="count">发送长度</param>
    /// <param name="stream">Socket网络流</param>
    /// <param name="callback">回调函数</param>
    /// <param name="state">自定义状态</param>
    /// <returns>异步结果</returns>
    IAsyncResult BeginSend(byte[] data, int offset, int count, Stream stream, AsyncCallback callback, object state);
    /// <summary>
    /// 结束发送
    /// </summary>
    /// <param name="asyncResult">异步结果</param>
    /// <returns>发送是否成功</returns>
    bool EndSend(IAsyncResult asyncResult);
}

在TCPClient中添加一个属性。

    /// <summary>
    /// Socket处理程序
    /// </summary>
    public ISocketHandler Handler { get; set; }

这个ISocketHandler在上面的EndConnect里有使用到BeginReceive()。

而使用BeginReceive的回调函数则是这个。

    private void EndReceive(IAsyncResult result)
    {
        SocketAsyncState state = (SocketAsyncState)result.AsyncState;
        //接收到的数据
        byte[] data = Handler.EndReceive(result);
        //如果数据长度为0，则断开Socket连接
        if (data.Length == 0)
        {
            Disconnected(true);
            return;
        }

        //再次开始接收数据
        Handler.BeginReceive(Stream, EndReceive, state);

        //引发接收完成事件
        if (ReceiveCompleted != null)
            ReceiveCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Receive) { Data = data });
    }

有了这个回调函数，我们的客户端就能持续的接收数据。

现在剩下发送数据的功能要完成。

    /// <summary>
    /// 发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    public void Send(byte[] data)
    {
        //是否已连接
        if (!IsConnected)
            throw new SocketException(10057);
        //发送的数据不能为null
        if (data == null)
            throw new ArgumentNullException("data");
        //发送的数据长度不能为0
        if (data.Length == 0)
            throw new ArgumentException("data的长度不能为0");

        //设置异步状态
        SocketAsyncState state = new SocketAsyncState();
        state.IsAsync = false;
        state.Data = data;
        try
        {
            //开始发送数据
            Handler.BeginSend(data, 0, data.Length, Stream, EndSend, state).AsyncWaitHandle.WaitOne();
        }
        catch
        {
            //出现异常则断开Socket连接
            Disconnected(true);
        }
    }

    /// <summary>
    /// 异步发送数据。
    /// </summary>
    /// <param name="data">要发送的数据。</param>
    public void SendAsync(byte[] data)
    {
        //是否已连接
        if (!IsConnected)
            throw new SocketException(10057);
        //发送的数据不能为null
        if (data == null)
            throw new ArgumentNullException("data");
        //发送的数据长度不能为0
        if (data.Length == 0)
            throw new ArgumentException("data的长度不能为0");

        //设置异步状态
        SocketAsyncState state = new SocketAsyncState();
        state.IsAsync = true;
        state.Data = data;
        try
        {
            //开始发送数据并等待完成
            Handler.BeginSend(data, 0, data.Length, Stream, EndSend, state);
        }
        catch
        {
            //出现异常则断开Socket连接
            Disconnected(true);
        }
    }

    private void EndSend(IAsyncResult result)
    {
        SocketAsyncState state = (SocketAsyncState)result.AsyncState;
        
        //是否完成
        state.Completed = Handler.EndSend(result);
        //没有完成则断开Socket连接
        if (!state.Completed)
            Disconnected(true);
        //引发发送结束事件
        if (state.IsAsync && SendCompleted != null)
        {
            SendCompleted(this, new SocketEventArgs(this, SocketAsyncOperation.Send) { Data = state.Data });
        }
    }

至此，客户端的发送接收也完成了。

我们再写一下释放资源的方法。

    /// <summary>
    /// 释放资源
    /// </summary>
    public void Dispose()
    {
        lock (this)
        {
            if (IsConnected)
                Socket.Disconnect(false);
            Socket.Close();
        }
    }

整个客户端编写完成。

下一篇将讲解ISocketHandler的实现方法，用ISocketHandler来完成Socket的IO工作。

你可以在ISocketHandler中定义你自己的Socket通讯协议。

原文地址：http://www.cnblogs.com/Kation/archive/2013/03/06/2946761.html