u3d局域网游戏网络（c# socket select 模型）——续

原文：http://www.cnblogs.com/saucerman/p/5555793.html

因为项目要加语音。语音数据都非常大。所以顺带就把之前写的网络模块一起测试了。

然后发现了一些bug，逐修。本来想在原文上面直接修改掉。但是恐怕已经看到的人拿去用了之后，再回头看也不一定能看明白，索性再写一文，将新文件直接放上来。

错误修改：

1. 网络接收数据后，有一种情况没有处理完整，导致接收数据之后数据池的计数器没有向后偏移
2. 网络数据处理后，当当前包仅剩1字节，下一个次数据进来的时候，需要2字节才能确认当前消息长度。增加了消息补齐机制。
3. 增加了当网络数据拥堵的时候，直接断开当前链接。
4. MsgUnPack的GetHead函数获取消息id的时候使用了错误的函数，导致数据偏移不正确
5. MsgUnPack的UnPack(byte[] mBuff, ushort offset, ushort len)，由于总buff扩大，导致offset参数超过上限，改为int
6. 消息事件增加了错误消息ID过滤

由于语音的需求，将原本的服务器段接受buff容量扩大一倍。增加了语音模块。

特别说下语音模块。

http://blog.csdn.net/huutu/article/details/20216613

这是原文。

稍做修改。特别说一下这个语音模块在使用中容易遇到的问题。

1. 如果声音太小，可能是你录音设备的侦听开得不够。
2. 本地测试还好，放到网络上之后，因为代码里有处理，如果没有对象会创建对象并且添加必要组件。原文在创建的时候比特率是手动填写的。导致我客户端一个比特率，服务器一个比特率。然后客户端听着一切正常，传给服务器就错了。后来查了一天，排查各个代码段之后才找到这个原因。

以下是代码：

新增语音模块：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using UnityEngine;
using System.Collections;

[RequireComponent(typeof(AudioSource))]
public class MicroPhoneInput : MonoBehaviour
{

    private static MicroPhoneInput m_instance;

    public float sensitivity = 100;
    public float loudness = 0;

    private static string[] micArray = null;

    const int HEADER_SIZE = 44;

    const int RECORD_TIME = 5;
    const int RECORD_frequency = 8000;

    // Use this for initialization  
    void Start()
    {
    }

    public static MicroPhoneInput getInstance()
    {
        if (m_instance == null)
        {
            micArray = Microphone.devices;
            if (micArray.Length == 0)
            {
                Debug.LogError("Microphone.devices is null");
            }
            foreach (string deviceStr in Microphone.devices)
            {
                Debug.Log("device name = " + deviceStr);
            }
            if (micArray.Length == 0)
            {
                Debug.LogError("no mic device");
            }

            GameObject MicObj = new GameObject("MicObj");
            m_instance = MicObj.AddComponent<MicroPhoneInput>();
        }
        return m_instance;
    }

    public void StartRecord()
    {
        audio.Stop();
        if (micArray.Length == 0)
        {
            Debug.Log("No Record Device!");
            return;
        }
        audio.loop = false;
        audio.mute = true;
        audio.clip = Microphone.Start(null, false, RECORD_TIME, RECORD_frequency); //22050   
        while (!(Microphone.GetPosition(null) > 0))
        {
        }
        audio.Play();
        Debug.Log("StartRecord");
        //倒计时  
        StartCoroutine(TimeDown());

    }

    public void StopRecord()
    {
        if (micArray.Length == 0)
        {
            Debug.Log("No Record Device!");
            return;
        }
        if (!Microphone.IsRecording(null))
        {
            return;
        }
        Microphone.End(null);
        audio.Stop();

        Debug.Log("StopRecord");

    }

    public Byte[] GetClipData()
    {
        if (audio.clip == null)
        {
            Debug.Log("GetClipData audio.clip is null");
            return null;
        }

        float[] samples = new float[audio.clip.samples];

        audio.clip.GetData(samples, 0);


        Byte[] outData = new byte[samples.Length * 2];
        //Int16[] intData = new Int16[samples.Length];  
        //converting in 2 float[] steps to Int16[], //then Int16[] to Byte[]  

        int rescaleFactor = 32767; //to convert float to Int16  

        for (int i = 0; i < samples.Length; i++)
        {
            short temshort = (short)(samples[i] * rescaleFactor);

            Byte[] temdata = System.BitConverter.GetBytes(temshort);

            outData[i * 2] = temdata[0];
            outData[i * 2 + 1] = temdata[1];


        }
        if (outData == null || outData.Length <= 0)
        {
            Debug.Log("GetClipData intData is null");
            return null;
        }
        //return intData;  
        return outData;
    }
    public void PlayClipData(Int16[] intArr)
    {
        if (intArr.Length == 0)
        {
            Debug.Log("get intarr clipdata is null");
            return;
        }
        //从Int16[]到float[]  
        float[] samples = new float[intArr.Length];
        int rescaleFactor = 32767;
        for (int i = 0; i < intArr.Length; i++)
        {
            samples[i] = (float)intArr[i] / rescaleFactor;
        }

        //从float[]到Clip  
        AudioSource audioSource = this.GetComponent<AudioSource>();
        if (audioSource.clip == null)
        {
            audioSource.clip = AudioClip.Create("playRecordClip", intArr.Length, 1, RECORD_frequency, false, false);
        }
        audioSource.clip.SetData(samples, 0);
        audioSource.mute = false;
        audioSource.Play();
    }
    public void PlayRecord()
    {
        if (audio.clip == null)
        {
            Debug.Log("audio.clip=null");
            return;
        }
        audio.mute = false;
        audio.loop = false;
        audio.Play();
        Debug.Log("PlayRecord");

    }



    public float GetAveragedVolume()
    {
        float[] data = new float[256];
        float a = 0;
        audio.GetOutputData(data, 0);
        foreach (float s in data)
        {
            a += Mathf.Abs(s);
        }
        return a / 256;
    }

    // Update is called once per frame  
    void Update()
    {
//         loudness = GetAveragedVolume() * sensitivity;
//         if (loudness > 1)
//         {
//             Debug.Log("loudness = " + loudness);
//         }
    }

    private IEnumerator TimeDown()
    {
        Debug.Log(" IEnumerator TimeDown()");

        int time = 0;
        while (time < RECORD_TIME)
        {
            if (!Microphone.IsRecording(null))
            { //如果没有录制  
                Debug.Log("IsRecording false");
                yield break;
            }
            Debug.Log("yield return new WaitForSeconds " + time);
            yield return new WaitForSeconds(1);
            time++;
        }
        if (time >= 10)
        {
            Debug.Log("RECORD_TIME is out! stop record!");
            StopRecord();
        }
        yield return 0;
    }
}

接下来的都和之前的一样。

using UnityEngine;
/*
 * 通信协议
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    class ClientMsgUnPack : MsgUnPack
    {
        long m_UserID;
        public ClientMsgUnPack()
        {
            m_UserID = -1;
        }

        public ClientMsgUnPack(byte[] mBuff, ushort len, long userID)
        {
            m_UserID = userID;
            UnPack(mBuff, len);
        }

        public ClientMsgUnPack(byte[] mBuff, int offset, ushort len, long userID)
        {
            m_UserID = userID;
            UnPack(mBuff, offset, len);
        }

        public long GetUserID()
        {
            return m_UserID;
        }

        public void SetUserID(long userID)
        {
            m_UserID = userID;
        }
    }
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

delegate void ServerEventDelagate(LanSocket.ClientMsgUnPack msg);

class EventNode
{
    public int m_EventID;
    public LanSocket.ClientMsgUnPack msg;
}

class EventDispathBase
{
    public static int g_MaxEventNum = 300;
}

class ServerEventDispath : EventDispathBase
{
    List<ServerEventDelagate>[] m_Event;
    Queue<EventNode> m_EventQueue;
    public ServerEventDispath()
    {
        m_Event = new List<ServerEventDelagate>[g_MaxEventNum];
        m_EventQueue = new Queue<EventNode>();
    }

    public void RegistEvent(int eventID, ServerEventDelagate func)
    {
        if(null == m_Event[eventID])
        {
            m_Event[eventID] = new List<ServerEventDelagate>();
        }
        m_Event[eventID].Add(func);
    }

    public void AddEvent(EventNode eventNode)
    {
        m_EventQueue.Enqueue(eventNode);
    }

    public void Proccess()
    {
        if (0 != m_EventQueue.Count)
        {
            EventNode mCur = m_EventQueue.Dequeue();
            if (mCur.m_EventID >= g_MaxEventNum || mCur.m_EventID < 0)
            {
                MonoBehaviour.print("error event ID: " + mCur.m_EventID);
                return;
            }
            if (null == m_Event[mCur.m_EventID])
            {
                MonoBehaviour.print("event ID: "+ mCur.m_EventID+" is null");
            }
            else
            {
                List<ServerEventDelagate> curEventDelagate = m_Event[mCur.m_EventID];
                for(int i = 0 ; i < curEventDelagate.Count ; ++i)
                {
                    curEventDelagate[i](mCur.msg);
                }
            }
        }
    }
}


delegate void ClientEventDelagate(LanSocket.MsgUnPack msg);
class ClientEventDispath : EventDispathBase
{
    List<ClientEventDelagate>[] m_Event;
    Queue<EventNode> m_EventQueue;
    public ClientEventDispath()
    {
        m_Event = new List<ClientEventDelagate>[g_MaxEventNum];
        m_EventQueue = new Queue<EventNode>();
    }

    public void RegistEvent(int eventID, ClientEventDelagate func)
    {
        if (null == m_Event[eventID])
        {
            m_Event[eventID] = new List<ClientEventDelagate>();
        }
        m_Event[eventID].Add(func);
    }

    public void AddEvent(EventNode eventNode)
    {
        m_EventQueue.Enqueue(eventNode);
    }

    public void Proccess()
    {
        if (0 != m_EventQueue.Count)
        {
            EventNode mCur = m_EventQueue.Dequeue();
            if (mCur.m_EventID >= g_MaxEventNum || mCur.m_EventID < 0)
            {
                MonoBehaviour.print("error event ID: " + mCur.m_EventID);
                return;
            }
            if (null == m_Event[mCur.m_EventID])
            {
                MonoBehaviour.print("event ID: " + mCur.m_EventID + " is null");
            }
            else
            {
                List<ClientEventDelagate> curEventDelagate = m_Event[mCur.m_EventID];
                for (int i = 0; i < curEventDelagate.Count; ++i)
                {
                    curEventDelagate[i](mCur.msg);
                }
            }
        }
    }
}

using System.Threading;
using UnityEngine;

/*
 *轻量级局域网服务器。 
 * 协议如下
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    public class LanSocketBase
    {
        public static int m_MaxOnePackBuff = 1024 * 3;
        public static int m_MaxAllBuff = 1024 * 100;
        public static int m_HeadSize = 6;
        protected bool m_HasInit = false;
        private Mutex m_Mutex;

        public void BaseInit()
        {
            m_HasInit = true;
            m_Mutex = new Mutex();
        }

        public void BaseRelease()
        {
            m_Mutex.Close();
        }

        protected void Lock()
        {
            m_Mutex.WaitOne();
            //MonoBehaviour.print("Lock:" + Thread.CurrentThread.ManagedThreadId.ToString());
        }

        protected void UnLock()
        {
            m_Mutex.ReleaseMutex();
            //MonoBehaviour.print("Unlock:" + Thread.CurrentThread.ManagedThreadId.ToString());
        }
    }
}

using UnityEngine;
/*
 * 通信协议
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    public class MsgPack : PackBase
    {
        public MsgPack()
        {
            m_OnePackIndex = LanSocketBase.m_HeadSize;
        }

        public void SetHead(int ID)
        {
            byte[] mBuff = System.BitConverter.GetBytes(ID);
            System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 2, 4);
        }

        public void PackEnd()
        {
            byte[] mBuff = System.BitConverter.GetBytes(m_OnePackIndex);
            System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 0, 2);
        }

        public void Packbool(bool data)
        {
            ushort curDatalen = 1;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Packbool() longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }

        public void Pack16bit(short data)
        {
            ushort curDatalen = 2;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack16bit(short) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack16bit(ushort data)
        {
            ushort curDatalen = 2;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack16bit(ushort) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack32bit(int data)
        {
            ushort curDatalen = 4;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack32bit(int) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack32bit(uint data)
        {
            ushort curDatalen = 4;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack32bit(uint) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack32bit(float data)
        {
            ushort curDatalen = 4;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack32bit(float) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack64bit(double data)
        {
            ushort curDatalen = 8;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack64bit(double) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }
        public void Pack64bit(long data)
        {
            ushort curDatalen = 8;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("Pack64bit(long) longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.BitConverter.GetBytes(data);
            Pack(mBuff, curDatalen);
        }

        public void PackString(string data, ushort len)
        {
            ushort curDatalen = len;
            if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("PackString() longer lager than Max buff len");
                return;
            }
            byte[] mBuff = System.Text.Encoding.UTF8.GetBytes(data);
            Pack(mBuff, curDatalen);
        }

        public void PackByte(byte[] data, int offset, ushort len)
        {
            if (m_OnePackIndex + len > m_MaxOnePackBuff)
            {
                MonoBehaviour.print("PackByte() longer lager than Max buff len");
                return;
            }
            System.Buffer.BlockCopy(data, offset, m_OnePack, m_OnePackIndex, len);
            m_OnePackIndex += len;
        }

        void Pack(byte[] data, ushort len)
        {
            System.Buffer.BlockCopy(data, 0, m_OnePack, m_OnePackIndex, len);
            m_OnePackIndex += len;
        }

        public byte[] GetByte()
        {
            return m_OnePack;
        }

        public int GetByteLen()
        {
            return m_OnePackIndex;
        }
    }
}

using UnityEngine;
/*
 * 通信协议
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    class MsgUnPack : PackBase
    {
        ushort m_PackLen;
        int m_MsgID;
        public MsgUnPack()
        {
        }

        void GetHead()
        {
            m_PackLen = System.BitConverter.ToUInt16(m_OnePack, 0);
            m_MsgID = System.BitConverter.ToInt32(m_OnePack, 2);
            m_OnePackIndex = 6;
        }

        public MsgUnPack(byte[] mBuff, ushort len)
        {
            UnPack(mBuff, len);
        }

        public MsgUnPack(byte[] mBuff, int offset, ushort len)
        {
            UnPack(mBuff, offset, len);
        }

        public void UnPack(byte[] mBuff, ushort len)
        {
            System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 0, len);
            GetHead();
        }

        public void UnPack(byte[] mBuff, int offset, ushort len)
        {
            System.Buffer.BlockCopy(mBuff, offset, m_OnePack, 0, len);
            GetHead();
        }

        public bool Readbool()
        {
            if (m_OnePackIndex + 1 > m_PackLen)
            {
                MonoBehaviour.print("Readbool() longer lager than Max buff len");
                return false;
            }
            bool data = System.BitConverter.ToBoolean(m_OnePack, m_OnePackIndex);
            ++m_OnePackIndex;
            return data;
        }

        public short ReadShort()
        {
            if (m_OnePackIndex + 2 > m_PackLen)
            {
                MonoBehaviour.print("ReadShort() longer lager than Max buff len");
                return 0;
            }
            short data = System.BitConverter.ToInt16(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 2;
            return data;
        }

        public ushort ReadUShort()
        {
            if (m_OnePackIndex + 2 > m_PackLen)
            {
                MonoBehaviour.print("ReadUShortbit() longer lager than Max buff len");
                return 0;
            }
            ushort data = System.BitConverter.ToUInt16(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 2;
            return data;
        }

        public int ReadInt()
        {
            if (m_OnePackIndex + 4 > m_PackLen)
            {
                MonoBehaviour.print("ReadInt() longer lager than Max buff len");
                return 0;
            }
            int data = System.BitConverter.ToInt32(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 4;
            return data;
        }

        public uint ReadUInt()
        {
            if (m_OnePackIndex + 4 > m_PackLen)
            {
                MonoBehaviour.print("ReadUInt() longer lager than Max buff len");
                return 0;
            }
            uint data = System.BitConverter.ToUInt32(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 4;
            return data;
        }

        public float ReadFloat()
        {
            if (m_OnePackIndex + 4 > m_PackLen)
            {
                MonoBehaviour.print("ReadFloat() longer lager than Max buff len");
                return 0.0f;
            }
            float data = System.BitConverter.ToSingle(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 4;
            return data;
        }

        public double ReadDouble()
        {
            if (m_OnePackIndex + 8 > m_PackLen)
            {
                MonoBehaviour.print("ReadDouble() longer lager than Max buff len");
                return 0.0f;
            }
            double data = System.BitConverter.ToDouble(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 8;
            return data;
        }

        public long ReadLong()
        {
            if (m_OnePackIndex + 8 > m_PackLen)
            {
                MonoBehaviour.print("ReadLong() longer lager than Max buff len");
                return 0;
            }
            long data = System.BitConverter.ToInt64(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 8;
            return data;
        }

        public ulong ReadULong()
        {
            if (m_OnePackIndex + 8 > m_PackLen)
            {
                MonoBehaviour.print("ReadULong() longer lager than Max buff len");
                return 0;
            }
            ulong data = System.BitConverter.ToUInt64(m_OnePack, m_OnePackIndex);
            m_OnePackIndex += 8;
            return data;
        }

        public string ReadString(ushort len)
        {
            if (m_OnePackIndex + len > m_PackLen)
            {
                MonoBehaviour.print("ReadString() longer lager than Max buff len");
                return "";
            }
            string data = System.Text.Encoding.UTF8.GetString(m_OnePack, m_OnePackIndex, len);
            m_OnePackIndex += len;
            return data;
        }

        public byte[] ReadByte(ushort len)
        {
            byte[] mCur = null;
            if (m_OnePackIndex + len > m_PackLen)
            {
                MonoBehaviour.print("ReadByte() longer lager than Max buff len");
                return mCur;
            }
            mCur = new byte[len];
            System.Buffer.BlockCopy(m_OnePack, m_OnePackIndex, mCur, 0, len);
            m_OnePackIndex += len;
            return mCur;
        }

        public int GetMsgID()
        {
            return m_MsgID;
        }
    }
}

using System.Threading;

/*
 *轻量级局域网服务器。 
 * 协议如下
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    public class PackBase
    {
        protected int m_MaxOnePackBuff;
        protected byte[] m_OnePack;
        protected int m_OnePackIndex;

        public PackBase()
        {
            m_MaxOnePackBuff = LanSocketBase.m_MaxOnePackBuff;
            m_OnePack = new byte[m_MaxOnePackBuff];
            m_OnePackIndex = 0;
        }
    }
}

using System.Net.Sockets;
using System.Threading;
using System.Net;

public class SocketBase
{
    protected bool m_HasInit = false;
    protected Socket m_Socket;
    protected Thread m_LinstenThread;
    protected IPEndPoint m_IP;
    protected Mutex m_Mutex;
}

using UnityEngine;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.Collections.Generic;

class ReciveBroadcast : SocketBase
{
    public Queue<string> m_ServerIP;
    public void Start(int port)
    {
        if (m_HasInit)
        {
            return;
        }
        try
        {
            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            m_IP = new IPEndPoint(IPAddress.Any, port);
            m_Socket.Bind(m_IP);
            MonoBehaviour.print("广播网络启动监听" + m_Socket.LocalEndPoint.ToString());
            m_LinstenThread = new Thread(ListenClientConnect);
            m_LinstenThread.Start();
            m_ServerIP = new Queue<string>();
            m_Mutex = new Mutex();
            m_HasInit = true;
        }
        catch (System.Exception ex)
        {
            MonoBehaviour.print("Broadcast reciver Start catch:" + ex.Message);
        }
    }

    void ListenClientConnect()
    {
        EndPoint ep = (EndPoint)m_IP;
        try
        {
            while (true)
            {
                Thread.Sleep(1);
                byte[] data = new byte[64];
                int recv = m_Socket.ReceiveFrom(data, ref ep);
                string stringData = System.Text.Encoding.UTF8.GetString(data, 0, recv);
                m_Mutex.WaitOne();
                m_ServerIP.Enqueue(stringData);
                m_Mutex.ReleaseMutex();
                MonoBehaviour.print("received: " + stringData + " from: " + ep.ToString());
            }
        }
        catch (System.Exception ex)
        {
            MonoBehaviour.print("Broadcast reciver ListenClientConnect out:" + ex.Message);
        }
    }

    public void Destroy()
    {
        if (!m_HasInit)
        {
            return;
        }
        m_Socket.Close();
        m_LinstenThread.Abort();
    }

    public string GetIP()
    {
        if (!m_HasInit)
        {
            return "";
        }

        try
        {
            m_Mutex.WaitOne();
            if (0 != m_ServerIP.Count)
            {
                m_Mutex.ReleaseMutex();
                return m_ServerIP.Dequeue();
            }
            m_Mutex.ReleaseMutex();
        }
        catch (System.Exception ex)
        {
            MonoBehaviour.print("Broadcast GetIP catch:" + ex.Message);
            return "";
        }
        return "";
    }
}

using UnityEngine;
using System.Net.Sockets;
using System.Net;

class SendBroadcast : SocketBase
{
    byte[] m_MyIP;
    public void Start(int port)
    {
        if (m_HasInit)
        {
            return;
        }
        try
        {
            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            m_IP = new IPEndPoint(IPAddress.Broadcast, port);//255.255.255.255
            //m_IP = new IPEndPoint(IPAddress.Parse("192.168.255.255"), 9050);

            string mLocalIP = "";
            string hostname = Dns.GetHostName();
            IPHostEntry localHost = Dns.GetHostEntry(hostname);
            for (int i = 0; i < localHost.AddressList.Length; ++i)
            {
                if (localHost.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    //MonoBehaviour.print(localHost.AddressList[i].ToString());
                    mLocalIP = localHost.AddressList[i].ToString();
                    break;
                }
            }

            if ("".Equals(m_MyIP))
            {
                MonoBehaviour.print("网络检测异常。请检查网络设置或接入网络");
                m_Socket.Close();
                m_Socket = null;
                return;
            }
            m_MyIP = System.Text.Encoding.UTF8.GetBytes(mLocalIP);
            m_Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
            m_HasInit = true;
        }
        catch (System.Exception ex)
        {
            MonoBehaviour.print("Broadcast sender Start catch:" + ex.Message);
        }
    }

    public void Send()
    {
        if(null != m_Socket)
        {
            MonoBehaviour.print("send a broadcast");
            m_Socket.SendTo(m_MyIP, m_IP);
        }
    }

    public void Destroy()
    {
        if (!m_HasInit)
        {
            return;
        }
        m_Socket.Close();
    }
}

using System.Net.Sockets;
using System.Net;
using System.Threading;
using UnityEngine;
using System.Collections.Generic;

/*
 *轻量级局域网服务器。 
 * 协议如下
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    class Client : LanSocketBase
    {
        Thread m_ReciveThread;
        Socket m_Connect;
        byte[] m_AllData;
        int m_AllDataHead;
        int m_AllDataEnd;
        int m_MsgNum;
        byte[] m_OnePack;
        int m_OnePackIndex;

        public void Start(string strIP, int port)
        {
            if (m_HasInit)
            {
                return;
            }
            //设定服务器IP地址  
            IPAddress ip = IPAddress.Parse(strIP);
            Socket temp = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                temp.Connect(new IPEndPoint(ip, port)); //配置服务器IP与端口  
                MonoBehaviour.print("连接服务器成功");

                BaseInit();
                m_Connect = temp;
                m_ReciveThread = new Thread(ReceiveMessage);
                m_ReciveThread.Start();
                m_AllData = new byte[LanSocketBase.m_MaxAllBuff + 1];
                m_AllDataHead = 0;
                m_AllDataEnd = 0;
                m_MsgNum = 0;
                m_OnePack = new byte[m_MaxOnePackBuff + 1];
                m_OnePackIndex = 0;
            }
            catch (System.Exception ex)
            {
                MonoBehaviour.print("连接服务器失败: " + ex.Message);
                return;
            }
        }

        private void PutDataToBuff(byte[] mClientSendBuff, int mReceiveNumber)
        {
            if (m_AllDataEnd + mReceiveNumber >= LanSocketBase.m_MaxAllBuff)
            {
                byte[] mCurAllData = new byte[m_AllDataEnd - m_AllDataHead];
                System.Buffer.BlockCopy(m_AllData, m_AllDataHead, mCurAllData, 0, m_AllDataEnd - m_AllDataHead);
                System.Buffer.BlockCopy(mCurAllData, 0, m_AllData, 0, m_AllDataEnd - m_AllDataHead);
                m_AllDataEnd -= m_AllDataHead;
                m_AllDataHead = 0;
            }
            int mOnePackStartPos = 0;
            while (mReceiveNumber > 0)
            {
                if (0 == m_OnePackIndex)
                {
                    ushort datalen = System.BitConverter.ToUInt16(mClientSendBuff, mOnePackStartPos);
                    if (datalen <= mReceiveNumber)
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_AllData, m_AllDataEnd, datalen);
                        m_AllDataEnd += datalen;

                        mOnePackStartPos += datalen;

                        mReceiveNumber -= datalen;
                        ++m_MsgNum;
                    }
                    else
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
                        m_OnePackIndex += mReceiveNumber;
                        mOnePackStartPos += mReceiveNumber;

                        mReceiveNumber -= mReceiveNumber;
                    }
                }
                else
                {
                    if (m_OnePackIndex < 2)
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, 1);

                        ++m_OnePackIndex;
                        --mReceiveNumber;
                        ++mOnePackStartPos;
                    }
                    ushort datalen = System.BitConverter.ToUInt16(m_OnePack, 0);
                    if (m_OnePackIndex + mReceiveNumber >= datalen)
                    {
                        int mNeedNum = datalen - m_OnePackIndex;
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mNeedNum);
                        mOnePackStartPos += mNeedNum;
                        
                        System.Buffer.BlockCopy(m_OnePack, 0, m_AllData, m_AllDataEnd, datalen);
                        m_OnePackIndex = 0;
                        m_AllDataEnd += datalen;

                        mReceiveNumber -= mNeedNum;
                    }
                    else
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
                        m_OnePackIndex += mReceiveNumber;
                        mOnePackStartPos += mReceiveNumber;

                        mReceiveNumber -= mReceiveNumber;
                    }
                }
            }
        }

        public void Destroy()
        {
            if (!m_HasInit)
            {
                return;
            }
            BaseRelease();
            ShutDownConnect();
            m_MsgNum = 0;
        }

        public void GetMsg(ref MsgUnPack msg)
        {
            if (!m_HasInit)
            {
                return;
            }
            try
            {
                Lock();
                if (0 != m_MsgNum)
                {
                    ushort datalen = System.BitConverter.ToUInt16(m_AllData, m_AllDataHead);
                    msg = new MsgUnPack(m_AllData, (ushort)m_AllDataHead, (ushort)datalen);
                    m_AllDataHead += datalen;
                    --m_MsgNum;
                }
            }
            finally
            {
                UnLock();
            }
        }

        /// <summary>  
        /// 接收消息  
        /// </summary>  
        public void ReceiveMessage()
        {
            while (true)
            {
                Thread.Sleep(1);
                try
                {
                    //通过clientSocket接收数据  
                    byte[] mClientSendBuff = new byte[m_MaxOnePackBuff + 1];
                    int mReceiveNumber = m_Connect.Receive(mClientSendBuff);
                    if (0 == mReceiveNumber)
                    {
                        MonoBehaviour.print("disconnect");
                        ShutDownConnect();
                    }
                    else if (mReceiveNumber > 0)
                    {
                        try
                        {
                            Lock();
                            PutDataToBuff(mClientSendBuff, mReceiveNumber);
                        }
                        catch (System.Exception ex)
                        {
                            MonoBehaviour.print("PutDataToBuff catch: " + ex.Message);
                        }
                        finally
                        {
                            UnLock();
                        }
                    }
                    else
                    {
                        MonoBehaviour.print("one connect recive a error num: " + mReceiveNumber.ToString());
                    }
                }
                catch (System.Exception ex)
                {
                    MonoBehaviour.print("ReceiveMessage catch: " + ex.Message);
                    ShutDownConnect();
                }
            }
        }

        public void Send(ref MsgPack msg)
        {
            try
            {
                Lock();
                m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
            }
            finally
            {
                UnLock();
            }
        }

        public void ShutDownConnect()
        {
            m_ReciveThread.Abort();
            if (m_Connect.Connected)
            {
                m_Connect.Shutdown(SocketShutdown.Both);
            }
            m_Connect.Close();
        }
    }
}

using System.Net.Sockets;
using System.Net;
using System.Threading;
using UnityEngine;
using System.Collections.Generic;
/*
 *轻量级局域网服务器。 
 * 协议如下
 * 消息头前2字节保存当前消息长度
 * 后面跟4字节表示消息ID
 * 再后面是消息实质内容
 */

namespace LanSocket
{
    class ClientConnect
    {
        public byte[] m_AllData;
        public int m_AllDataHead;
        public int m_AllDataEnd;
        public int m_MsgCount;
        public byte[] m_OnePack;
        public int m_OnePackIndex;
        public Socket m_Connect;
        public long m_UserID;

        public ClientConnect()
        {
            m_AllData = new byte[LanSocketBase.m_MaxAllBuff];
            m_AllDataHead = 0;
            m_AllDataEnd = 0;
            m_MsgCount = 0;
            m_OnePack = new byte[LanSocketBase.m_MaxOnePackBuff];
            m_OnePackIndex = 0;
            m_Connect = null;
            m_UserID = 0;
        }

        public void Reset()
        {
            m_AllDataHead = 0;
            m_AllDataEnd = 0;
            m_MsgCount = 0;
            m_OnePackIndex = 0;
            m_Connect = null;
            m_UserID = 0;
        }
    }
    class Server : LanSocketBase
    {
        Queue<int> m_MsgOrder;

        Socket m_ServerSocket;
        Thread m_LinstenThread;
        Thread m_ReciveThread;
        System.Collections.ArrayList m_ServerSocketList;
        System.Collections.ArrayList m_listenSocketList;
        System.Collections.ArrayList m_DeleteSocketList;
        int m_MaxClientConnect = 10;
        ClientConnect[] m_ConnectPool;
        Queue<int> m_EmptyConnect;
        public void Start(int port)
        {
            if (m_HasInit)
            {
                return;
            }
            string mLocalIP = "";

            string mHostName = Dns.GetHostName();
            IPHostEntry localHost = Dns.GetHostEntry(mHostName);
            for (int i = 0; i < localHost.AddressList.Length; ++i)
            {
                if (localHost.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    //MonoBehaviour.print(localHost.AddressList[i].ToString());
                    mLocalIP = localHost.AddressList[i].ToString();
                    break;
                }
            }

            if ("".Equals(mLocalIP))
            {
                MonoBehaviour.print("网络检测异常。请检查网络设置或接入网络");
                return;
            }
            BaseInit();
            m_MsgOrder = new Queue<int>();

            //服务器IP地址  
            IPAddress ip = IPAddress.Parse(mLocalIP);
            m_ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_ServerSocket.Bind(new IPEndPoint(ip, port));  //绑定IP地址：端口  
            m_ServerSocket.Listen(10);    //设定最多10个排队连接请求  
            MonoBehaviour.print("游戏网络启动监听" + m_ServerSocket.LocalEndPoint.ToString());

            m_ServerSocketList = new System.Collections.ArrayList();
            m_listenSocketList = new System.Collections.ArrayList();
            m_DeleteSocketList = new System.Collections.ArrayList();

            m_ConnectPool = new ClientConnect[m_MaxClientConnect];
            m_EmptyConnect = new Queue<int>();
            for (int i = 0; i < m_MaxClientConnect; ++i)
            {
                m_ConnectPool[i] = new ClientConnect();
                m_EmptyConnect.Enqueue(i);
            }
            //通过Clientsoket发送数据  
            m_ReciveThread = new Thread(ReceiveMessage);
            m_ReciveThread.Start();
            m_LinstenThread = new Thread(ListenClientConnect);
            m_LinstenThread.Start();
        }

        /// <summary>  
        /// 监听客户端连接  
        /// </summary>  
        public void ListenClientConnect()
        {
            while (true)
            {
                Thread.Sleep(500);
                m_ServerSocketList.Add(m_ServerSocket);
                Socket.Select(m_ServerSocketList, null, null, 1000);
                for (int i = 0; i < m_ServerSocketList.Count; ++i)
                {
                    Socket clientSocket = ((Socket)m_ServerSocketList[i]).Accept();
                    if (null != clientSocket)
                    {
                        try
                        {
                            Lock();
                            if (0 == m_EmptyConnect.Count)
                            {
                                MonoBehaviour.print("链接已经达到最大上线，丢弃当前连接");
                                clientSocket.Shutdown(SocketShutdown.Both);
                                clientSocket.Close();
                            }
                            else
                            {
                                //m_listenSocketList.Add(clientSocket);
                                int mSlot = m_EmptyConnect.Dequeue();
                                m_ConnectPool[mSlot].m_Connect = clientSocket;
                                m_ConnectPool[mSlot].m_UserID = System.DateTime.Now.ToFileTime();
                                MonoBehaviour.print("成功连接一个客户端，编号:" + mSlot.ToString());
                            }
                        }
                        finally
                        {
                            UnLock();
                        }
                    }
                }
                m_ServerSocketList.Clear();
            }
        }

        private bool PutDataToBuff(byte[] mClientSendBuff, int mReceiveNumber, Socket client)
        {
            ClientConnect curPlayer = null;
            int mSlot = -1;
            for (int i = 0; i < m_MaxClientConnect; ++i)
            {
                if (client == m_ConnectPool[i].m_Connect)
                {
                    curPlayer = m_ConnectPool[i];
                    mSlot = i;
                    break;
                }
            }
            if (null == curPlayer)
            {
                return false;
            }
            if (curPlayer.m_AllDataEnd + mReceiveNumber >= LanSocketBase.m_MaxAllBuff)
            {
                byte[] mCurAllData = new byte[curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead];
                System.Buffer.BlockCopy(curPlayer.m_AllData, curPlayer.m_AllDataHead, mCurAllData, 0, curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead);
                System.Buffer.BlockCopy(mCurAllData, 0, curPlayer.m_AllData, 0, curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead);
                curPlayer.m_AllDataEnd -= curPlayer.m_AllDataHead;
                curPlayer.m_AllDataHead = 0;

                if(curPlayer.m_AllDataEnd + mReceiveNumber >= LanSocketBase.m_MaxAllBuff)
                {
                    return false;
                }
            }
            int mOnePackStartPos = 0;
            while (mReceiveNumber > 0)
            {
                if (0 == curPlayer.m_OnePackIndex)
                {
                    ushort datalen = System.BitConverter.ToUInt16(mClientSendBuff, mOnePackStartPos);
                    if (datalen > LanSocketBase.m_MaxOnePackBuff || datalen < LanSocketBase.m_HeadSize)
                    {
                        return false;
                    }
                    if (datalen <= mReceiveNumber)
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_AllData, curPlayer.m_AllDataEnd, datalen);
                        curPlayer.m_AllDataEnd += datalen;
                        mOnePackStartPos += datalen;

                        mReceiveNumber -= datalen;

                        m_MsgOrder.Enqueue(mSlot);
                    }
                    else
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_OnePack, curPlayer.m_OnePackIndex, mReceiveNumber);
                        curPlayer.m_OnePackIndex += mReceiveNumber;
                        mOnePackStartPos += mReceiveNumber;

                        mReceiveNumber -= mReceiveNumber;
                    }
                }
                else
                {
                    if(curPlayer.m_OnePackIndex < 2)
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_OnePack, curPlayer.m_OnePackIndex, 1);

                        ++curPlayer.m_OnePackIndex;
                        --mReceiveNumber;
                        ++mOnePackStartPos;
                    }
                    ushort datalen = System.BitConverter.ToUInt16(curPlayer.m_OnePack, 0);
                    if (datalen > LanSocketBase.m_MaxOnePackBuff || datalen < LanSocketBase.m_HeadSize)
                    {
                        return false;
                    }
                    if (curPlayer.m_OnePackIndex + mReceiveNumber >= datalen)
                    {
                        int mNeedNum = datalen - curPlayer.m_OnePackIndex;
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_OnePack, curPlayer.m_OnePackIndex, mNeedNum);
                        mOnePackStartPos += mNeedNum;

                        System.Buffer.BlockCopy(curPlayer.m_OnePack, 0, curPlayer.m_AllData, curPlayer.m_AllDataEnd, datalen);
                        curPlayer.m_OnePackIndex = 0;
                        curPlayer.m_AllDataEnd += datalen;

                        mReceiveNumber -= mNeedNum;

                        m_MsgOrder.Enqueue(mSlot);
                    }
                    else
                    {
                        System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_OnePack, curPlayer.m_OnePackIndex, mReceiveNumber);
                        curPlayer.m_OnePackIndex += mReceiveNumber;
                        mOnePackStartPos += mReceiveNumber;

                        mReceiveNumber -= mReceiveNumber;
                    }
                }
            }

            return true;
        }

        /// <summary>  
        /// 接收消息  
        /// </summary>  
        public void ReceiveMessage()
        {
            try
            {
                while (true)
                {
                    Thread.Sleep(1);
                    for (int i = 0; i < m_MaxClientConnect; ++i)
                    {
                        if (null != m_ConnectPool[i].m_Connect)
                        {
                            m_listenSocketList.Add(m_ConnectPool[i].m_Connect);
                        }
                    }
                    if (0 == m_listenSocketList.Count)
                    {
                        continue;
                    }
                    Socket.Select(m_listenSocketList, null, null, 1000);
                    for (int i = 0; i < m_listenSocketList.Count; ++i)
                    {
                        Socket mClient = (Socket)m_listenSocketList[i];
                        //try
                        //{
                        //通过clientSocket接收数据  
                        byte[] mClientSendBuff = new byte[m_MaxOnePackBuff];
                        int mReceiveNumber = mClient.Receive(mClientSendBuff);
                        if (0 == mReceiveNumber)
                        {
                            m_DeleteSocketList.Add(mClient);
                        }
                        else if (mReceiveNumber > 0)
                        {
                            try
                            {
                                Lock();
                                bool rt = PutDataToBuff(mClientSendBuff, mReceiveNumber, mClient);
                                if (!rt)
                                {
                                    m_DeleteSocketList.Add(mClient);
                                }
                            }
                            catch (System.Exception ex)
                            {
                                MonoBehaviour.print("PutDataToBuff catch: " + ex.Message);
                            }
                            finally
                            {
                                UnLock();
                            }
                        }
                        else
                        {
                            MonoBehaviour.print("one connect recive a error num: " + mReceiveNumber.ToString());
                        }
                        //}
                        //catch (System.Exception ex)
                        //{
                        //    MonoBehaviour.print("ReceiveMessage catch: " + ex.Message);
                        //    m_DeleteSocketList.Add(mClient);
                        //}
                    }
                    m_listenSocketList.Clear();
                    if (0 != m_DeleteSocketList.Count)
                    {
                        ShutDownConnect();
                    }
                }

            }
            catch (System.Exception ex)
            {
                MonoBehaviour.print("ReceiveMessage out:" + ex.Message);
            }

        }

        /// <summary>  
        /// 程序退出销毁  
        /// </summary>  
        public void Destroy()
        {
            if (!m_HasInit)
            {
                return;
            }
            m_LinstenThread.Abort();
            m_ReciveThread.Abort();
            m_listenSocketList.Clear();

            for (int i = 0; i < m_ServerSocketList.Count; ++i)
            {
                Socket mServer = (Socket)m_ServerSocketList[i];
                if (mServer.Connected)
                {
                    mServer.Shutdown(SocketShutdown.Both);
                }
                mServer.Close();
            }
            m_ServerSocketList.Clear();

            for (int i = 0; i < m_MaxClientConnect; ++i)
            {
                if (null != m_ConnectPool[i].m_Connect)
                {
                    if (m_ConnectPool[i].m_Connect.Connected)
                    {
                        m_ConnectPool[i].m_Connect.Shutdown(SocketShutdown.Both);
                    }
                    m_ConnectPool[i].m_Connect.Close();
                    m_ConnectPool[i].m_Connect = null;
                }
            }
            m_EmptyConnect.Clear();
            BaseRelease();
        }

        /// <summary>  
        /// 销毁一个连接  
        /// </summary>  
        void ShutDownConnect()
        {
            try
            {
                Lock();
                for (int j = 0; j < m_DeleteSocketList.Count; ++j)
                {
                    Socket connect = (Socket)m_DeleteSocketList[j];
                    for (int i = 0; i < m_MaxClientConnect; ++i)
                    {
                        if (connect == m_ConnectPool[i].m_Connect)
                        {
                            connect.Shutdown(SocketShutdown.Both);
                            connect.Close();
                            m_ConnectPool[i].Reset();
                            m_EmptyConnect.Enqueue(i);
                            MonoBehaviour.print("关闭一个连接，编号:" + i.ToString());
                            break;
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                MonoBehaviour.print("ShutDownConnect catch: " + ex.Message);
            }
            finally
            {
                m_DeleteSocketList.Clear();
                UnLock();
            }
        }

        /// <summary>  
        /// 获取一个数据  
        /// </summary>  
        public void GetMsg(ref ClientMsgUnPack msg)
        {
            if(!m_HasInit)
            {
                return;
            }
            try
            {
                Lock();
                if (0 != m_MsgOrder.Count)
                {
                    int mSlot = m_MsgOrder.Dequeue();
                    ClientConnect curPlayer = m_ConnectPool[mSlot];
                    ushort mOnePackLen = System.BitConverter.ToUInt16(curPlayer.m_AllData, curPlayer.m_AllDataHead);
                    msg = new ClientMsgUnPack(curPlayer.m_AllData, curPlayer.m_AllDataHead, (ushort)mOnePackLen, curPlayer.m_UserID);
                    curPlayer.m_AllDataHead += mOnePackLen;
                }
            }
            finally
            {
                UnLock();
            }
        }

        public void SendTo(ref MsgPack msg, long userID)
        {
            try
            {
                Lock();
                for(int i = 0 ; i < m_MaxClientConnect ; ++i)
                {
                    ClientConnect curPlayer = m_ConnectPool[i];
                    if (null != curPlayer.m_Connect && curPlayer.m_UserID == userID)
                    {
                        curPlayer.m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
                        break;
                    }
                }
            }
            finally
            {
                UnLock();
            }
        }

        public void SendToAll(ref MsgPack msg)
        {
            try
            {
                Lock();
                for (int i = 0; i < m_MaxClientConnect; ++i)
                {
                    ClientConnect curPlayer = m_ConnectPool[i];
                    if (null != curPlayer.m_Connect)
                    {
                        curPlayer.m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
                        break;
                    }
                }
            }
            finally
            {
                UnLock();
            }
        }
    }
}

using UnityEngine;
using System.Collections;

public class ClientMain : MonoBehaviour {

    // Use this for initialization
    ClientEventDispath m_Msg;
    SendBroadcast m_Sender;
    ReciveBroadcast m_Reciver;
    LanSocket.Client m_GameNet;
    string m_GameServerIP;
    bool m_bReady;
    float m_BroadTime;

    void Start () 
    {
        m_Sender = new SendBroadcast();
        m_Sender.Start(6666);
        m_Reciver = new ReciveBroadcast();
        m_Reciver.Start(6688);

        m_GameNet = new LanSocket.Client();

        m_GameServerIP = "";

        m_bReady = false;
        m_BroadTime = 0.0f;

        EventDispathBase.g_MaxEventNum = (int)NetMsgID.NET_MSG_END;
        m_Msg = new ClientEventDispath();
        m_Msg.RegistEvent((int)NetMsgID.S2C_SEND_ANIMAL_DATA, Action_S2C_SEND_ANIMAL_DATA);
    }
    
    void OnGUI()
    {
        if (GUILayout.Button("Record"))
        {
            MicroPhoneInput.getInstance().StartRecord();
        }
        if (GUILayout.Button("End"))
        {
            MicroPhoneInput.getInstance().StopRecord();
        }
        if (GUILayout.Button("send"))
        {
            byte[] data = MicroPhoneInput.getInstance().GetClipData();

            LanSocket.MsgPack audioBegin = new LanSocket.MsgPack();
            audioBegin.SetHead((int)NetMsgID.C2S_ASK_SEND_AUDIO_BEGIN);
            audioBegin.PackEnd();
            m_GameNet.Send(ref audioBegin);

            print("audio length = " + data.Length);
            int lastData = data.Length;
            int offset = 0;
            while (true)
            {
                ushort sendNum = (ushort)lastData;
                if (lastData > 3000)
                {
                    sendNum = 3000;
                }
                LanSocket.MsgPack audioData = new LanSocket.MsgPack();
                audioData.SetHead((int)NetMsgID.C2S_ASK_SEND_AUDIO);
                audioData.Pack16bit(sendNum);
                audioData.PackByte(data, offset, sendNum);
                audioData.PackEnd();
                m_GameNet.Send(ref audioData);

//                 string result = string.Empty;
//                 for (int i = 0; i < sendNum; i++)
//                 {
//                     result += System.Convert.ToString(data[offset + i], 16) + " ";
//                 }
//                 print(result);

                offset += sendNum;
                if (offset >= data.Length)
                {
                    break;
                }
                lastData -= sendNum;
            }
            LanSocket.MsgPack audioEnd = new LanSocket.MsgPack();
            audioEnd.SetHead((int)NetMsgID.C2S_ASK_SEND_AUDIO_END);
            audioEnd.PackEnd();
            m_GameNet.Send(ref audioEnd);

//             string result2 = string.Empty;
//             for (int i = 0; i < data.Length; i++)
//             {
//                 result2 += System.Convert.ToString(data[i], 16) + " ";
//             }
//             print(result2);
        }
        if (GUILayout.Button("Play"))
        {
            MicroPhoneInput.getInstance().PlayRecord();
        }
        if (GUILayout.Button("PlayByData"))
        {
            byte[] data = MicroPhoneInput.getInstance().GetClipData();
            short[] decodeData = new short[data.Length / 2];
            for (int i = 0; i < decodeData.Length; ++i)
            {
                decodeData[i] = System.BitConverter.ToInt16(data, i * 2);
            }
            MicroPhoneInput.getInstance().PlayClipData(decodeData);
        }
    }
    
    // Update is called once per frame
    void Update ()
    {
        if (m_bReady)
        {
            LanSocket.MsgUnPack msg = null;
            m_GameNet.GetMsg(ref msg);
            if (null != msg)
            {
                print("here have one msg on client");
            }

            if (Input.GetKeyUp(KeyCode.Space))
            {
                LanSocket.MsgPack sendMsg = new LanSocket.MsgPack();
                sendMsg.SetHead((int)NetMsgID.C2S_SELECT_ANIMAL);
                sendMsg.Pack16bit(1);
                sendMsg.PackEnd();
                m_GameNet.Send(ref sendMsg);
                print("send 1");
            }
        }
        else
        {
            m_GameServerIP = m_Reciver.GetIP();
            if ("".Equals(m_GameServerIP))
            {
                m_BroadTime -= Time.deltaTime;
                if(m_BroadTime - Time.deltaTime < 0.0f)
                {
                    m_BroadTime = 5.0f;
                    m_Sender.Send();
                }
            }
            else
            {
                print("get broadcast ip:" + m_GameServerIP);
                GameStart();
            }
        }
    }
    void OnDestroy()
    {
        m_GameNet.Destroy();
        if(null != m_Reciver)
        {
            m_Reciver.Destroy();
        }
        if (null != m_Sender)
        {
            m_Sender.Destroy();
        }
    }

    void GameStart()
    {
        m_bReady = true;
        m_GameNet.Start(m_GameServerIP, 8888);
        try
        {
            m_Reciver.Destroy();
            m_Sender.Destroy();
        }
        catch (System.Exception ex)
        {
            MonoBehaviour.print("GameStart catch:" + ex.Message);
        }
        m_Reciver = null;
        m_Reciver = null;
    }

    void Action_S2C_SEND_ANIMAL_DATA(LanSocket.MsgUnPack msg)
    {
    }
}

using UnityEngine;
using System.Collections;

enum NetMsgID
{
    NET_MSG_START = 100,
    S2C_SEND_ANIMAL_DATA,
    C2S_SELECT_ANIMAL,
    C2S_ASK_SEND_AUDIO_BEGIN,
    C2S_ASK_SEND_AUDIO,
    C2S_ASK_SEND_AUDIO_END,

    NET_MSG_END,
}

using UnityEngine;
using System.Collections;

public class ServerMain : MonoBehaviour 
{
    bool m_Destroy;
    ServerEventDispath m_ClientMsg;
    ReciveBroadcast m_Reciver;
    SendBroadcast m_Sender;
    LanSocket.Server m_GameNet;
    byte[] m_AudioData;
    int m_AudioOffset;
    int m_AudioLen;
    void Start () 
    {
        m_Destroy = false;
        //广播
        m_Reciver = new ReciveBroadcast();
        m_Reciver.Start(6666);
        m_Sender = new SendBroadcast();
        m_Sender.Start(6688);

        //游戏网络
        m_GameNet = new LanSocket.Server();
        m_GameNet.Start(8888);

        m_AudioData = new byte[44100000];
        m_AudioOffset = 0;
        m_AudioLen = 0;

        m_ClientMsg = new ServerEventDispath();
        m_ClientMsg.RegistEvent((int)NetMsgID.C2S_ASK_SEND_AUDIO_BEGIN, Action_C2S_ASK_SEND_AUDIO_BEGIN);
        m_ClientMsg.RegistEvent((int)NetMsgID.C2S_ASK_SEND_AUDIO, Action_C2S_ASK_SEND_AUDIO);
        m_ClientMsg.RegistEvent((int)NetMsgID.C2S_ASK_SEND_AUDIO_END, Action_C2S_ASK_SEND_AUDIO_END);
    }
    
    // Update is called once per frame
    void Update () 
    {
        if(!m_Destroy)
        {
            LanSocket.ClientMsgUnPack clientMsg = null;
            m_GameNet.GetMsg(ref clientMsg);
            if (null != clientMsg)
            {
                //print("Msg:" + clientMsg.GetMsgID() + " from: " + clientMsg.GetUserID());

                EventNode mNode = new EventNode();
                mNode.m_EventID = clientMsg.GetMsgID();
                mNode.msg = clientMsg;

                MonoBehaviour.print("Update EventID " + mNode.m_EventID + " ID: " + clientMsg.GetMsgID());
                m_ClientMsg.AddEvent(mNode);
            }

            if(!"".Equals(m_Reciver.GetIP()))
            {
                m_Sender.Send();
            }

            m_ClientMsg.Proccess();
        }
    }

    void OnDestroy()
    {
        m_Destroy = true;
        m_GameNet.Destroy();
        m_Reciver.Destroy();
        m_Sender.Destroy();
    }

    void Action_123(LanSocket.ClientMsgUnPack msg)
    {
        long userID = msg.GetUserID();
        ushort accountLen = msg.ReadUShort();
        string account = msg.ReadString(accountLen);
        ushort passLen = msg.ReadUShort();
        string pass = msg.ReadString(passLen);

        print("Action_123 account: " + account + " pass word: " + pass+" from user: " + userID);

        LanSocket.MsgPack sendMsg = new LanSocket.MsgPack();
        sendMsg.SetHead(123);
        string strAccount = "test account";
        sendMsg.Pack16bit((ushort)strAccount.Length);
        sendMsg.PackString(strAccount, (ushort)strAccount.Length);
        string strPass = "test pass word";
        sendMsg.Pack16bit((ushort)strPass.Length);
        sendMsg.PackString(strPass, (ushort)strPass.Length);
        sendMsg.PackEnd();
        m_GameNet.SendTo(ref sendMsg, msg.GetUserID());
    }

    void Action_C2S_ASK_SEND_AUDIO_BEGIN(LanSocket.ClientMsgUnPack msg)
    {
        m_AudioOffset = 0;
        m_AudioLen = 0;
    }

    void Action_C2S_ASK_SEND_AUDIO(LanSocket.ClientMsgUnPack msg)
    {
        long userID = msg.GetUserID();
        ushort dataLen = msg.ReadUShort();
        byte[] audioData = msg.ReadByte(dataLen);

//         string result = string.Empty;
//         for (int i = 0; i < dataLen; i++)
//         {
//             result += System.Convert.ToString(audioData[i], 16) + " ";
//         }
//         print(result);

        System.Buffer.BlockCopy(audioData, 0, m_AudioData, m_AudioOffset, (int)dataLen);
        m_AudioOffset += dataLen;
    }

    void Action_C2S_ASK_SEND_AUDIO_END(LanSocket.ClientMsgUnPack msg)
    {
        print("audio length: " + m_AudioOffset);
        short[] decodeData = new short[m_AudioOffset / 2];
        for (int i = 0; i < decodeData.Length; ++i)
        {
            decodeData[i] = System.BitConverter.ToInt16(m_AudioData, i * 2);
        }
        MicroPhoneInput.getInstance().PlayClipData(decodeData);

//         string result = string.Empty;
//         for (int i = 0; i < m_AudioOffset; i++)
//         {
//             result += System.Convert.ToString(m_AudioData[i], 16) + " ";
//         }
//         print(result);
    }
}

以上为修改过的全部代码。