《Unity3D網絡遊戲實踐》（第2版）要點摘錄 – 「數據流收發」

• 要確保發送數據的完整，需要在發送前將數據保存，如果發送不完整，在Send回調中繼續發送

  • int readIdx = 0; //緩沖區偏移值
    int length = 0; //緩沖區剩餘長度
    ​
    public void Send()
    {
        //sendBytes = 要發送的數據
        length = sendBytes.Length;
        readIdx = 0;
        socket.BeginSend(sendBytes, 0, length, 0, SendCallback, socket);
    }
    ​
    public void SendCallback(IASyncResult ar)
    {
        Socket socket = (Socket)ar.AsyncState;
        int count = socket.EndSend(ar); //返回已發送數據的長度
        readIdx += count; //將readIdx向後移動至已發送數據長度的末尾
        length -= count;
        if(length > 0) //如果全部數據正常發送，length - count應該 == 0
        {
            //如果>0，代表有數據需要重新發送
            socket.BeginSend(sendBytes, readIdx, length, 0, SendCallback, socket);    
        }
    }

ByteArray和Queue

• 上述方案雖然可以確保數據在最終能正常被完整發送出去，但是如果在Callback之前再次調用Send，就會把length和readIdx修改，把這個保障機制干碎。

  • 因此我們需要一個封裝好readIdx、length以及具體數據bytes的數據結構，然後維護一個隊列（Queue<ByteArray>）；每次調用Send時把這個數據入隊，Callback時只修改它自身的length和readIdx，處理完成後出隊。

• ByteArray

  • using System;
    ​
    public class ByteArray
    {
        //默認大小
        const int DEFAULT_SIZE = 1024;
        //初始大小
        int initSize = 0;
    ​
        //緩沖區
        public byte[] bytes;
    ​
        //讀寫位置
        public int readIdx = 0;
        public int writeIdx = 0;
    ​
        //容量
        private int capicity = 0;
        //剩餘空間
        public int remain { get { return capicity - writeIdx; } }
    ​
        //數據長度
        public int length { get { return writeIdx - readIdx; } }
    ​
        public ByteArray(int size = DEFAULT_SIZE)
        {
            bytes = new byte[size];
            capicity = size;
            initSize = size;
            readIdx = 0;
            writeIdx = 0;
        }
    ​
        public ByteArray(byte[] defaultBytes)
        {
            bytes = defaultBytes;
            capicity = defaultBytes.Length;
            initSize = defaultBytes.Length;
            readIdx = 0;
            writeIdx = defaultBytes.Length;
        }
    ​
        //重設尺寸
        public void ReSize(int size)
        {
            if (size < length) { return; }
            if (size < initSize) { return; }
            int n = 1;
            while(n < size) //計算新數組的尺寸， 為避免頻繁重設，一般直接翻倍
            {
                n *= 2;
            }
            capicity = n;
    ​
            //申請新的byte數組並把原數據複製過去
            byte[] newBytes = new byte[capicity];
            Array.Copy(bytes, readIdx, newBytes, 0, writeIdx - readIdx);        
            bytes = newBytes;
    ​
            //重設讀寫索引
            writeIdx = length;
            readIdx = 0;
        }
    ​
        //檢查並移動數據
        public void CheckAndMoveBytes()
        {
            if(length < 8)
            {
                MoveBytes();
            }
        }
    ​
        //移動數據
        public void MoveBytes()
        {
            if(length > 0)
            {
                Array.Copy(bytes, readIdx, bytes, 0, length);
            }
            writeIdx = length;
            readIdx = 0;
        }
    ​
        //寫入數據
        public int Write(byte[] bs, int offset, int count)
        {
            if(remain < count)
            {
                //檢查緩沖區剩餘空間
                ReSize(length + count);
            }
            Array.Copy(bs, offset, bytes, writeIdx, count); //從offset位置寫入
            writeIdx += count;
            return count; //返回新的有效數據長度
        }
    ​
        //讀取數據
        public int Read(byte[] bs, int offset, int count)
        {
            count = Math.Min(count, length);
            Array.Copy(bytes, readIdx, bs, offset, count); //把數據從bytes的readIdx讀取，保存在bs的offset到count的空間中
            readIdx += count; //根據已讀取的數據量更新readIdx
            CheckAndMoveBytes(); //如果剩餘的有效數據很小，可以將數據前移
            return count;
        }
    }

• 具體應用

  • public void Send()
    {
        //byte[] sendByte = 發送的數據字符串
        ByteArray ba = new ByteArray(sendByte);
        int count = 0;
        //BeginSend和回調函數可能於不同線程執行，可能出現多個線程同時操作writeQueue的情況，因此需要加鎖
        lock (writeQueue)
        {
            writeQueue.Enqueue(ba);
            count = writeQueue.Count;
        }
    ​
        if(count == 1)
        {
            socket.BeginSend(sendByte, 0, sendByte.Length, 0, SendCallback, socket);
        }
    }
    ​
    public void SendCallback(IAsyncResult result)
    {
        Socket socket = (Socket)result.AsyncState;
        int count = socket.EndSend(result);
        ByteArray ba;
    ​
        //BeginSend和回調函數可能於不同線程執行，可能出現多個線程同時操作writeQueue的情況，因此需要加鎖
        lock (writeQueue)
        {
            ba = writeQueue.First();
        }
    ​
        ba.readIdx += count;
        if(ba.length == 0) //ba.length = ba.writeIdx - ba.readIdx
        {
            //Send Finished
            //BeginSend和回調函數可能於不同線程執行，可能出現多個線程同時操作writeQueue的情況，因此需要加鎖
            lock (writeQueue)
            {
                writeQueue.Dequeue();
                ba = writeQueue.First(); //Get Next Send ByteArray
            }                
        }
    ​
        if(ba != null)
        {
            //Send Remain ByteArray
            socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
        }
    }