llyyc的个人博客

使用CSharp封装类简单实现TCP/UDP

Fri, 27 Jul 2018 01:00:23 +0800

C#已经为我们封装了简单易用的Socket,在这基础上更封装了TcpListener,TcpClient,UdpClient这三个类。这里就是用四个类来实现最简单的TCP和UDP。

1.Socket TCP

(1)服务端

class Program
    {
       /*
    1：建立一个Socket对像；

    2：用socket对像的Bind()方法绑定EndPoint；

    3：用socket对像的Listen()方法开始监听；

    4：接受到客户端的连接，用socket对像的Accept()方法创建新的socket对像用于和请求的客户端进行通信;

    5：用新的socket对象接收（Receive）和发送（Send）消息。
     */
        static void Main(string[] args)
        {
            //1.                              寻址方案               套接字类型           协议类型

            Socket tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //2.
           
            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
            EndPoint endpoint = new IPEndPoint(ipaddress, 8888);     //向操作系统申请一份可用的ip和端口号
            tcpServer.Bind(endpoint);


            //3.

            tcpServer.Listen(100);              //能同时接收100个客户端的请求
            Console.WriteLine("服务器启动完成");
            Socket clientSocket = tcpServer.Accept();  //暂停当前线程，直到一个客户端连接过来，返回Socket对象 
            Console.WriteLine("接收到客户端的连接请求");

            //4.

            string message = "Hello Client";
            var data = Encoding.UTF8.GetBytes(message);   //将字符串转成字节数组
            clientSocket.Send(data);
            Console.WriteLine("我向客户端发送了一条消息：" + message);

            byte[] data2 = new byte[1024];            //存放数组的容器
            int length = clientSocket.Receive(data2);
            string message2 = Encoding.UTF8.GetString(data2, 0, length);
            Console.WriteLine("我接收到客户端发来的消息:" + message2);
            Console.ReadKey();
        }
    }

(2)客户端

/*
1：建立一个Socket对像；

2：用socket对像的Connect()方法以上面建立的EndPoint对像做为参数，向服务器发出连接请求；

3：如果连接成功，就用socket对像的Send()方法向服务器发送信息；

4：用socket对像的Receive()方法接受服务器发来的信息 ;

5：通信结束后一定记得关闭socket；
*/
   class Program
   {  
       
      
      static void Main(string[] args)
      {
            Socket tcpClient;
            string serverIP = "127.0.0.1";
            int serverPort = 8888;
          //1.
            try {
                  tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);// 寻址方案               套接字类型           协议类型
 

                  //2.

                  IPAddress ipaddress = IPAddress.Parse(serverIP);
                  EndPoint endpoint = new IPEndPoint(ipaddress, serverPort);
                  tcpClient.Connect(endpoint);//发送连接请求
                  Console.WriteLine("请求服务器连接");

                  //3.

                  byte[] data = new byte[1024];
                  int length = tcpClient.Receive(data);
                  var message = Encoding.UTF8.GetString(data, 0, length);
                  Console.WriteLine("我接收到服务器发来的消息：" + message);

                  //4.

                  string message2 = "这是我向服务器发送的消息";
                  tcpClient.Send(Encoding.UTF8.GetBytes(message2));
                  Console.WriteLine("我向服务器发送消息：" + message2);
                  Console.ReadKey();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.ReadKey();
            }
      }
    }

2.Socket UDP

(1)服务端(接收端)

  class Program
    {
        static void Main(string[] args)
        {
            //1.                                        寻址方案               套接字类型           协议类型    SocketType.Dgram,无连接。协议UDP。
            Socket udpserver = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

            //2.绑定IP 端口
            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
            EndPoint endpoint = new IPEndPoint(ipaddress, 8888);
            udpserver.Bind(endpoint);

            //3.不用监听，直接接收

            EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);       
            byte[] data = new byte[1024];
            while (true) { 
            int length = udpserver.ReceiveFrom(data, ref remoteEndPoint);     

            string message = Encoding.UTF8.GetString(data, 0, length);
            Console.WriteLine("服务器接收到客户端发来的消息：" + message);
            }
            udpserver.Close();
            Console.ReadKey();
        }

    }

(2)客户端(发送端)

 class Program
    {
        static void Main(string[] args)
        {
            //1.
            Socket udpclient = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

            //2.

            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
            EndPoint serverpoint = new IPEndPoint(ipaddress, 8888);
            while (true) {
            string message = Console.ReadLine();
            byte[] data = Encoding.UTF8.GetBytes(message);
            udpclient.SendTo(data, serverpoint);//直接发送，不用连接
            }
            Console.ReadKey();
        }
    }

这里就可以很直观的看出TCP和UDP的区别了，TCP需要建立连接后再传输数据。而UDP则不需要连接，只是向地址发送数据。

3.TcpListener/TcpClient TCP

(1)服务端

   class Program
    {
        static void Main(string[] args)
        {
            //1.TcpListener对Socket进行封装，会自己创建一个Socket对象
            TcpListener tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), 8888);
            try
            {
                //2.开始监听
                tcpListener.Start();
                //3.等待连接
                TcpClient tcpClient = tcpListener.AcceptTcpClient();
                //4.获取客户端发送的数据
                NetworkStream ns = tcpClient.GetStream();
                while (true)
                {
                    byte[] date = new byte[1024];
                    int length = ns.Read(date,0,1024);
                    string message = Encoding.UTF8.GetString(date, 0, length);
                    Console.WriteLine("收到信息： "+message);
                    if (message == "stop") break;
                }
                ns.Close();
                tcpClient.Close();
                tcpListener.Stop();
                Console.ReadLine();

            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

        }
    }

(2)客户端

public static class Online
    {
        public static bool IsOnline(this TcpClient c)//该函数用来判断远程主机是否关闭连接
        {
            return !((c.Client.Poll(1000, SelectMode.SelectRead) && (c.Client.Available == 0)) || !c.Client.Connected);
        }
    }
       
    class Program
    {
    
        static void Main(string[] args)
        {
            try {
            TcpClient tcpClient = new TcpClient("127.0.0.1", 8888);//和远程主机建立连接
            NetworkStream ns = tcpClient.GetStream();//通过网络流来传输数据
            {
                while (Online.IsOnline(tcpClient))
                {
                    string message = Console.ReadLine();
                    byte[] date = new byte[1024];
                    date = Encoding.UTF8.GetBytes(message);
                    ns.Write(date, 0, date.Length);
                }
                Console.WriteLine("断开连接");
                ns.Close();
                tcpClient.Close();
            }
            Console.ReadLine();
        }catch(Exception e){
            Console.WriteLine(e);
            Console.ReadLine();
        }
        }
    }

4.UdpClient UDP

(1)服务端(接收端)

  class Program
    {
        static void Main(string[] args)
        {
            UdpClient udpClient = new UdpClient(new IPEndPoint(IPAddress.Parse("127.0.0.1"),8888));//绑定本机IP端口
            try { 
            while(true)
            {
                IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = udpClient.Receive(ref ipEndPoint);
                string message = Encoding.UTF8.GetString(data, 0, data.Length);
                Console.WriteLine("收到信息：" + message);
   
            }
            }
            catch (Exception e)
            {
                udpClient.Close();
            }
           
        }
    }

(2)客户端(发送端)

    class Program
    {
        static void Main(string[] args)
        {
             UdpClient udpClient = new UdpClient();
             try
             {
                 while (true)
                 {
                     //发送数据
                     string message = Console.ReadLine();
                     byte[] data = Encoding.UTF8.GetBytes(message);
                     IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127
                     0.0.1"), 8888);
                     udpClient.Send(data, data.Length, ipEndPoint);
                 }

             }
             catch (Exception e)
             {
                 Console.WriteLine(e);
                 udpClient.
            }
        }
    }

OSI七层模型与TCP/IP四层模型

Wed, 25 Jul 2018 01:00:23 +0800

以前虽然学校有学习过计算机网络，但是平时接触网络编程比较少，因此我对计算机网络只有个大概的印象。什么OSI七层模型，TCP/IP四层模型这样表面的东西。但是到底哪七层哪四层？这两个模型有什么关系？TCP、UDP、FTP、HTTP这些协议到底是什么？又是什么关系？带着这些问题我开始从网上查找资料进行学习，并整理成这篇博文。

1.OSI七层模型

开放系统互连参考模型 (Open System Interconnect 简称OSI）是国际标准化组织(ISO)和国际电报电话咨询委员会(CCITT)联合制定的开放系统互连参考模型，为开放式互连信息系统提供了一种功能结构的框架。它从低到高分别是：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。
这里不详细说明OSI七层模型，附一张非常详细的图。

OSI 七层模型通过七个层次化的结构模型使不同的系统不同的网络之间实现可靠的通讯，因此其最主要的功能就是帮助不同类型的主机实现数据传输。完成中继功能的节点通常称为中继系统。在OSI七层模型中，处于不同层的中继系统具有不同的名称。
一个设备工作在哪一层，关键看它工作时利用哪一层的数据头部信息。网桥工作时，是以MAC头部来决定转发端口的，因此显然它是数据链路层的设备。

物理层：网卡，网线，集线器，中继器，调制解调器

数据链路层：网桥，交换机(MAC)

网络层：路由器(IP)

网关工作在第四层传输层及其以上

集线器是物理层设备,采用广播的形式来传输信息。交换机就是用来进行报文交换的机器。多为链路层设备(二层交换机)，能够进行地址学习，采用存储转发的形式来交换报文.。路由器的一个作用是连通不同的网络，另一个作用是选择信息传送的线路。选择通畅快捷的近路，能大大提高通信速度，减轻网络系统通信负荷，节约网络系统资源，提高网络系统畅通率。

常见的数据单元如下: 物理层比特（bit）

数据链路层：帧(frame)

网络层：数据报/包 (packet)

运输层：数据段(segment)

会话层、表示层、应用层：一般就称呼为消息（message)

数据链路层的PDU叫做Frame（帧）；

网络层的PDU叫做Packet（数据包）；

TCP的叫做Segment（数据段）；

UDP的叫做Datagram。（数据报）——和网络层的Packet区别开，太过理论了，不讨论。

2.TCP/IP协议簇

互联网协议族（Internet Protocol Suite，缩写IPS）是一个网络通信模型，以及一整个网络传输协议家族，为互联网的基础通信架构。它常被通称为TCP/IP协议族（TCP/IP Protocol Suite，或TCP/IP Protocols），简称TCP/IP。 TCP/IP提供点对点的链接机制，将数据应该如何封装、定址、传输、路由以及在目的地如何接收，都加以标准化。它通常将软件通信过程抽象化为四个抽象层，采取协议堆栈的方式，分别实现出不同通信协议。协议套组下的各种协议，依其功能不同，被分别归属到这四个层次结构之中，常被视为是简化的七层OSI模型。与OSI对应关系如下:

在上面，通常我们是把TCP/IP协议族分为四层，但是如果是五层的话就是在链路层下再加个物理层。下面是对各层的详细介绍。

3.TCP/UDP

从上面的学习我们可以知道TCP和UDP协议都属于TCP/IP模型中的传输层协议。

(1)TCP

TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂，只简单的描述下这三次对话的简单过程：

（1）第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

（2）第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

（3）第三次握手 ：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。关于需要握手三次的理解：TCP是一种可靠的传输，所以建立连接的时候也是需要保证可靠的，应答机制是必不可少的。A和B要完成一次完整的信息交互：A向B发送了一次数据，B必须告诉A自己收到数据，并且告诉一些信息给A，这就导致第二次数据的发送，当然A收到B发过来的数据，也必须告诉B自己收到了数据，所以A需要再一次发送数据给B。这三次是完成一个信息交互最基本的过程，整个过程感觉上是一问一答，有问必答的形式。

TCP建立连接要进行3次握手,而断开连接要进行4次：

（1） 当主机A完成数据传输后,将控制位FIN置1,提出停止TCP连接的请求

（2） 主机B收到FIN后对其作出响应,确认这一方向上的TCP连接将关闭,将ACK置1

（3） 由B 端再提出反方向的关闭请求,将FIN置1

（4） 主机A对主机B的请求进行确认,将ACK置1,双方向的关闭结束。

为什么需要分为四次的原因： 这是因为服务端的LISTEN状态下的SOCKET当收到SYN报文的建连请求后，它可以把ACK和SYN（ACK起应答作用，而SYN起同步作用）放在一个报文里来发送。但关闭连接时，当收到对方的FIN报文通知时，它仅仅表示对方没有数据发送给你了；但未必你所有的数据都全部发送给对方了，所以你可以未必会马上会关闭SOCKET,也即你可能还需要发送一些数据给对方之后，再发送FIN报文给对方来表示你同意现在可以关闭连接了，所以它这里的ACK报文和FIN报文多数情况下都是分开发送的。

下面用两张图更为简洁明了地展示三次握手和四次挥手:

三次握手：

四次挥手：

(2)UDP

（1） UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。

（2） 由于传输数据不建立连接，因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。

（3） UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很小。

（4） 吞吐量不受拥挤控制算法的调节，只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制。

（5） UDP使用尽最大努力交付，即不保证可靠交付，因此主机不需要维持复杂的链接状态表（这里面有许多参数）。

（6） UDP是面向报文的。发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付给IP层。既不拆分，也不合并，而是保留这些报文的边界，因此，应用程序需要选择合适的报文大小。我们经常使用“ping”命令来测试两台主机之间TCP/IP通信是否正常，其实“ping”命令的原理就是向对方主机发送UDP数据包，然后对方主机确认收到数据包，如果数据包是否到达的消息及时反馈回来，那么网络就是通的。

(3)小结TCP/UDP区别

1.基于连接与无连接；

2.对系统资源的要求(TCP较多，UDP少)；

3.UDP程序结构较简单；

4.流模式与数据报模式；

5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证。

注：关于第4点不同的解释：用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535－20－8＝65507字节，其中20字节为IP包头长度，8字节为UDP包头长度。用sendto函数发送数据时，如果指的的数据长度大于该值，则函数会返回错误。用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，可能会被分段发送，如果比较短，可能会等待和下一次数据一起发送。关于第5点不同的解释：多线程的调度问题，先发的后调度，后发的先调度，以及路由选择的不同路径都可能造成UDP数据到达的无序性。

(4) TCP粘包拆包与UDP丢包

(1) TCP粘包拆包

TCP是数据流传输，没有边界。为了效率，TCP接受到应用数据不是马上发送到网络，而是根据默认使用的Nagle算法来进行缓存。简单的说，如果一个数据包太大，就会进行拆包，然后先发送部分。如果几个数据包太小，则拼接起来一起发送。对于处理粘包的关键在于提前获取到数据包的长度，无论这个长度是提前商定好的还是写在在数据包的开头。详细可以看这篇博客。

(2) UDP丢包

上面讲到，UDP不保证可靠的交付。因为网络、接收方、发送方一些原因，会导致包的丢失。因为UDP丢包的原因比较复杂，这里不详细讨论了。

4.Socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。 Socket 接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，用以开发TCP/IP网络上的应用程序。粗俗的讲，Socket只是方便我们实现TCP/UDP的工具类。

参考资料:

ulua官方案例解析

Sat, 21 Jul 2018 01:00:23 +0800

之前我们简单解析uLua是如何让cs和Lua互相调用的。今天我们来分析下官方案例，并实现官方案例的热更新。这里我们需要使用到SimpleFramework的服务器，下载后解压是sln工程文件夹。我们先不管服务器的代码，把Server文件夹拖到Unity工程文件夹下(也就是和Assets同一文件夹)。准备工作大致完成了，接下来我们来解析下案例的代码。

1.GlobalGenerator.cs

        void Awake() {
            InitGameMangager();
        }
        /// <summary>
        /// 实例化游戏管理器
        /// </summary>
        public void InitGameMangager() {
            string name = "GameManager";
            GameObject manager = GameObject.Find(name);
            if (manager == null) {
                manager = new GameObject(name);
                manager.name = name;

                AppFacade.Instance.StartUp();   //启动游戏
            }
        }

这是实例场景login 里GlobalGenerator挂的唯一一个脚本。这个脚本是整个框架的入口，用来启动框架。他新建了一个GameManger的GameObjet，然后启动框架。

2.StartUpCommand.cs

public class StartUpCommand : ControllerCommand {

    public override void Execute(IMessage message) {
        if (!Util.CheckEnvironment()) return;

        GameObject gameMgr = GameObject.Find("GlobalGenerator");
        if (gameMgr != null) {
            AppView appView = gameMgr.AddComponent<AppView>();
        }
        //-----------------关联命令-----------------------
        AppFacade.Instance.RegisterCommand(NotiConst.DISPATCH_MESSAGE, typeof(SocketCommand));

        //-----------------初始化管理器-----------------------
        AppFacade.Instance.AddManager(ManagerName.Lua, new LuaScriptMgr());

        AppFacade.Instance.AddManager<PanelManager>(ManagerName.Panel);
        AppFacade.Instance.AddManager<MusicManager>(ManagerName.Music);
        AppFacade.Instance.AddManager<TimerManager>(ManagerName.Timer);
        AppFacade.Instance.AddManager<NetworkManager>(ManagerName.Network);
        AppFacade.Instance.AddManager<ResourceManager>(ManagerName.Resource);
        AppFacade.Instance.AddManager<ThreadManager>(ManagerName.Thread);
        AppFacade.Instance.AddManager<GameManager>(ManagerName.Game);

        Debug.Log("SimpleFramework StartUp-------->>>>>");
    }
}

上面的StartUp()会通过命令模式调用到StartUpCommand的Execute()，在这里我们关联了新的命令以及添加管理器。 AppFacade.Instance.AddManager<>()在代码中就是把相应的管理器脚本挂在上面GameManger的物体上。因为GameManger是DontDestroy的，因此在场景切换时就不用新加管理器。管理器一般用来执行一些通用的操作，方便调用。

3.GameManager.cs

namespace SimpleFramework.Manager {
    public class GameManager : LuaBehaviour {
        private List<string> downloadFiles = new List<string>();

        /// <summary>
        /// 初始化游戏管理器
        /// </summary>
        void Awake() {
            Init();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        void Init() {
            if (AppConst.ExampleMode) {
                InitGui();
            }
            DontDestroyOnLoad(gameObject);  //防止销毁自己

            CheckExtractResource(); //释放资源
            Screen.sleepTimeout = SleepTimeout.NeverSleep;
            Application.targetFrameRate = AppConst.GameFrameRate;
        }

        /// <summary>
        /// 初始化GUI
        /// </summary>
        public void InitGui() {
            string name = "GUI";
            GameObject gui = GameObject.Find(name);
            if (gui != null) return;

            GameObject prefab = Util.LoadPrefab(name);
            gui = Instantiate(prefab) as GameObject;
            gui.name = name;
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void CheckExtractResource() {
            bool isExists = Directory.Exists(Util.DataPath) &&
              Directory.Exists(Util.DataPath + "lua/") && File.Exists(Util.DataPath + "files.txt");
            if (isExists || AppConst.DebugMode) {
                StartCoroutine(OnUpdateResource());
                return;   //文件已经解压过了，自己可添加检查文件列表逻辑
            }
            StartCoroutine(OnExtractResource());    //启动释放协成 
        }

        IEnumerator OnExtractResource() {
            string dataPath = Util.DataPath;  //数据目录
            string resPath = Util.AppContentPath(); //游戏包资源目录

            if (Directory.Exists(dataPath)) Directory.Delete(dataPath, true);
            Directory.CreateDirectory(dataPath);

            string infile = resPath + "files.txt";
            string outfile = dataPath + "files.txt";
            if (File.Exists(outfile)) File.Delete(outfile);

            string message = "正在解包文件:>files.txt";
            Debug.Log(message);
            facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

            if (Application.platform == RuntimePlatform.Android) {
                WWW www = new WWW(infile);
                yield return www;

                if (www.isDone) {
                    File.WriteAllBytes(outfile, www.bytes);
                }
                yield return 0;
            } else File.Copy(infile, outfile, true);
            yield return new WaitForEndOfFrame();

            //释放所有文件到数据目录
            string[] files = File.ReadAllLines(outfile);
            foreach (var file in files) {
                string[] fs = file.Split('|');
                infile = resPath + fs[0];  //
                outfile = dataPath + fs[0];

                message = "正在解包文件:>" + fs[0];
                Debug.Log("正在解包文件:>" + infile);
                facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

                string dir = Path.GetDirectoryName(outfile);
                if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);

                if (Application.platform == RuntimePlatform.Android) {
                    WWW www = new WWW(infile);
                    yield return www;

                    if (www.isDone) {
                        File.WriteAllBytes(outfile, www.bytes);
                    }
                    yield return 0;
                } else {
                    if (File.Exists(outfile)) {
                        File.Delete(outfile);
                    }
                    File.Copy(infile, outfile, true);
                }
                yield return new WaitForEndOfFrame();
            }
            message = "解包完成!!!";
            facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

            yield return new WaitForSeconds(0.1f);
            message = string.Empty;

            //释放完成，开始启动更新资源
            StartCoroutine(OnUpdateResource());
        }

        /// <summary>
        /// 启动更新下载，这里只是个思路演示，此处可启动线程下载更新
        /// </summary>
        IEnumerator OnUpdateResource() {
            downloadFiles.Clear();

            if (!AppConst.UpdateMode) {
                ResManager.initialize(OnResourceInited);
                yield break;
            }
            string dataPath = Util.DataPath;  //数据目录
            string url = AppConst.WebUrl;
            string random = DateTime.Now.ToString("yyyymmddhhmmss");
            string listUrl = url + "files.txt?v=" + random;
            Debug.LogWarning("LoadUpdate---->>>" + listUrl);

            WWW www = new WWW(listUrl); yield return www;
            if ( www.error != "") {
                OnUpdateFailed(string.Empty);
                yield break;
            }
            if (!Directory.Exists(dataPath)) {
                Directory.CreateDirectory(dataPath);
            }
            File.WriteAllBytes(dataPath + "files.txt", www.bytes);

            string filesText = www.text;
            string[] files = filesText.Split('\n');

            string message = string.Empty;
            for (int i = 0; i < files.Length; i++) {
                if (string.IsNullOrEmpty(files[i])) continue;
                string[] keyValue = files[i].Split('|');
                string f = keyValue[0];
                string localfile = (dataPath + f).Trim();
                string path = Path.GetDirectoryName(localfile);
                if (!Directory.Exists(path)) {
                    Directory.CreateDirectory(path);
                }
                string fileUrl = url + keyValue[0] + "?v=" + random;
                bool canUpdate = !File.Exists(localfile);
                if (!canUpdate) {
                    string remoteMd5 = keyValue[1].Trim();
                    string localMd5 = Util.md5file(localfile);
                    canUpdate = !remoteMd5.Equals(localMd5);
                    if (canUpdate) File.Delete(localfile);
                }
                if (canUpdate) {   //本地缺少文件
                    Debug.Log(fileUrl);
                    message = "downloading>>" + fileUrl;
                    facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);
                    /*
                    www = new WWW(fileUrl); yield return www;
                    if (www.error != null) {
                        OnUpdateFailed(path);   //
                        yield break;
                    }
                    File.WriteAllBytes(localfile, www.bytes);
                     * */
                    //这里都是资源文件，用线程下载
                    BeginDownload(fileUrl, localfile);
                    while (!(IsDownOK(localfile))) { yield return new WaitForEndOfFrame(); }
                }
            }
            yield return new WaitForEndOfFrame();
            message = "更新完成!!";
            facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

            ResManager.initialize(OnResourceInited);
        }

        /// <summary>
        /// 是否下载完成
        /// </summary>
        bool IsDownOK(string file) {
            return downloadFiles.Contains(file);
        }

        /// <summary>
        /// 线程下载
        /// </summary>
        void BeginDownload(string url, string file) {     //线程下载
            object[] param = new object[2] {url, file};

            ThreadEvent ev = new ThreadEvent();
            ev.Key = NotiConst.UPDATE_DOWNLOAD;
            ev.evParams.AddRange(param);
            ThreadManager.AddEvent(ev, OnThreadCompleted);   //线程下载
        }

        /// <summary>
        /// 线程完成
        /// </summary>
        /// <param name="data"></param>
        void OnThreadCompleted(NotiData data) {
            switch (data.evName) {
                case NotiConst.UPDATE_EXTRACT:  //解压一个完成
                    //
                break;
                case NotiConst.UPDATE_DOWNLOAD: //下载一个完成
                    downloadFiles.Add(data.evParam.ToString());
                break;
            }
        }

        /// <summary>
        /// 资源初始化结束
        /// </summary>
        public void OnResourceInited() {
            LuaManager.Start();
            LuaManager.DoFile("Logic/Network");       //加载网络
            LuaManager.DoFile("Logic/GameManager");    //加载游戏
            initialize = true;                     //初始化完 

            NetManager.OnInit();    //初始化网络

            object[] panels = CallMethod("LuaScriptPanel");  
            //---------------------Lua面板---------------------------
            foreach (object o in panels) {
                string name = o.ToString().Trim();
                if (string.IsNullOrEmpty(name)) continue;
                name += "Panel";    //添加

                LuaManager.DoFile("View/" + name);
                Debug.LogWarning("LoadLua---->>>>" + name + ".lua");
            }
            //------------------------------------------------------------
            CallMethod("OnInitOK");   //初始化完成
        }

        void OnUpdateFailed(string file) {
            string message = "更新失败!>" + file;
            facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);
        }

   
}

这个是热更新核心的管理器，大部分是从服务器下载资源的代码。OnResourceInited()函数里加载了lua网络模块还有GameManager.lua，并且调用了GameManager.lua里的LuaScriptPanel和OnInitOK。从代码可以看出，uLua从服务器上下载了files.txt，然后和本地的files.txt进行对比来进行更新。使用Unity 2017的同学这里要注意，这里有个坑，源代码里加载如果没有问题使用www.error != null来判断。而在Unity 2017版本已经改为www.error != ““。我们这里可以使用String.IsNullOrEmpty(www.error)。这样可以兼容2017及2017以下版本。

4.GameManager.lua

--管理器--
GameManager = {};
local this = GameManager;

local game; 
local transform;
local gameObject;
local WWW = UnityEngine.WWW;

function GameManager.LuaScriptPanel()
	return 'Prompt', 'Message';
end

function GameManager.Awake()
    --warn('Awake--->>>');
end

--启动事件--
function GameManager.Start()
	--warn('Start--->>>');
end

--初始化完成，发送链接服务器信息--
function GameManager.OnInitOK()
    AppConst.SocketPort = 2012;
    AppConst.SocketAddress = "127.0.0.1";
    NetManager:SendConnect();
    CtrlManager.Init();
    local ctrl = CtrlManager.GetCtrl(CtrlName.Prompt);
    if ctrl ~= nil and AppConst.ExampleMode then
        ctrl:Awake();
    end
       
    logWarn('SimpleFramework InitOK--->>>');
end

--销毁--
function GameManager.OnDestroy()
	--logWarn('OnDestroy--->>>');
end

LuaScriptPanel用来返回游戏里需要使用的面板名，并且返回给GameManager.cs,用来调用 xxxPanel.lua，初始化面板的一些属性数据。当初始化完成后GameManager.cs回调OnInitOK，发送连接服务器，并且获取了PromptCtrl的控制器，进行Prompt面板位置，外观等初始化。

5.PromptCtrl.lua

--构建函数--
function PromptCtrl.New()
	logWarn("PromptCtrl.New--->>");
	return this;
end

function PromptCtrl.Awake()
	logWarn("PromptCtrl.Awake--->>");
	PanelManager:CreatePanel('Prompt', this.OnCreate);
end

--启动事件--
function PromptCtrl.OnCreate(obj)
	gameObject = obj;
	transform = obj.transform;

	panel = transform:GetComponent('UIPanel');
	prompt = transform:GetComponent('LuaBehaviour');
	logWarn("Start lua--->>"..gameObject.name);

	this.InitPanel();	--初始化面板--
	prompt:AddClick(PromptPanel.btnOpen, this.OnClick);
end

--初始化面板--
function PromptCtrl.InitPanel()
	panel.depth = 1;	--设置纵深--
	local parent = PromptPanel.gridParent;
	local itemPrefab = prompt:LoadAsset('PromptItem');
	for i = 1, 100 do
		local go = newObject(itemPrefab);
		go.name = tostring(i);
		go.transform.parent = parent;
		go.transform.localScale = Vector3.one;
		go.transform.localPosition = Vector3.zero;
		prompt:AddClick(go, this.OnItemClick);

		local goo = go.transform:Find('Label');
		goo:GetComponent('UILabel').text = i;
	end
	local grid = parent:GetComponent('UIGrid');
	grid:Reposition();
	grid.repositionNow = true;
	parent:GetComponent('WrapGrid'):InitGrid();
end

--滚动项单击事件--
function PromptCtrl.OnItemClick(go)
	log(go.name);
end

--单击事件--
function PromptCtrl.OnClick(go)
	if TestProtoType == ProtocalType.BINARY then
		this.TestSendBinary();
	end
end

--测试发送二进制--
function PromptCtrl.TestSendBinary()
    local buffer = ByteBuffer.New();
    buffer:WriteShort(Login);
    buffer:WriteByte(ProtocalType.BINARY);
    buffer:WriteString("ffff我的ffffQ靈uuu");
    buffer:WriteInt(200);
    NetManager:SendMessage(buffer);
end

--关闭事件--
function PromptCtrl.Close()
	PanelManager:ClosePanel(CtrlName.Prompt);
end

InitPanel()，OnItemClick()用来初始化面板和列表Item。通过PanelManager:CreatePanel()来实例化预制体，回调初始化。绑定按钮点击事件调用OnClick(),向服务器发送消息。

6.NetWork.lua

function Network.Start() 
    logWarn("Network.Start!!");
    Event.AddListener(Connect, this.OnConnect); 
    Event.AddListener(Login, this.OnLogin); 
    Event.AddListener(Exception, this.OnException); 
    Event.AddListener(Disconnect, this.OnDisconnect); 
end

--Socket消息--
function Network.OnSocket(key, data)
    Event.Brocast(tostring(key), data);
end

--当连接建立时--
function Network.OnConnect() 
    logWarn("Game Server connected!!");
end

--异常断线--
function Network.OnException() 
    islogging = false; 
    NetManager:SendConnect();
   	logError("OnException------->>>>");
end

--连接中断，或者被踢掉--
function Network.OnDisconnect() 
    islogging = false; 
    logError("OnDisconnect------->>>>");
end

--登录返回--
function Network.OnLogin(buffer) 
	if TestProtoType == ProtocalType.BINARY then
		this.TestLoginBinary(buffer);
	end
	----------------------------------------------------
    --createPanel("Message"); --Lua里创建面板
    local ctrl = CtrlManager.GetCtrl(CtrlName.Message);
    if ctrl ~= nil then
        ctrl:Awake();
    end
    logWarn('OnLogin----------->>>');
end

--二进制登录--
function Network.TestLoginBinary(buffer)
	local protocal = buffer:ReadByte();
	local str = buffer:ReadString();
	log('TestLoginBinary: protocal:>'..protocal..' str:>'..str);
end
--卸载网络监听--
function Network.Unload()
    Event.RemoveListener(Connect);
    Event.RemoveListener(Login);
    Event.RemoveListener(Exception);
    Event.RemoveListener(Disconnect);
    logWarn('Unload Network...');
end

PromptCtrl.lua中用来向服务器发送数据的NetManager.cs是StartUpCommand.cs初始化的管理器之一。它在Update()中对从服务器收到的消息进行派发，而发送的NotiConst.DISPATCH_MESSAGE命令仅仅在StartUpCommand.cs关联过SocketCommand.cs，这里又调用了Network.lua的OnSocket()函数,从Lua中进行消息的派发。而事件监听我们早早的在GameManager.cs就调用了NetWork.lua，对事件进行监听。因为我们在PromptCtrl.lua中，向服务器发送的是Login消息，案例的服务器会下发Login。根据代码调用了OnLogin()，然后开始创建Message面板，这里初始化等和上面的PromptCtrl.lua差不多就不详细讲了。

7.实际操作

把AppConst.cs中的UpdateMode设为true。然后把StreamingAssets文件夹下的文件删除。点击Lua/Clear LuaBinder File + Wrap Files 清除wrap文件，再点击Lua/Gen Lua Wrap Files 生成wrap文件，点击Game/Build Windows Resource打包资源。上面这些操作是为了保证文件和资源为最新的。

然后打开服务器，启动项目就可以看到服务器接受到Login，并且点击按钮显示出消息面板。

ulua的简单解析，cs和Lua的相互调用

Thu, 19 Jul 2018 01:00:23 +0800

热更新是unity一个长久的话题，热更新主要有两部分，一部分就是资源，这个靠u3d的assetbundle就可以做，另一部分就是逻辑了。游戏更新难免会遇到一些流程或者UI的逻辑变动。在PC和Android上可以使用C#的反射来动态的生成代码，而IOS的Full AOT（完全预先编译/静态编译）的性质，因此这个办法在IOS上使用不了。为了解决这个问题，我们引入了Lua。使用Lua的主要原因是因为Lua在Unity是当作文本资源使用的，Lua在Unity中的执行是依赖于解释器(虚拟机)读取Lua代码进行解释执行。所以工程中比较常变化的逻辑代码都是写在Lua中，通过更新Lua（文本文件）来实现逻辑的热更，而常用的热更新方案有sLua,xLua,uLua等等。公司这里使用的是ulua，因此今天就来初步解析并使用下uLua。为了方便学习，本文章使用的是SimpleFramework_NGUI_v0.4.1，这个集成了NGUI,uLua的框架。

1.简单认识uLua

uLua具体怎么去调用Lua的，怎么让Lua调用C#这里先不做具体研究，先简单地使用起来，不去探究原理了。我们先认识下uLua中的几个类，让我们不至于使用得不明不白。当然如果想要直接使用，则可以跳过这个部分。

(1)WrapFile.cs

WrapFile类的内容很简单，就是保存了一个需要生成Wrap的数组(binds)。通过_GT()方法来获取类的信息并标记类的类型。如果我们用C#写了个类想要在Lua中使用，可以在binds中添加

(2)BindLua.cs

BingLua.cs类里主要是uLua对Unity菜单栏的一些扩展。里面有一些批处理方法，比如Lua/Gen Lua Wrap Files实际上是调用了Binding()方法。这个方法用来遍历WrapFil里的binds数组，来生成相应的Wrap文件。而里面调用的GenLuaBinder()方法用来生成Wrap.lua和LuaBinder.cs。GenLuaDelegates()方法用来生成DelegateFactory.cs。

(3)Wrap.lua

Wrap.lua使用了”import 类名”把类注册到lua中，import字段是在Lua.cs的LuaState()方法来绑定到lua的全局表中，并且用来调用LuaStatic.importWrap()方法。因为我们要调用Lua时一般会用用到LuaScriptMgr.cs。在New LuaScriptMgr()时，则会自动调用LuaState()方法来绑定一些全局的字段。

(4)LuaBinder.cs

LuaBinder.Bind()方法则是用来把Wrap.lua里的类和相应的Wrap类，通过Wrap类的Register()方法来进行绑定。

(5)DelegateFactory.cs

大致和LuaBinder类似，用来注册委托。

这样我们就知道通过Unity的菜单栏，uLua为我们做了什么事。我们该如何简单的使用uLua，下面我来演示一下。

2.简单使用uLua

首先，把AppConst.cs中的DebugMode设置为true，这是框架的设置。意思是我们会在Unity编辑器下来运行程序，而不是打包到具体平台上使用。当DebugMode为true时会读取工程的Lua文件夹来获取Lua文件。以后如果需要导出具体平台上的包则需要通过Game/Build xxx Resource 他会根据不同平台把lua和资源生成到相应的文件夹下。

我们先写一个cs用来注册到Lua中：

public class CsToLuaTest
{
    public CsToLuaTest() { }
	public void  testprint()
    {
        Debug.Log("success");
    }
}

这里有一个坑，我们写的这个类不能继承MonoBehaviour。因为继承了MonoBehaviour的类不能使用构造函数来创建对象，只能用AddComponent()来创建对象。而uLua是通过把注册到Lua中的类所有的构造方法绑定为New来创建对象的。如果从Unity中新建的脚本记得把MonoBehaviour删去。

再写一个Lua文件LuaTest.lua，用来在Lua中调用我们写的testprint()方法：

local this = LuaTest;
function LuaTest.Test(data)
      data:testprint();
end

写一个类用来运行调用这个lua文件 StartTest.cs:

public class StartTest : MonoBehaviour {
  
    public void Awake()
    {
   
    }
	// Use this for initialization
	void Start () {
        CsToLuaTest test = new CsToLuaTest();
        LuaScriptMgr mgr = new LuaScriptMgr();
        mgr.Start();
        mgr.DoFile("LuaTest.lua");//这里放在工程中Lua文件夹下
        mgr.CallLuaFunction("LuaTest.Test", test);//传入一个CsToLuaTest对象

	}
	// Update is called once per frame
	void Update () {
		
	}
}

接下来打开WrapFile.cs，仿照着把CsToLuaTest写进binds中。在菜单栏中点击Lua/Clear LuaBinder + Wrap Files。这是清除之前已经生成的文件。然后再点击Lua/Gen Lua Wrap Files。这样就能生成Wrap文件并在Lua中进行注册了。把StartTest绑到场景中的物体上，运行游戏。就能看到我们在LuaTest.lua成功调用了CsToLuaTest.cs中的testprint()方法并打出了success的日志。

由变量类型、装箱拆箱、到ref/out到堆栈到GC

Tue, 17 Jul 2018 01:38:23 +0800

1.变量类型

C#是强类型语言，类型大体分为两种，其一是值类型(如int,float,struct,enum)，另一种是引用类型(类,string,object 后两个比较特殊，后面会讲)。值类型的值是他本身，而引用类型则是类似保存了内存地址。show you the code。

值类型:

	public struct ValueTyepTest
    {
       public int iValue;
    }
    class Program
    {
        static void Main(string[] args)
        {
            ValueTyepTest valueType1 = new ValueTyepTest();
            valueType1.iValue = 1;
            ValueTyepTest valueType2 = valueType1;
            valueType1.iValue = 2;
            Console.WriteLine(valueType2.iValue);
            Console.ReadLine();

        }
    }

输出结果是1。

valueType1赋值给valueType2之后，两者没有关系了，各自的变化互不影响。

引用类型：

  public class ValueTyepTest
    {
       public int iValue;
    }
    class Program
    {
        static void Main(string[] args)
        {
            ValueTyepTest valueType1 = new ValueTyepTest();
            valueType1.iValue = 1;
            ValueTyepTest valueType2 = valueType1;
            valueType1.iValue = 2;
            Console.WriteLine(valueType2.iValue);
            Console.ReadLine();

        }
    }

输出结果是2。

这里只是把struct变成了class，变量类型则从值类型变为了引用类型。引用类型存的是变量的引用，我们这就把他当作地址看。valueType1存储了iValue=1的地址,valueType2=valueType1则使valueType2也指向了这段地址。valueType2.iValue=2使这段地址的iValue=2。输出结果就变成了2.

2.装箱拆箱

装箱就是把值类型封装为object的过程，拆箱则是相反的过程,以下是microsoft C#编程指南的示例代码: 装箱:

int i = 123;
// The following line boxes i.
object o = i;  
拆箱:
o = 123;
i = (int)o;  // unboxing

装箱可以写成object o = (object) i; (object)可以省略，但是拆箱的(int)是不能省略的，这里主要还是考虑到类型安全，拆箱必须保证该值变量有足够的空间存储拆箱后得到的值，这里是需要十分注意的。

3.ref/out

在C#中，方法的参数传递默认是按值传递的。而ref/out这两个关键字就可以使值类型变为引用传递。

值类型值传递:

		static void Change(int i)
        {
            i += i;
            Console.WriteLine("Change： " + i);
        }
        static void Main(string[] args)
        {
            int n = 1;
            Console.WriteLine("Change Before:  " + n);
            Change(n);
            Console.WriteLine("Change After:  " + n);
            Console.ReadLine();

       }

输出： Change Before: 1 Change： 2 Change After: 1

值传递就是把值赋给了形参，形参在作用域内相当于一个新的变量。在作用域内改变形参的值，不会改变外面实参的值。上面我们用值类型进行值传递，我们下面用引用类型进行值传递。引用类型值传递:

	class  RefType
    {
       public int value;
    }
    class Program
    {

        static void Change(RefType i)
        {
            i.value = 999;
            i = new RefType();
            i.value = 2;
            Console.WriteLine("Change： " + i.value);
        }
        static void Main(string[] args)
        {
            RefType n = new RefType();
            n.value = 1;
            Console.WriteLine("Change Before:  " + n.value);
            Change(n);
            Console.WriteLine("Change After:  " + n.value);
            Console.ReadLine();

        }
    }

输出： Change Before: 1 Change： 2 Change After: 999

我们传了一个地址到方法里，在方法里把这个地址的value变量改为了999，然后改变了方法内作为形参的引用变量的值，把这个引用类型指向了新的引用。结果并没有影响到实参。这里不能被输出的999混淆，输出999只是因为地址存储的变量变成了999，并不是通过改变原来的引用而改变输出值。

值类型引用传递：

		static void Change(ref int i)
        {
           
            i += i;
            Console.WriteLine("Change： " + i);
        }
        static void Main(string[] args)
        {
            int n = 1;           
            Console.WriteLine("Change Before:  " + n);
            Change(ref n);
            Console.WriteLine("Change After:  " + n);
            Console.ReadLine();

        }

输出： Change Before: 1 Change： 2 Change After: 2 可以看到我们通过改变了方法里形参的值而改变了实参的值。方法里的i变量实际不是int类型，而是实参n的引用。引用类型引用传递:

	class RefType
    {
        public int value;
    }
    class Program
    {

        static void Change(ref RefType i)
        {
            i.value = 999;
            i = new RefType();
            i.value = 2;
            Console.WriteLine("Change： " + i.value);
        }
        static void Main(string[] args)
        {
            RefType n = new RefType();
            n.value = 1;
            Console.WriteLine("Change Before:  " + n.value);
            Change(ref n);
            Console.WriteLine("Change After:  " + n.value);
            Console.ReadLine();

        }
    }

输出： Change Before: 1 Change： 2 Change After: 2 这里方法里的i变成了实参n的引用，改变i即改变了n。

值传递可以看成新建了一个变量，他的值与实参的值一样，而形参如何改变是无法影响到实参的。引用传递则是相当于形参就是实参，形参怎么改变实参会跟着变化。

4.堆栈

C#里面的栈叫做堆栈，堆则一般称作托管堆。值类型存储在栈，引用类类型则是在托管堆中。系统把可用内存分为两部分，分别供堆和栈使用。

堆栈的工作方式：

{
    int a;
    {
        int b;
    }
}

比如上面的代码,a、b在创建时都在栈中占用了4个字节。而当b初了作用域之后，则b的所占用的内存进行释放。堆栈是向下填充的，即从高地址向低地址填充。当数据入栈后，堆栈指针就会随之调整，指向下一个自由空间。比如我们起始的地址为600000,a先声明，堆栈指针指向了599996,当声明时指向599992。当b出作用域后，指针指向599996。

托管堆工作方式：

	class RefType
    {
        public int value;
		public int i;
    }

	static void Main(string[] args)
	{
		RefType n；
		n = new RefType();
	}

上面RefType n；中，声明了一个引用类型，此时并没有指向引用，这里使用了堆栈来存储引用地址，32位机占用了堆栈4个字节。n = new RefType();则在托管堆中申请了一块连续的内存来保存类。如果我们起始地址为200000，因为类中有两个int类型的值则指针指向了200008。

5.GC

托管堆如其名，是托管在CLR，由GC进行释放的。 CLR在运行时管理着一段内存地址空间（虚拟地址空间，在运行中会映射到物理内存地址中），分为“托管堆”和“栈”两部分，栈用于存储值类型数据，它会在方法执行结束后自动销毁其中引用的值类型变量，这一部分不属于垃圾收集的范围。托管堆用于引用类型的变量存储，是GC的主要位置。托管堆是一段连续的地址空间，其中所分配出去的空间呈现出类似数组形态的队列结构。当对象不再被引用时，内存被被释放，这样会导致内存变成一块一块的断层。当有新的对象生成时，.Net则需要搜索整个堆才能找到一块足够大的连续的空间。GC就是当释放了能释放的对象，压缩其他对象，使他们都在堆顶。这样所有对象的引用地址都需要更新，当声明新的对象就会快许多。

上面提到了string类型和object类型是比较特殊的引用类型。这里就可以很好解释了。

string str1="hello world";
string str2=str1;
str1="hello"
Console.WriteLine(str1+" "+str2 );

则输出的是 hello hello world。并不是预想中的hello hello。这是因为string在赋值后，在堆中的内存已经是固定的了，再重新赋值所需内存大小发生变化，需要找一块新的连续的堆内存来存储。