Unity3D中簡單的C#異步Socket實現

 

 

　　簡單的異步Socket實現。.net框架自身提供了很完善的Socket底層。筆者在做Unity3D小東西的時候需要使用到Socket網絡通信。於是決定自己研究研究。

　　經過不懈努力。。O(∩_∩)O哈哈~。。自我誇獎一下。終於搞定了。SimpleSocket.cs

 

　　由於筆者本身並不是專業的C#程序員。O(∩_∩)O哈哈~。大神就可以直接忽視這篇文章了。顧名思義。哈哈簡單的Socket。給那些沒接觸的盆友參考借鑒下吧。服務社會了

　　

　　注釋一： 本例在編碼上使用的是大端存貯,這個和C#本身是沖突的. 需要小端存儲的朋友可以將MiscUtil的EndianBitConverter修改成.net提供的BitConverter

　　注釋二： 筆者這里使用了Protobuf協議. 所以寫了一個工具在這里做轉換使用. 大家可以直接刪除Protobuf的那部分代碼.不會對本例產生任何影響

　　注釋三：筆者這里實現了一個基於長度的解碼器。用於避免粘包等問題。編碼時候的長度描述數字的默認為short類型（長度2字節）。解碼時候的長度描述數字默認為int類型（長度4字節）

 

　　上源碼：注釋的比較詳細了。不明白的可以問我。

 

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using Google.ProtocolBuffers;
using MiscUtil.Conversion;

// +------------------------+
// |    Author : TinyZ      |
// |   Data : 2014-08-12    |
// |Ma-il : [e-mail]|
// +------------------------+
// 注釋一： 本例在編碼上使用的是大端存貯,這個和C#本身是沖突的. 需要小端存儲的朋友可以將MiscUtil的EndianBitConverter修改成.net提供的BitConverter
// 注釋二： 筆者這里使用了Protobuf協議. 所以寫了一個工具在這里做轉換使用. 大家可以直接刪除Protobuf的那部分代碼.不會對本例產生任何影響
// 注釋三： 筆者這里實現了一個基於長度的解碼器。用於避免粘包等問題。編碼時候的長度描述數字的默認為short類型（長度2字節）。解碼時候的長度描述數字默認為int類型（長度4字節）
// 引用資料:
// Miscellaneous Utility Library類庫官網: http://www.yoda.arachsys.com/csharp/miscutil/

namespace Assets.TinyZ.Class.SimpleNet
{
    /// <summary>
    /// 簡單的異步Socket實現. 用於Unity3D客戶端與JAVA服務端的數據通信.
    /// 
    /// <br/><br/>方法：<br/>
    /// Connect：用於連接遠程指定端口地址,連接成功后開啟消息接收監聽<br/>
    /// OnSendMessage：用於發送字節流消息. 長度不能超過short[65535]的長度<br/>
    /// <br/>事件：<br/>
    /// ReceiveMessageCompleted： 用於回調. 返回接收到的根據基於長度的解碼器解碼之后獲取的數據[字節流]
    /// 
    /// <br/><br/>
    /// [*]完全不支持C#等小端（Little Endian）編碼
    /// <br/><br/>
    /// 服務器為JAVA開發。因此編碼均為 BigEndian編碼
    /// 消息的字節流格式如下：<br/>
    ///     * +------------+-------------+ <br/>
    ///     * |消息程度描述|  內容       | <br/>
    ///     * |    0x04    | ABCD        | <br/>
    ///     * +------------+-------------+ <br/>
    /// 注釋: 消息頭為消息內容長度描述,后面是相應長度的字節內容. 
    /// 由於是大端存儲.所以無法使用C#提供的<see cref="BitConverter"/>進行解碼.
    /// 本例使用的是網絡開源MiscUtil中的大端轉換器<see cref="EndianBitConverter"/> 
    /// <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 ReceiveMessageCompletedEvent;
    ///     if (rmc == null) return;
    ///     var data = rmc.MessageData 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 Socket _socket;

        /// <summary>
        /// SimpleSocket的構造函數
        /// </summary>
        public SimpleSocket()
        {
            _socket = new 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>
        /// <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);
            StartReceive();
        }

        #endregion


        #region Send Message

        /// <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;
                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;
                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)
        {
            SocketError socketError;
            _socket.EndSend(ar, out socketError);
            if (socketError != SocketError.Success)
            {
                _socket.Disconnect(false);
                throw new SocketException((int)socketError);
            }
            //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 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;
            // 幀長度 
            var length = EndianBitConverter.Big.ToInt32(frameLength, 0);
            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 ReceiveMessageCompletedEvent(data));
            }
            StartReceive();
        }

        #endregion


        #region Protocol Buffers Utility

        /// <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 = ConvertMessageToByteArray(generatedExtensionLite, messageLite);
            OnSendMessage(data);
        }

        /// <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();
        }

        /// <summary>
        /// byte[]轉換為Message
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <param name="generatedExtensionLite"></param>
        /// <returns></returns>
        public static IMessageLite ConvertByteArrayToMessage<T>(byte[] data, GeneratedExtensionLite<ServerMessage, T> generatedExtensionLite) where T : IMessageLite
        {
            ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
            extensionRegistry.Add(ProtobufMsgEnterGame.MsgEnterGame);
            extensionRegistry.Add(ProtobufMsgLogin.MsgLogin);
            extensionRegistry.Add(MsgBuyItem.msgBuyItem);

            ServerMessage serverMessage = ServerMessage.ParseFrom(data, extensionRegistry);
            return serverMessage.HasExtension(generatedExtensionLite)
                ? serverMessage.GetExtension(generatedExtensionLite)
                : default(T);
        }

        #endregion
    }

    #region Event

    /// <summary>
    /// 消息接收完成事件
    /// </summary>
    public class ReceiveMessageCompletedEvent : EventArgs
    {
        /// <summary>
        /// 接收到的數據
        /// </summary>
        private readonly object _data;

        public ReceiveMessageCompletedEvent(object data)
        {
            _data = data;
        }

        /// <summary>
        /// 消息數據
        /// </summary>
        public object MessageData
        {
            get { return _data; }
        }
    }

    #endregion
}

 

 

ps：

由於當初寫這個代碼的時候比較粗糙。筆者覺得新開一章發布版本1.1的。優化了一下以前的代碼。推薦使用新的

直接上連接：

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

 

 

 

 

 

 

--------------------------------------------------------------分割線-- 打個小廣告-----------------------------------------------------------

女裝飾品店:http://aoleitaisen.taobao.com 

 

歡迎轉載,轉載必須保留

我的郵箱:[e-mail] 博客地址: http://www.cnblogs.com/zou90512

否則視為侵權