unity3d基础学习笔记16：C#Socket应用

http://blog.csdn.net/jbjwpzyl3611421/article/details/12676625

 

最近比较忙，有段时间没写博客拉。最近项目中需要使用HTTP与Socket，雨松MOMO把自己这段时间学习的资料整理一下。有关Socket与HTTP的基础知识MOMO就不赘述拉，不懂得朋友自己谷歌吧。我们项目的需求是在登录的时候使用 HTTP请求，游戏中其它的请求都用Socket请求，比如人物移动同步坐标，同步关卡等等。

1.Socket

        Socket不要写在脚本上，如果写在脚本上游戏场景一旦切换，那么这条脚本会被释放掉，Socket会断开连接。场景切换完毕后需要重新在与服务器建立 Socket连接，这样会很麻烦。所以我们需要把Socket写在一个单例的类中，不用继承MonoBehaviour。这个例子我模拟一下，主角在游戏中移动，时时向服务端发送当前坐标，当服务器返回同步坐标时角色开始同步服务端新角色坐标。

Socket在发送消息的时候采用的是字节数组，也就是说无论你的数据是 intfloat short object 都会将这些数据类型先转换成byte[] ， 目前在处理发送的地方我使用的是数据包，也就是把（角色坐标）结构体object转换成byte[]发送， 这就牵扯一个问题， 如何把结构体转成字节数组，如何把字节数组回转成结构体。请大家接续阅读，答案就在后面，哇咔咔。

直接上代码

JFSocket.cs 该单例类不要绑定在任何对象上

[c#] view plaincopy

1. using UnityEngine;     
2. using System.Collections;     
3. using System;     
4. using System.Threading;     
5. using System.Text;     
6. using System.Net;     
7. using System.Net.Sockets;     
8. using System.Collections.Generic;     
9. using System.IO;     
10. using System.Runtime.InteropServices;     
11. using System.Runtime.Serialization;     
12. using System.Runtime.Serialization.Formatters.Binary;     
13.          
14. public class JFSocket     
15. {     
16.          
17.     //Socket客户端对象     
18.     private Socket clientSocket;     
19.     //JFPackage.WorldPackage是我封装的结构体，     
20.     //在与服务器交互的时候会传递这个结构体     
21.     //当客户端接到到服务器返回的数据包时，我把结构体add存在链表中。     
22.     public List<JFPackage.WorldPackage> worldpackage;     
23.     //单例模式     
24.     private static JFSocket instance;     
25.     public static JFSocket GetInstance()     
26.     {     
27.         if (instance == null)     
28.         {     
29.             instance = new JFSocket();     
30.         }     
31.         return instance;     
32.      }           
33.          
34.     //单例的构造函数     
35.     JFSocket()     
36.     {     
37.         //创建Socket对象， 这里我的连接类型是TCP     
38.         clientSocket = new Socket (AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);     
39.         //服务器IP地址     
40.         IPAddress ipAddress = IPAddress.Parse ("192.168.1.100");     
41.         //服务器端口     
42.         IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060);     
43.         //这是一个异步的建立连接，当连接建立成功时调用connectCallback方法     
44.         IAsyncResult result = clientSocket.BeginConnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket);     
45.         //这里做一个超时的监测，当连接超过5秒还没成功表示超时     
46.         bool success = result.AsyncWaitHandle.WaitOne( 5000, true );     
47.         if ( !success )     
48.         {     
49.             //超时     
50.             Closed();     
51.             Debug.Log("connect Time Out");     
52.         }else  
53.         {     
54.             //与socket建立连接成功，开启线程接受服务端数据。     
55.             worldpackage = new List<JFPackage.WorldPackage>();     
56.             Thread thread = new Thread(new ThreadStart(ReceiveSorket));     
57.             thread.IsBackground = true;     
58.             thread.Start();     
59.         }     
60.     }     
61.          
62.     private void connectCallback(IAsyncResult asyncConnect)     
63.     {     
64.         Debug.Log("connectSuccess");     
65.     }     
66.          
67.     private void ReceiveSorket()     
68.     {     
69.         //在这个线程中接受服务器返回的数据     
70.         while (true)     
71.         {      
72.          
73.             if(!clientSocket.Connected)     
74.             {     
75.                 //与服务器断开连接跳出循环     
76.                 Debug.Log("Failed to clientSocket server.");     
77.                 clientSocket.Close();     
78.                 break;     
79.             }     
80.             try  
81.             {     
82.                 //接受数据保存至bytes当中     
83.                 byte[] bytes = new byte[4096];     
84.                 //Receive方法中会一直等待服务端回发消息     
85.                 //如果没有回发会一直在这里等着。     
86.                 int i = clientSocket.Receive(bytes);     
87.                 if(i <= 0)     
88.                 {     
89.                     clientSocket.Close();     
90.                     break;     
91.                 }        
92.          
93.                 //这里条件可根据你的情况来判断。     
94.                 //因为我目前的项目先要监测包头长度，     
95.                 //我的包头长度是2，所以我这里有一个判断     
96.                 if(bytes.Length > 2)     
97.                 {     
98.                     SplitPackage(bytes,0);     
99.                 }else  
100.                 {     
101.                     Debug.Log("length is not  >  2");     
102.                 }     
103.          
104.              }     
105.              catch (Exception e)     
106.              {     
107.                 Debug.Log("Failed to clientSocket error." + e);     
108.                 clientSocket.Close();     
109.                 break;     
110.              }     
111.         }     
112.     }        
113.          
114.     private void SplitPackage(byte[] bytes , int index)     
115.     {     
116.         //在这里进行拆包，因为一次返回的数据包的数量是不定的     
117.         //所以需要给数据包进行查分。     
118.         while(true)     
119.         {     
120.             //包头是2个字节     
121.             byte[] head = new byte[2];     
122.             int headLengthIndex = index + 2;     
123.             //把数据包的前两个字节拷贝出来     
124.             Array.Copy(bytes,index,head,0,2);     
125.             //计算包头的长度     
126.             short length = BitConverter.ToInt16(head,0);     
127.             //当包头的长度大于0 那么需要依次把相同长度的byte数组拷贝出来     
128.             if(length > 0)     
129.             {     
130.                 byte[] data = new byte[length];     
131.                 //拷贝出这个包的全部字节数     
132.                 Array.Copy(bytes,headLengthIndex,data,0,length);     
133.                 //把数据包中的字节数组强制转换成数据包的结构体     
134.                 //BytesToStruct()方法就是用来转换的     
135.                 //这里需要和你们的服务端程序商量，     
136.                 JFPackage.WorldPackage wp = new JFPackage.WorldPackage();     
137.                 wp = (JFPackage.WorldPackage)BytesToStruct(data,wp.GetType());     
138.                 //把每个包的结构体对象添加至链表中。     
139.                 worldpackage.Add(wp);     
140.                 //将索引指向下一个包的包头     
141.                 index  =  headLengthIndex + length;     
142.          
143.             }else  
144.             {     
145.                 //如果包头为0表示没有包了，那么跳出循环     
146.     
147.                 break;     
148.             }     
149.         }     
150.     }        
151.          
152.     //向服务端发送一条字符串     
153.     //一般不会发送字符串 应该是发送数据包     
154.     public void SendMessage(string str)     
155.     {     
156.         byte[] msg = Encoding.UTF8.GetBytes(str);     
157.          
158.         if(!clientSocket.Connected)     
159.         {     
160.             clientSocket.Close();     
161.             return;     
162.         }     
163.         try  
164.         {     
165.             //int i = clientSocket.Send(msg);     
166.             IAsyncResult asyncSend = clientSocket.BeginSend (msg,0,msg.Length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);     
167.             bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );     
168.             if ( !success )     
169.             {     
170.                 clientSocket.Close();     
171.                 Debug.Log("Failed to SendMessage server.");     
172.             }     
173.         }     
174.         catch  
175.         {     
176.              Debug.Log("send message error" );     
177.         }     
178.     }     
179.          
180.     //向服务端发送数据包，也就是一个结构体对象     
181.     public void SendMessage(object obj)     
182.     {     
183.          
184.         if(!clientSocket.Connected)     
185.         {     
186.             clientSocket.Close();     
187.             return;     
188.         }     
189.         try  
190.         {     
191.             //先得到数据包的长度     
192.             short size = (short)Marshal.SizeOf(obj);     
193.             //把数据包的长度写入byte数组中     
194.             byte [] head = BitConverter.GetBytes(size);     
195.             //把结构体对象转换成数据包，也就是字节数组     
196.             byte[] data = StructToBytes(obj);     
197.          
198.             //此时就有了两个字节数组，一个是标记数据包的长度字节数组， 一个是数据包字节数组，     
199.             //同时把这两个字节数组合并成一个字节数组     
200.          
201.             byte[] newByte = new byte[head.Length + data.Length];     
202.             Array.Copy(head,0,newByte,0,head.Length);     
203.             Array.Copy(data,0,newByte,head.Length, data.Length);     
204.          
205.             //计算出新的字节数组的长度     
206.             int length = Marshal.SizeOf(size) + Marshal.SizeOf(obj);     
207.          
208.             //向服务端异步发送这个字节数组     
209.             IAsyncResult asyncSend = clientSocket.BeginSend (newByte,0,length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);     
210.             //监测超时     
211.             bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );     
212.             if ( !success )     
213.             {     
214.                 clientSocket.Close();     
215.                 Debug.Log("Time Out !");     
216.             }      
217.          
218.         }     
219.         catch (Exception e)     
220.         {     
221.              Debug.Log("send message error: " + e );     
222.         }     
223.     }     
224.          
225.     //结构体转字节数组     
226.     public byte[] StructToBytes(object structObj)     
227.     {     
228.          
229.         int size = Marshal.SizeOf(structObj);     
230.         IntPtr buffer =  Marshal.AllocHGlobal(size);     
231.         try  
232.         {     
233.             Marshal.StructureToPtr(structObj,buffer,false);     
234.             byte[]  bytes  =   new byte[size];     
235.             Marshal.Copy(buffer, bytes,0,size);     
236.             return   bytes;     
237.         }     
238.         finally  
239.         {     
240.             Marshal.FreeHGlobal(buffer);     
241.         }     
242.     }     
243.     //字节数组转结构体     
244.     public object BytesToStruct(byte[] bytes,   Type   strcutType)     
245.     {     
246.         int size = Marshal.SizeOf(strcutType);     
247.         IntPtr buffer = Marshal.AllocHGlobal(size);     
248.         try  
249.         {     
250.             Marshal.Copy(bytes,0,buffer,size);     
251.             return  Marshal.PtrToStructure(buffer,   strcutType);     
252.         }     
253.         finally  
254.         {     
255.             Marshal.FreeHGlobal(buffer);     
256.         }        
257.          
258.     }     
259.          
260.     private void sendCallback (IAsyncResult asyncSend)     
261.     {     
262.          
263.     }     
264.          
265.     //关闭Socket     
266.     public void Closed()     
267.     {     
268.          
269.         if(clientSocket != null && clientSocket.Connected)     
270.         {     
271.             clientSocket.Shutdown(SocketShutdown.Both);     
272.             clientSocket.Close();     
273.         }     
274.         clientSocket = null;     
275.     }     
276.          
277. }  

为了与服务端达成默契，判断数据包是否完成。我们需要在数据包中定义包头，包头一般是这个数据包的长度，也就是结构体对象的长度。正如代码中我们把两个数据类型 short 和 object 合并成一个新的字节数组。

然后是数据包结构体的定义，需要注意如果你在做IOS和Android的话数据包中不要包含数组，不然在结构体转换byte数组的时候会出错。

Marshal.StructureToPtr () error : Attempting to JIT compile method

JFPackage.cs

[c#] view plaincopy

1. using UnityEngine;     
2. using System.Collections;     
3. using System.Runtime.InteropServices;     
4.          
5. public class JFPackage     
6. {     
7.     //结构体序列化     
8.     [System.Serializable]     
9.     //4字节对齐 iphone 和 android上可以1字节对齐     
10.     [StructLayout(LayoutKind.Sequential, Pack = 4)]     
11.     public struct WorldPackage     
12.     {     
13.          public byte mEquipID;     
14.          public byte mAnimationID;     
15.          public byte mHP;     
16.          public short mPosx;     
17.          public short mPosy;     
18.          public short mPosz;     
19.          public short mRosx;     
20.          public short mRosy;     
21.          public short mRosz;     
22.          
23.          public WorldPackage(short posx,short posy,short posz, short rosx, short rosy, short rosz,byte equipID,byte animationID,byte hp)     
24.          {     
25.             mPosx = posx;     
26.             mPosy = posy;     
27.             mPosz = posz;     
28.             mRosx = rosx;     
29.             mRosy = rosy;     
30.             mRosz = rosz;     
31.             mEquipID = equipID;     
32.             mAnimationID = animationID;     
33.             mHP = hp;     
34.          }     
35.          
36.     };       
37.          
38. }  

在脚本中执行发送数据包的动作，在Start方法中得到Socket对象。

[c#] view plaincopy

1. public JFSocket mJFsorket;     
2.          
3. void Start ()     
4. {     
5.     mJFsorket = JFSocket.GetInstance();     
6. }  

让角色发生移动的时候，调用该方法向服务端发送数据。

[c#] view plaincopy

1. void SendPlayerWorldMessage()     
2. {     
3.                 //组成新的结构体对象，包括主角坐标旋转等。     
4.      Vector3 PlayerTransform = transform.localPosition;     
5.      Vector3 PlayerRotation = transform.localRotation.eulerAngles;     
6.                 //用short的话是2字节，为了节省包的长度。这里乘以100 避免使用float 4字节。当服务器接受到的时候小数点向前移动两位就是真实的float数据     
7.      short px =  (short)(PlayerTransform.x*100);     
8.      short py =  (short)(PlayerTransform.y*100);     
9.      short pz =  (short)(PlayerTransform.z*100);     
10.      short rx =  (short)(PlayerRotation.x*100);     
11.      short ry =  (short)(PlayerRotation.y*100);     
12.      short rz =  (short)(PlayerRotation.z*100);     
13.      byte equipID = 1;     
14.      byte animationID =9;     
15.      byte hp = 2;     
16.      JFPackage.WorldPackage wordPackage = new JFPackage.WorldPackage(px,py,pz,rx,ry,rz,equipID,animationID,hp);     
17.                 //通过Socket发送结构体对象     
18.      mJFsorket.SendMessage(wordPackage);     
19. }  

接着就是客户端同步服务器的数据，目前是测试阶段所以写的比较简陋，不过原理都是一样的。哇咔咔！！

[c#] view plaincopy

1. //上次同步时间     
2.       private float mSynchronous;     
3.          
4. void Update ()     
5. {     
6.          
7.     mSynchronous +=Time.deltaTime;     
8.     //在Update中每0.5s的时候同步一次     
9.     if(mSynchronous > 0.5f)     
10.     {     
11.         int count = mJFsorket.worldpackage.Count;     
12.         //当接受到的数据包长度大于0 开始同步     
13.         if(count > 0)     
14.         {     
15.                                //遍历数据包中 每个点的坐标     
16.             foreach(JFPackage.WorldPackage wp in mJFsorket.worldpackage)     
17.             {     
18.                 float x = (float)(wp.mPosx / 100.0f);     
19.                 float y = (float)(wp.mPosy /100.0f);     
20.                 float z = (float)(wp.mPosz /100.0f);     
21.          
22.                 Debug.Log("x = " + x + " y = " + y+" z = " + z);     
23.                   //同步主角的新坐标     
24.                 mPlayer.transform.position = new Vector3 (x,y,z);     
25.             }     
26.                                //清空数据包链表     
27.             mJFsorket.worldpackage.Clear();     
28.         }     
29.         mSynchronous = 0;     
30.     }     
31. }  

主角移动的同时，通过Socket时时同步坐标喔。。有没有感觉这个牛头人非常帅气 哈哈哈。

对于Socket的使用，我相信没有比MSDN更加详细的了。 有关Socket 同步请求异步请求的地方可以参照MSDN  链接地址给出来了，好好学习吧，嘿嘿。http://msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.aspx

上述代码中我使用的是Thread() 没有使用协同任务StartCoroutine() ，原因是协同任务必需要继承MonoBehaviour，并且该脚本要绑定在游戏对象身上。问题绑定在游戏对象身上切换场景的时候这个脚本必然会释放，那 么Socket肯定会断开连接，所以我需要用Thread，并且协同任务它并不是严格意义上的多线程。

2.HTTP

HTTP请求在Unity我相信用的会更少一些，因为HTTP会比SOCKET慢很多，因为它每次请求完都会断开。废话不说了， 我用HTTP请求制作用户的登录。用HTTP请求直接使用Unity自带的www类就可以，因为HTTP请求只有登录才会有，所以我就在脚本中来完成， 使用 www 类 和 协同任务StartCoroutine()。

[c#] view plaincopy

1. using UnityEngine;     
2. using System.Collections;     
3. using System.Collections.Generic;     
4. public class LoginGlobe : MonoBehaviour {     
5.          
6.     void Start ()     
7.     {     
8.         //GET请求     
9.         StartCoroutine(GET("http://xuanyusong.com/"));     
10.          
11.     }     
12.          
13.     void Update ()     
14.     {     
15.          
16.     }     
17.          
18.     void OnGUI()     
19.     {     
20.          
21.     }     
22.          
23.     //登录     
24.     public void LoginPressed()     
25.     {     
26.         //登录请求 POST 把参数写在字典用 通过www类来请求     
27.         Dictionary<string,string> dic = new Dictionary<string, string> ();     
28.         //参数     
29.         dic.Add("action","0");     
30.         dic.Add("usrname","xys");     
31.         dic.Add("psw","123456");     
32.          
33.         StartCoroutine(POST("http://192.168.1.12/login.php",dic));     
34.          
35.     }     
36.     //注册     
37.     public void SingInPressed()     
38.     {     
39.         //注册请求 POST     
40.         Dictionary<string,string> dic = new Dictionary<string, string> ();     
41.         dic.Add("action","1");     
42.         dic.Add("usrname","xys");     
43.         dic.Add("psw","123456");     
44.          
45.         StartCoroutine(POST("http://192.168.1.12/login.php",dic));     
46.     }     
47.          
48.     //POST请求     
49.     IEnumerator POST(string url, Dictionary<string,string> post)     
50.     {     
51.         WWWForm form = new WWWForm();     
52.         foreach(KeyValuePair<string,string> post_arg in post)     
53.         {     
54.             form.AddField(post_arg.Key, post_arg.Value);     
55.         }     
56.          
57.         WWW www = new WWW(url, form);     
58.         yield return www;     
59.          
60.         if (www.error != null)     
61.         {     
62.             //POST请求失败     
63.             Debug.Log("error is :"+ www.error);     
64.          
65.         } else  
66.         {     
67.             //POST请求成功     
68.              Debug.Log("request ok : " + www.text);     
69.         }     
70.     }     
71.          
72.     //GET请求     
73.     IEnumerator GET(string url)     
74.     {     
75.          
76.         WWW www = new WWW (url);     
77.         yield return www;     
78.          
79.         if (www.error != null)     
80.         {     
81.             //GET请求失败     
82.             Debug.Log("error is :"+ www.error);     
83.          
84.         } else  
85.         {     
86.             //GET请求成功     
87.              Debug.Log("request ok : " + www.text);     
88.         }     
89.     }     
90.          
91. }  

如果想通过HTTP传递二进制流的话 可以使用 下面的方法。

[c#] view plaincopy

1. WWWForm wwwForm = new WWWForm();     
2.          
3.      byte[] byteStream = System.Text.Encoding.Default.GetBytes(stream);     
4.          
5.      wwwForm.AddBinaryData("post", byteStream);     
6.          
7.      www = new WWW(Address, wwwForm);  

目前Socket数据包还是没有进行加密算法，后期我会补上。欢迎讨论，互相学习互相进度 加油，蛤蛤。

下载地址我不贴了，因为没有服务端的东西运行也看不到效果。 希望大家学习愉快， 我们下次再见！