簡單的異步Socket實現——SimpleSocket_V1.1

 

　　筆者在前段時間的博客中分享了一段簡單的異步.net的Socket實現。由於是筆者自己測試使用的。寫的很粗糙。很簡陋。於是花了點時間自己去完善了一下

　　舊版本的SimpleSocket大致實現了異步socket的全部功能。但是代碼擴展性較差。對很多事件都沒有做出相對應的處理。在1.1版本進行了相對應的維護和更新。

　　

　　SimpleSocket（簡稱：SS）是一個簡單的.net原生的Socket簡單封裝。實現了異步操作。SS利用長度的解碼器來解決和避免粘包等網絡問題。

 　　新增特性：

　　　　1.增加對.net原生的小端存儲支持. 通過define是否是大端編碼及可以切換存儲形式

　　　　2.獨立的Protocol Buffers編解碼器工具. 通過define機可以開啟關閉是否需要Protobuf支持

　　　　3.對Socket的部分管理。例如關閉和斷開連接

　　　　4.增加消息發送完成事件，連接建立完成事件，消息接收完成事件

 

下面上代碼： SimpleSocket.cs  1.1版本

// +------------------------+
// |    Author : TinyZ      |
// |   Data : 2014-08-20    |
// |Ma-il : [e-mail]|
// |     Version : 1.1      |
// +------------------------+
// 注釋： 筆者這里實現了一個基於長度的解碼器。用於避免粘包等問題。編碼時候的長度描述數字的默認為short類型（長度2字節）。解碼時候的長度描述數字默認為int類型（長度4字節）

// GOOGLE_PROTOCOL_BUFFERS : 
//      是否支持Google的Protocol Buffers. 作者自己使用的.
//      Define request Google protocol buffers
//      Example: #define GOOGLE_PROTOCOL_BUFFERS
//      相關資料: 
//      [推薦]protobuf-csharp-port：https://code.google.com/p/protobuf-csharp-port/ . PB最好,最完整的C#實現.使用.net 20版本即可以完美支持Unity3D 4.3x以上版本
//      protobuf-net: https://code.google.com/p/protobuf-net/ 
//#define GOOGLE_PROTOCOL_BUFFERS
//
// BIG_ENDIANESS :
//      是否是大端存儲. 是=>使用大端存儲,將使用Misc類庫提供的大端存儲工具EndianBitConverter. 否=>使用.Net提供的BitConverter
//      Define is socket endianess is big-endianess(大端) . If endianess is Big-endianess use EndianBitConverter , else use BitConverter
//      相關資料:
//      Miscellaneous Utility Library類庫官網: http://www.yoda.arachsys.com/csharp/miscutil/
#define BIG_ENDIANESS

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
#if BIG_ENDIANESS
using MiscUtil.Conversion;
#endif
#if GOOGLE_PROTOCOL_BUFFERS
using Google.ProtocolBuffers;
using Assets.TinyZ.Socket.Codec;
#endif

namespace Assets.TinyZ.Socket
{
    /// <summary>
    /// 簡單的異步Socket實現. 用於Unity3D客戶端與JAVA服務端的數據通信.
    /// 
    /// <br/><br/>方法：<br/>
    /// Connect：用於連接遠程指定端口地址,連接成功后開啟消息接收監聽<br/>
    /// OnSendMessage：用於發送字節流消息. 長度不能超過short[65535]的長度<br/>
    /// <br/>事件：<br/>
    /// ReceiveMessageCompleted： 用於回調. 返回接收到的根據基於長度的解碼器解碼之后獲取的數據[字節流]
    /// SendMessageCompleted:   用於回調. 當消息發送完成時
    /// ConnectCompleted： 用於回調. 當成功連接到遠程網絡地址后調用
    /// 
    /// <br/><br/>
    /// 服務器為JAVA開發。因此編碼均為 BigEndian編碼
    /// 消息的字節流格式如下：<br/>
    ///     * +------------+-------------+ <br/>
    ///     * |消息程度描述|  內容       | <br/>
    ///     * |    0x04    | ABCD        | <br/>
    ///     * +------------+-------------+ <br/>
    /// 注釋: 消息頭為消息內容長度描述,后面是相應長度的字節內容. 
    /// <br/><br/>
    /// </summary>
    /// <example>
    /// <code>
    /// // Unity3D客戶端示例代碼如下:
    /// var _simpleSocket = new SimpleSocket();
    /// _simpleSocket.Connect("127.0.0.1", 9003);
    /// _simpleSocket.ReceiveMessageCompleted += (s, e) =>
    /// {
    ///     var rmc = e as SocketEventArgs;
    ///     if (rmc == null) return;
    ///     var data = rmc.Data as byte[];
    ///     if (data != null)
    ///     {
    ///         // 在Unity3D控制台輸出接收到的UTF-8格式字符串 
    ///         Debug.Log(Encoding.UTF8.GetString(data));
    ///     }
    //      _count++;
    /// };
    /// 
    /// // Unity3D客戶端發送消息：
    /// _simpleSocket.OnSendMessage(Encoding.UTF8.GetBytes("Hello World!"));
    /// </code>
    /// </example>
    public class SimpleSocket
    {
        #region Construct

        /// <summary>
        /// Socket
        /// </summary>
        private readonly System.Net.Sockets.Socket _socket;

        /// <summary>
        /// SimpleSocket的構造函數
        /// </summary>
        public SimpleSocket()
        {
            _socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
            //_socket.Blocking = false; // ?
        }

        /// <summary>
        /// 初始化Socket, 並設置幀長度
        /// </summary>
        /// <param name="encoderLengthFieldLength">編碼是消息長度數字的字節數長度. 1：表示1byte  2：表示2byte[Short類型] 4：表示4byte[int類型] 8：表示8byte[long類型]</param>
        /// <param name="decoderLengthFieldLength">解碼時消息長度數字的字節數長度. 1：表示1byte  2：表示2byte[Short類型] 4：表示4byte[int類型] 8：表示8byte[long類型]</param>
        public SimpleSocket(int encoderLengthFieldLength, int decoderLengthFieldLength) : this()
        {
            _encoderLengthFieldLength = encoderLengthFieldLength;
            _decoderLengthFieldLength = decoderLengthFieldLength;
        }

        #endregion


        #region Connect to remote host

        /// <summary>
        /// 連接遠程地址完成事件
        /// </summary>
        public event EventHandler<SocketEventArgs> ConnectCompleted;

        /// <summary>
        /// 是否連接狀態
        /// </summary>
        /// <see cref="Socket.Connected"/>
        public bool Connected
        {
            get { return _socket != null && _socket.Connected; }
        }

        /// <summary>
        /// 連接指定的遠程地址
        /// </summary>
        /// <param name="host">遠程地址</param>
        /// <param name="port">端口</param>
        public void Connect(string host, int port)
        {
            _socket.BeginConnect(host, port, OnConnectCallBack, this);
        }

        /// <summary>
        /// 連接指定的遠程地址
        /// </summary>
        /// <param name="ipAddress">目標網絡協議ip地址</param>
        /// <param name="port">目標端口</param>
        /// 查看:<see cref="IPAddress"/>
        public void Connect(IPAddress ipAddress, int port)
        {
            _socket.BeginConnect(ipAddress, port, OnConnectCallBack, this);
        }

        /// <summary>
        /// 連接端點
        /// </summary>
        /// <param name="endPoint">端點, 標識網絡地址</param>
        /// 查看:<see cref="EndPoint"/>
        public void Connect(EndPoint endPoint)
        {
            _socket.BeginConnect(endPoint, OnConnectCallBack, this);
        }

        /// <summary>
        /// 連接的回調函數
        /// </summary>
        /// <param name="ar"></param>
        private void OnConnectCallBack(IAsyncResult ar)
        {
            if (!_socket.Connected) return;
            _socket.EndConnect(ar);
            if (ConnectCompleted != null)
            {
                ConnectCompleted(this, new SocketEventArgs());
            }
            StartReceive();
        }

        #endregion


        #region Send Message

        /// <summary>
        /// 發送消息完成
        /// </summary>
        public event EventHandler<SocketEventArgs> SendMessageCompleted;

        /// <summary>
        /// 編碼時長度描述數字的字節長度[default = 2 => 65535字節]
        /// </summary>
        private readonly int _encoderLengthFieldLength = 2;

        /// <summary>
        /// 發送消息
        /// </summary>
        /// <param name="data">要傳遞的消息內容[字節數組]</param>
        public void OnSendMessage(byte[] data)
        {
            var stream = new MemoryStream();
            switch (_encoderLengthFieldLength)
            {
                case 1:
                    stream.Write(new[] {(byte) data.Length}, 0, 1);
                    break;
#if BIG_ENDIANESS
                case 2:
                    stream.Write(EndianBitConverter.Big.GetBytes((short) data.Length), 0, 2);
                    break;
                case 4:
                    stream.Write(EndianBitConverter.Big.GetBytes(data.Length), 0, 4);
                    break;
                case 8:
                    stream.Write(EndianBitConverter.Big.GetBytes((long) data.Length), 0, 8);
                    break;
#else
                case 2:
                    stream.Write(BitConverter.GetBytes((short) data.Length), 0, 2);
                    break;
                case 4:
                    stream.Write(BitConverter.GetBytes(data.Length), 0, 4);
                    break;
                case 8:
                    stream.Write(BitConverter.GetBytes((long) data.Length), 0, 8);
                    break;
#endif

                default:
                    throw new Exception("unsupported decoderLengthFieldLength: " + _encoderLengthFieldLength +
                                        " (expected: 1, 2, 3, 4, or 8)");
            }
            stream.Write(data, 0, data.Length);
            var all = stream.ToArray();
            stream.Close();
            _socket.BeginSend(all, 0, all.Length, SocketFlags.None, OnSendMessageComplete, all);
        }

        /// <summary>
        /// 發送消息完成的回調函數
        /// </summary>
        /// <param name="ar"></param>
        private void OnSendMessageComplete(IAsyncResult ar)
        {
            var data = ar.AsyncState as byte[];
            SocketError socketError;
            _socket.EndSend(ar, out socketError);
            if (socketError != SocketError.Success)
            {
                _socket.Disconnect(false);
                throw new SocketException((int)socketError);
            }
            if (SendMessageCompleted != null)
            {
                SendMessageCompleted(this, new SocketEventArgs(data));
            }
            //Debug.Log("Send message successful !");
        }

        #endregion


        #region Receive Message

        /// <summary>
        /// the length of the length field. 長度字段的字節長度, 用於長度解碼 
        /// </summary>
        private readonly int _decoderLengthFieldLength = 4;

        /// <summary>
        /// 事件消息接收完成
        /// </summary>
        public event EventHandler<SocketEventArgs> ReceiveMessageCompleted;

        /// <summary>
        /// 開始接收消息
        /// </summary>
        private void StartReceive()
        {
            if (!_socket.Connected) return;
            var buffer = new byte[_decoderLengthFieldLength];
            _socket.BeginReceive(buffer, 0, _decoderLengthFieldLength, SocketFlags.None, OnReceiveFrameLengthComplete, buffer);
        }

        /// <summary>
        /// 實現幀長度解碼.避免粘包等問題
        /// </summary>
        private void OnReceiveFrameLengthComplete(IAsyncResult ar)
        {
            var frameLength = (byte[]) ar.AsyncState;
            // 幀長度 
#if BIG_ENDIANESS
            var length = EndianBitConverter.Big.ToInt32(frameLength, 0);
#else
            var length = BitConverter.ToInt32(frameLength, 0);
#endif
            var data = new byte[length];
            _socket.BeginReceive(data, 0, length, SocketFlags.None, OnReceiveDataComplete, data);
        }

        /// <summary>
        /// 數據接收完成的回調函數
        /// </summary>
        private void OnReceiveDataComplete(IAsyncResult ar)
        {
            _socket.EndReceive(ar);
            var data = ar.AsyncState as byte[];
            // 觸發接收消息事件
            if (ReceiveMessageCompleted != null)
            {
                ReceiveMessageCompleted(this, new SocketEventArgs(data));
            }
            StartReceive();
        }

        #endregion


        #region Close and Disconnect

        /// <summary>
        /// 關閉 <see cref="Socket"/> 連接並釋放所有關聯的資源
        /// </summary>
        public void Close()
        {
            _socket.Close();
        }

        /// <summary>
        /// 關閉套接字連接並允許重用套接字。
        /// </summary>
        /// <param name="reuseSocket">如果關閉當前連接后可以重用此套接字，則為 true；否則為 false。 </param>
        public void Disconnect(bool reuseSocket)
        {
            _socket.Disconnect(reuseSocket);
        }

        #endregion


        #region Protocol Buffers Utility [Request ： Google Protocol Buffers version 2.5]

#if GOOGLE_PROTOCOL_BUFFERS

        /// <summary>
        /// 發送消息
        /// </summary>
        /// <typeparam name="T">IMessageLite的子類</typeparam>
        /// <param name="generatedExtensionLite">消息的擴展信息</param>
        /// <param name="messageLite">消息</param>
        public void OnSendMessage<T>(GeneratedExtensionLite<ServerMessage, T> generatedExtensionLite, T messageLite)
            where T : IMessageLite
        {
            var data = ProtobufEncoder.ConvertMessageToByteArray(generatedExtensionLite, messageLite);
            OnSendMessage(data);
        }

#endif

        #endregion
    }

    #region Event

    /// <summary>
    /// Simple socket event args
    /// </summary>
    public class SocketEventArgs : EventArgs
    {

        public SocketEventArgs()
        {
        }

        public SocketEventArgs(byte[] data) : this()
        {
            Data = data;
        }

        /// <summary>
        /// 相關的數據
        /// </summary>
        public byte[] Data { get; private set; }

    }

    #endregion

}

 

 下面是筆者自己使用的Protocol Buffers的編解碼器。類庫需求：protobuf-csharp-port 523版本。有興趣的可以自己試試。

　　解碼器是通用的解碼器.是仿照Netty的ProtobufDecoder解碼器C#實現。

//     +------------------------+
//     |    Author : TinyZ      |
//     |   Data : 2014-08-20    |
//     |Ma-il : [e-mail]|
//     +------------------------+
//      引用資料: 
//      [推薦]protobuf-csharp-port：https://code.google.com/p/protobuf-csharp-port/ . PB最好,最完整的C#實現.使用.net 20版本即可以完美支持Unity3D 4.3x以上版本
//      protobuf-net: https://code.google.com/p/protobuf-net/ 


using System;
using Google.ProtocolBuffers;

namespace Assets.TinyZ.Socket.Codec
{
    /// <summary>
    /// Protocol Buffers 解碼器
    /// </summary>
    public class ProtobufDecoder
    {
        private readonly IMessageLite _prototype;

        /// <summary>
        /// 擴展消息注冊
        /// </summary>
        private readonly ExtensionRegistry _extensionRegistry;

        public ProtobufDecoder(IMessageLite prototype)
        {
            _prototype = prototype.WeakDefaultInstanceForType;
        }

        public ProtobufDecoder(IMessageLite prototype, ExtensionRegistry extensionRegistry)
            : this(prototype)
        {
            _extensionRegistry = extensionRegistry;
        }

        /// <summary>
        /// 注冊擴展
        /// </summary>
        /// <param name="extension">protobuf擴展消息</param>
        public void RegisterExtension(IGeneratedExtensionLite extension)
        {
            if (_extensionRegistry == null)
            {
                throw new Exception("ExtensionRegistry must using InitProtobufDecoder method to initialize. ");
            }
            _extensionRegistry.Add(extension);
        }

        /// <summary>
        /// 解碼
        /// </summary>
        /// <param name="data">protobuf編碼字節數組</param>
        /// <returns>返回解碼之后的消息</returns>
        public IMessageLite Decode(byte[] data)
        {
            if (_prototype == null)
            {
                throw new Exception("_prototype must using InitProtobufDecoder method to initialize.");
            }
            IMessageLite message;
            if (_extensionRegistry == null)
            {
                message = (_prototype.WeakCreateBuilderForType().WeakMergeFrom(ByteString.CopyFrom(data))).WeakBuild();
            }
            else
            {
                message =
                    (_prototype.WeakCreateBuilderForType().WeakMergeFrom(ByteString.CopyFrom(data), _extensionRegistry))
                        .WeakBuild();
            }
            if (message == null)
            {
                throw new Exception("Decode message failed");
            }
            return message;
        }
    }
}

 

　　編碼器。方法ConvertMessageToByteArray是筆者自己寫來測試使用的。大家可以無視之

　　

//     +------------------------+
//     |    Author : TinyZ      |
//     |   Data : 2014-08-20    |
//     |Ma-il : [e-mail]|
//     +------------------------+
//      引用資料: 
//      [推薦]protobuf-csharp-port：https://code.google.com/p/protobuf-csharp-port/ . PB最好,最完整的C#實現.使用.net 20版本即可以完美支持Unity3D 4.3x以上版本
//      protobuf-net: https://code.google.com/p/protobuf-net/ 

using Google.ProtocolBuffers;

namespace Assets.TinyZ.Socket.Codec
{
    /// <summary>
    /// Protocol Buffers 編碼器
    /// </summary>
    public class ProtobufEncoder
    {
        /// <summary>
        /// [自用]Message轉換為byte[]
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="generatedExtensionLite"></param>
        /// <param name="messageLite"></param>
        /// <returns></returns>
        public static byte[] ConvertMessageToByteArray<T>(GeneratedExtensionLite<ServerMessage, T> generatedExtensionLite, T messageLite) where T : IMessageLite
        {
            ServerMessage.Builder builder = ServerMessage.CreateBuilder();
            builder.SetMsgId("" + generatedExtensionLite.Number);
            builder.SetExtension(generatedExtensionLite, messageLite);
            ServerMessage serverMessage = builder.Build();
            return serverMessage.ToByteArray();
        }

        public static byte[] Encode(IMessageLite messageLite)
        {
            return messageLite.ToByteArray();
        }

        public static byte[] Encode(IBuilder builder)
        {
            return builder.WeakBuild().ToByteArray();
        }
    }
}

 

 源碼下載地址：http://pan.baidu.com/s/1pJz7Tv9   

ps：因為筆者最近使用Unity3D。所以示例源碼是Unity3D的。假如你沒有安裝過Unity3D。也沒關系。筆者同時提供了zip壓縮包。包含cs源文件

 

作者：TinyZ
出處：http://www.cnblogs.com/zou90512/
關於作者：努力學習，天天向上。不斷探索學習，提升自身價值。記錄經驗分享。
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文鏈接
如有問題，可以通過 [e-mail] 聯系我，非常感謝。
筆者網店: http://aoleitaisen.taobao.com. 歡迎圍觀。O(∩_∩)O哈哈~