Windows 8 Metro 关于StreamSocket与原异步Socket
前一篇 《Windows 8 Metro 关于 StreamSocket MSDN示例阅读》我们基本懂得如何通过StreamSocket 做监听、连接、发送接收数据。同时前一篇留下的几个疑问，我们在这里进行实验和解答。
在“原有的异步Socket”连接方式与现在WIN8 Metro App 的StreamSocket 如何通信呢？
首先解释下这里说的“原有的异步Socket” 是什么。
在await/async 关键字出现前，我们的Socket异步是依靠System.Net 以及 System.Net.Sockets 命名空间下的类与方法实现的。
请求连接BeginConnect/ConnectAsync 接受连接 BeginAccept/AcceptAsync 发送信息BeginSend/SendAsyn 收信息BeginReceive/ReceiveAsync
上面列举的都是Socket类下的异步操作主要方法。这就是前面文章说的“原有的异步Socket”。
前一篇里还有两个问题分别是
StreamSocket在原有的数据包格式如何读取到数据？（没有DataWriter.WriteUInt32()，DataReader.ReadUInt32();）
WIN8 Metro App 如何像之前的Silverlight一样与服务器进行异步收发数据（问答数据）？
这几个问题我想用一个相对简单合适的示例来讲解。
所以我们先来设定一下场景。
我现在面对的情况是，已经有使用原异步Socket的成熟服务器程序以及解决方案了。
这个解决方案可能会用于各种客户端的连接，比如 FLASH客户端 Silverlight客户端 WINFORM客户端 HTML5客户端 等等。
现在我们需要增加一个WIN8 metro APP 的客户端。但是我们不希望重新开发服务器端的东西。
于是乎我们就有了WIN8 metro APP 与 原异步Socket 连接收发信息的需求。
首先是服务器方面的一些主要代码：（如果您之前已经做了很多可以忽略这一部分）
首先建立一个WINFORM工程然后在默认的FORM1上添加一个LISTBOX 和一个 Button 控件
然后转到后台代码。
声明一个Socket 以及一个存储客户端的LIST。 添加Button Click事件代码：
button1_Click
1 IList ClientList = new List();
2 Socket ServerSoket;
3 ///
4 /// 开始监听
5 ///
6 ///
7 ///
8 private void button1_Click(object sender, EventArgs e)
9 {
10 ServerSoket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
11 ServerSoket.Bind(new IPEndPoint(IPAddress.Any, 4518));//监听端口为4518
12 ServerSoket.Listen(100);//100是相对稳定连接队列数
13 ServerSoket.BeginAccept(new AsyncCallback(ClientConnectComplete), null);
14 OutPutMsg("服务器在端口4518开始监听");
15 }
ClientConnectComplete 代码：
ClientConnectComplete
1 private void ClientConnectComplete(IAsyncResult async)
2 {
3 Client client = new Client();
4
5 // 完成接受客户端传入的连接的这个异步操作，并返回客户端连入的 socket
6 try
7 {
8 client.Socket = ServerSoket.EndAccept(async);
9 }
10 catch (Exception)
11 {
12
13 return;
14 }
15
16 //把连接进来的客户端保存起来
17 ClientList.Add(client);
18
19 OutPutMsg(client.Socket.RemoteEndPoint + " 连接成功!");
20
21 try
22 {
23 // 开始异步接收客户端传入的数据
24 client.Socket.BeginReceive(client.Buffer, 0, client.Buffer.Length, SocketFlags.None, new AsyncCallback(ClientReceiveComplete), client);
25 }
26 catch (SocketException ex)
27 {
28 // 处理异常
29 }
30
31 ServerSoket.BeginAccept(new AsyncCallback(ClientConnectComplete), null);//继续接受下一个连接
32 }
ClientReceiveComplete代码：
ClientReceiveComplete
1 private void ClientReceiveComplete(IAsyncResult async)
2 {
3 Client client = async.AsyncState as Client;
4
5 int _receiveCount = 0;//用于统计本次接收到的字节数
6
7 try
8 {
9 // 完成接收数据的这个异步操作，并返回接收的字节数
10 if (client.Socket.Connected)
11 {
12 _receiveCount = client.Socket.EndReceive(async);
13 }
14 else
15 {
16 }
17 }
18 catch (SocketException ex)
19 {
20 // 处理异常
21 }
22
23 char startChar = System.BitConverter.ToChar(client.Buffer, 0);//获取到包头
24 Int16 msgType = System.BitConverter.ToInt16(client.Buffer, 2);//获取到消息类型
25 Int32 dataSize = System.BitConverter.ToInt32(client.Buffer, 4);//获取到包长度
26 char endtChar = System.BitConverter.ToChar(client.Buffer, dataSize-2);//获取到包尾
27
28 //验证数据包的正确性
29 if (startChar.Equals(Convert.ToChar(2)) && endtChar.Equals(Convert.ToChar(3)))
30 {
31 //数据验证成功输出信息
32 OutPutMsg(client.Socket.RemoteEndPoint + "数据验证成功。");
33 string receivedContent = UTF32Encoding.UTF8.GetString(client.Buffer,8, dataSize - 10);//获取到数据内容
34 OutPutMsg("接收到的数据内容是：" + receivedContent);
35
36 //服务器应答机制，制造回发给客户端消息
37 byte[] sendMsg = GetSendMsg(UTF32Encoding.UTF8.GetBytes("服务器发回数据:" + receivedContent),2);
38
39 try
40 {
41 //发送给所有客户端
42 foreach (var clientItem in ClientList)
43 {
44 clientItem.Socket.BeginSend(sendMsg, 0, sendMsg.Length, SocketFlags.None, new AsyncCallback(SendToClientComplete), clientItem);
45 }
46
47 }
48 catch (Exception ex)
49 {
50
51 OutPutMsg(ex.Message);
52 }
53 }
54
55 try
56 {
57 //继续开始接收客户端传入的数据
58 if (client.Socket.Connected)
59 {
60 client.Socket.BeginReceive(client.Buffer, 0, client.Buffer.Length, 0, new AsyncCallback(ClientReceiveComplete), client);
61 }
62 }
63 catch (SocketException ex)
64 {
65 // 处理异常
66 }
67 }
这里数据接收以及验证数据都是比较简单粗略的，没有考虑掉包拆包复杂的数据验证等等。
SendToClientComplete代码：
SendToClientComplete
1 private void SendToClientComplete(IAsyncResult async)
2 {
3 Client client = async.AsyncState as Client;
4 try
5 {
6 // 完成将信息发送到客户端的这个异步操作
7 if (client.Socket.Connected)
8 {
9 client.Socket.EndSend(async);
10 }
11 }
12 catch (SocketException ex)
13 {
14 // 处理异常
15 }
16 OutPutMsg("服务器数据回发完毕。");
17 }
OutPutMsg代码：
OutPutMsg
1 ///
2 /// 正常消息输出
3 ///
4 ///
5 private void OutPutMsg(string msg)
6 {
7 this.BeginInvoke(new System.EventHandler(AddToList), msg);
8 }
AddToList代码：
AddToList
1///
2 /// 添加到窗体列表显示
3 ///
4 ///
5 ///
6 private void AddToList(object sender, EventArgs e)
7 {
8 this.listBox1.Items.Add(sender.ToString());
9 try
10 {
11 this.listBox1.SelectedIndex = this.listBox1.Items.Count - 1;
12 }
13 catch (Exception)
14 {
15 //throw;
16 }
17
18 if (this.listBox1.Items.Count > 100)
19 {
20 this.listBox1.Items.RemoveAt(0);
21 }
22 }
GetSendMsg代码：
1 ///
2 /// 组装消息包
3 ///
4 /// 内容字节流
5 /// 消息类型
6 ///
7 private byte[] GetSendMsg(byte[] BArr, Int16 MsgType)
8 {
9 //数据包格式为 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
10 //开始字节流 包头
11 byte[] bs = System.BitConverter.GetBytes(Convert.ToChar(2));
12 //结束字节流 包尾
13 byte[] be = System.BitConverter.GetBytes(Convert.ToChar(3));
14 //消息体类型
15 byte[] b1 = System.BitConverter.GetBytes(MsgType);
16
17 //总长度
18 int size = BArr == null ? 10 : BArr.Length + 10;
19
20 byte[] b2 = System.BitConverter.GetBytes(size);
21
22
23 byte[] b = new byte;
24
25 Array.Copy(bs, 0, b, 0, bs.Length);
26 Array.Copy(b1, 0, b, 2, b1.Length);
27 Array.Copy(b2, 0, b, 4, b2.Length);
28 if (BArr != null)
29 {
30 Array.Copy(BArr, 0, b, 8, BArr.Length);
31 }
32 Array.Copy(be, 0, b, size - 2, be.Length);
33
34
35 return b;
36
37 }
这个方法需要讲解下。前一篇博文我已经说到，做原异步socket通信时需要设计的数据包格式。
我的数据包格式 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
当然METRO APP 通信时也是需要设计数据包的，只是数据长度可以单独出来。
class Client 代码：
class Client
1 public class Client
2 {
3 ///
4 /// 客户端 Socket
5 ///
6 public Socket Socket { get; set; }
7
8 private byte[] _buffer;
9 ///
10 /// 为该客户端 Socket 开辟的缓冲区
11 ///
12 public byte[] Buffer
13 {
14 get
15 {
16 if (_buffer == null)
17 _buffer = new byte;
18
19 return _buffer;
20 }
21 }
22 }
到这里简单的原异步socket服务器就设计完毕了。
服务器做的事情：接收连接放入客户端列表，接收客户端发来的数据验证处理并回发给所有客户端。
现在我们看看WIN8 METRO APP 的 设计。
首先新建一个 Windows 应用商店 空应用程序。
使用Blend + SketchFlow Preview for Visual Studio 2012 打开工程。
在默认的MainPage.xaml 里添加 两个 button，一个 TextBox， 一个ListBox 控件。
在第一个Button事件内我们写入StreamSocket 的连接以及对已连接上的StreamSocket 实例进行消息监听。
Button_Click_1代码：
Button_Click_1
1 StreamSocket sk = new StreamSocket();
2 private async void Button_Click_1(object sender, Windows.UI.Xaml.RoutedEventArgs e)
3 {
4
5 await sk.ConnectAsync(new HostName("127.0.0.1"), "4518");
6 await ShowMsg("发送连接完毕。");
7
8 if (sk.Information!= null)
9 {
10 await BeginReceived();
11 }
12
13 }
这段代码我就不解释了，看过前一篇的朋友应该都懂。
BeginReceived 代码：
BeginReceived
private async Task BeginReceived()
{
//绑定已连接的StreamSocket到DataReader
DataReader reader = new DataReader(sk.InputStream);
while (true)
{
try
{
//尝试从StreamSocket 读取到数据 读取2个字节的数据（包头）
uint sizeFieldCount = await reader.LoadAsync(sizeof(UInt16));
if (sizeFieldCount != sizeof(UInt16))
{
return;
}
}
catch (Exception exception)
{
return;
}
//临时处理读取器 的字节流数组
byte[] tempByteArr;
tempByteArr = new byte;
//将刚才reader读取到的数据填充到tempByteArr
reader.ReadBytes(tempByteArr);
char startChar = System.BitConverter.ToChar(tempByteArr, 0);//获取到包头
//如果不是包头
if (!startChar.Equals(Convert.ToChar(2)))
{
return;
}
//在读取下2个字节
await reader.LoadAsync(sizeof(UInt16));
reader.ReadBytes(tempByteArr);
Int16 msgType = System.BitConverter.ToInt16(tempByteArr,0);//获取到消息类型
await ShowMsg("获取到的消息类型：" + msgType.ToString());
tempByteArr = new byte;
//在读取下4个字节
await reader.LoadAsync(sizeof(uint));
reader.ReadBytes(tempByteArr);
uint dataSize = System.BitConverter.ToUInt32(tempByteArr, 0);//获取到包长度
await ShowMsg("获取到的数据包长度：" + dataSize.ToString());
uint contentByteLenth = dataSize - 8;//内容字节流长度
//根据长度读取内容字节流
uint actualStringLength = await reader.LoadAsync(contentByteLenth);
if (contentByteLenth != actualStringLength)
{
//内容数据流未发送完成
await ShowMsg("内容数据流未发送完成");
return;
}
//填充
tempByteArr = new byte;
reader.ReadBytes(tempByteArr);
await ShowMsg(System.Text.UnicodeEncoding.UTF8.GetString(tempByteArr, 0, int.Parse(contentByteLenth.ToString())));
}
}
BeginReceived方法内我们用一个 DataReader 绑定已经连接上的StreamSocket 实例的InputStream
然后我们利用循环进行监听，监听时需要进行初步的数据读取以便查看是否有数据到达。
我讲解一下BeginReceived内的代码。因为这是这篇博文比较重要的部分。
代码：
try
{
//尝试从StreamSocket 读取到数据 读取2个字节的数据（包头）
uint sizeFieldCount = await reader.LoadAsync(sizeof(UInt16));
if (sizeFieldCount != sizeof(UInt16))
{
return;
}
}
catch (Exception exception)
{
return;
}
这里要说下为什么要读取 2个字节的数据长度来做验证呢？
前面的服务器设计里我们数据包的格式包头就是2个字节。
DataReader.LoadAsync() 方法的机制是：
从StreamSocket的InputStream读取一定长度的数据字节数到DataReader内，且读取完毕后InputStream内被读取到的数据将被删除。
所以我这里用读取2个字节的包头来做是否有数据的判断。
接下来的代码：
1 //临时处理读取器 的字节流数组
2 byte[] tempByteArr;
3 tempByteArr = new byte;
4
5 //将刚才reader读取到的数据填充到tempByteArr
6 reader.ReadBytes(tempByteArr);
7
8 char startChar = System.BitConverter.ToChar(tempByteArr, 0);//获取到包头
9 //如果不是包头
10 if (!startChar.Equals(Convert.ToChar(2)))
11 {
12 return;
13 }
定义一个临时的字节数组 tempByteArr 且数组大小与需要读取到的数据长度一样。
DataReader.ReadBytes()方法是根据传入的字节数组长度读取数据的。
所以接下来的代码：
1 //再读取下2个字节
2 await reader.LoadAsync(sizeof(UInt16));
3 reader.ReadBytes(tempByteArr);
4 Int16 msgType = System.BitConverter.ToInt16(tempByteArr,0);//获取到消息类型
5 await ShowMsg("获取到的消息类型：" + msgType.ToString());
6
7 tempByteArr = new byte;
8 //再读取下4个字节
9 await reader.LoadAsync(sizeof(uint));
10 reader.ReadBytes(tempByteArr);
11 uint dataSize = System.BitConverter.ToUInt32(tempByteArr, 0);//获取到包长度
12 await ShowMsg("获取到的数据包长度：" + dataSize.ToString());
13
14 uint contentByteLenth = dataSize - 8;//内容字节流长度
15 //根据长度读取内容字节流
16 uint actualStringLength = await reader.LoadAsync(contentByteLenth);
17 if (contentByteLenth != actualStringLength)
18 {
19 //内容数据流未发送完成
20 await ShowMsg("内容数据流未发送完成");
21 return;
22 }
23
24 //填充
25 tempByteArr = new byte;
26 reader.ReadBytes(tempByteArr);
27
28 await ShowMsg(System.Text.UnicodeEncoding.UTF8.GetString(tempByteArr, 0, int.Parse(contentByteLenth.ToString())));
我们读取到包长度后就能顺利的得到我们的消息内容了。
接下来的Button2 发送信息 代码：
Button_Click_2
1 DataWriter writer;
2 private async void Button_Click_2(object sender, Windows.UI.Xaml.RoutedEventArgs e)
3 {
4 if (this.SendText.Text != string.Empty)
5 {
6 if (writer == null)
7 {
8 writer = new DataWriter(sk.OutputStream);
9 }
10
11 //需要发送的数据
12 byte[] sendMsg = GetSendMsg(System.Text.UnicodeEncoding.UTF8.GetBytes(this.SendText.Text), 1);
13
14 //把数据写入到发送流
15 writer.WriteBytes(sendMsg);
16
17 //异步发送
18 await writer.StoreAsync();
19
20 }
21 }
ShowMsg GetSendMsg 代码：
ShowMsg GetSendMsg
1 protected async Task ShowMsg(string s)
2 {
3 MsgList.Items.Insert(0, s);
4 }
5
6 ///
7 /// 组装消息包
8 ///
9 /// 内容字节流
10 /// 消息类型
11 ///
12 private byte[] GetSendMsg(byte[] BArr, Int16 MsgType)
13 {
14 //数据包格式为 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
15 //开始字节流 包头
16 byte[] bs = System.BitConverter.GetBytes(Convert.ToChar(2));
17 //结束字节流 包尾
18 byte[] be = System.BitConverter.GetBytes(Convert.ToChar(3));
19 //消息体类型
20 byte[] b1 = System.BitConverter.GetBytes(MsgType);
21
22 //总长度
23 int size = BArr == null ? 10 : BArr.Length + 10;
24
25 byte[] b2 = System.BitConverter.GetBytes(size);
26
27
28 byte[] b = new byte;
29
30 Array.Copy(bs, 0, b, 0, bs.Length);
31 Array.Copy(b1, 0, b, 2, b1.Length);
32 Array.Copy(b2, 0, b, 4, b2.Length);
33 if (BArr != null)
34 {
35 Array.Copy(BArr, 0, b, 8, BArr.Length);
36 }
37 Array.Copy(be, 0, b, size - 2, be.Length);
38
39
40 return b;
41
42 }
到这里基本解答了
在“原有的异步Socket”连接方式与现在WIN8 Metro App 的StreamSocket 如何通信呢？
StreamSocket在原有的数据包格式如何读取到数据？（没有DataWriter.WriteUInt32()，DataReader.ReadUInt32();）
WIN8 Metro App 如何像之前的Silverlight一样与服务器进行异步收发数据（问答数据）？
最后给上 示例的源码：点击这里下载
国际惯例如果您看得起鄙人，转载请注明出处谢谢。
页:
[1]