前一篇 《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
IList<Client> ClientList = new List<Client>();
Socket ServerSoket;
/// <summary>
/// 开始监听
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
ServerSoket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ServerSoket.Bind(new IPEndPoint(IPAddress.Any, 4518));//监听端口为4518
ServerSoket.Listen(100);//100是相对稳定连接队列数
ServerSoket.BeginAccept(new AsyncCallback(ClientConnectComplete), null);
OutPutMsg("服务器在端口4518开始监听");
}
ClientConnectComplete 代码：
ClientConnectComplete
private void ClientConnectComplete(IAsyncResult async)
{
Client client = new Client();
// 完成接受客户端传入的连接的这个异步操作，并返回客户端连入的 socket
try
{
client.Socket = ServerSoket.EndAccept(async);
}
catch (Exception)
{
return;
}
//把连接进来的客户端保存起来
ClientList.Add(client);
OutPutMsg(client.Socket.RemoteEndPoint + " 连接成功!");
try
{
// 开始异步接收客户端传入的数据
client.Socket.BeginReceive(client.Buffer, 0, client.Buffer.Length, SocketFlags.None, new AsyncCallback(ClientReceiveComplete), client);
}
catch (SocketException ex)
{
// 处理异常
}
ServerSoket.BeginAccept(new AsyncCallback(ClientConnectComplete), null);//继续接受下一个连接
}
ClientReceiveComplete代码：
ClientReceiveComplete
private void ClientReceiveComplete(IAsyncResult async)
{
Client client = async.AsyncState as Client;
int _receiveCount = 0;//用于统计本次接收到的字节数
try
{
// 完成接收数据的这个异步操作，并返回接收的字节数
if (client.Socket.Connected)
{
_receiveCount = client.Socket.EndReceive(async);
}
else
{
}
}
catch (SocketException ex)
{
// 处理异常
}
char startChar = System.BitConverter.ToChar(client.Buffer, 0);//获取到包头
Int16 msgType = System.BitConverter.ToInt16(client.Buffer, 2);//获取到消息类型
Int32 dataSize = System.BitConverter.ToInt32(client.Buffer, 4);//获取到包长度
char endtChar = System.BitConverter.ToChar(client.Buffer, dataSize-2);//获取到包尾
//验证数据包的正确性
if (startChar.Equals(Convert.ToChar(2)) && endtChar.Equals(Convert.ToChar(3)))
{
//数据验证成功输出信息
OutPutMsg(client.Socket.RemoteEndPoint + "数据验证成功。");
string receivedContent = UTF32Encoding.UTF8.GetString(client.Buffer,8, dataSize - 10);//获取到数据内容
OutPutMsg("接收到的数据内容是：" + receivedContent);
//服务器应答机制，制造回发给客户端消息
byte[] sendMsg = GetSendMsg(UTF32Encoding.UTF8.GetBytes("服务器发回数据:" + receivedContent),2);
try
{
//发送给所有客户端
foreach (var clientItem in ClientList)
{
clientItem.Socket.BeginSend(sendMsg, 0, sendMsg.Length, SocketFlags.None, new AsyncCallback(SendToClientComplete), clientItem);
}
}
catch (Exception ex)
{
OutPutMsg(ex.Message);
}
}
try
{
//继续开始接收客户端传入的数据
if (client.Socket.Connected)
{
client.Socket.BeginReceive(client.Buffer, 0, client.Buffer.Length, 0, new AsyncCallback(ClientReceiveComplete), client);
}
}
catch (SocketException ex)
{
// 处理异常
}
}
这里数据接收以及验证数据都是比较简单粗略的，没有考虑掉包拆包复杂的数据验证等等。
SendToClientComplete代码：
SendToClientComplete
private void SendToClientComplete(IAsyncResult async)
{
Client client = async.AsyncState as Client;
try
{
// 完成将信息发送到客户端的这个异步操作
if (client.Socket.Connected)
{
client.Socket.EndSend(async);
}
}
catch (SocketException ex)
{
// 处理异常
}
OutPutMsg("服务器数据回发完毕。");
}
OutPutMsg代码：
OutPutMsg
/// <summary>
/// 正常消息输出
/// </summary>
/// <param name="msg"></param>
private void OutPutMsg(string msg)
{
this.BeginInvoke(new System.EventHandler(AddToList), msg);
}
AddToList代码：
AddToList
/// <summary>
/// 添加到窗体列表显示
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AddToList(object sender, EventArgs e)
{
this.listBox1.Items.Add(sender.ToString());
try
{
this.listBox1.SelectedIndex = this.listBox1.Items.Count - 1;
}
catch (Exception)
{
//throw;
}
if (this.listBox1.Items.Count > 100)
{
this.listBox1.Items.RemoveAt(0);
}
}
GetSendMsg代码：
/// <summary>
/// 组装消息包
/// </summary>
/// <param name="BArr">内容字节流</param>
/// <param name="MsgType">消息类型</param>
/// <returns></returns>
private byte[] GetSendMsg(byte[] BArr, Int16 MsgType)
{
//数据包格式为 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
//开始字节流 包头
byte[] bs = System.BitConverter.GetBytes(Convert.ToChar(2));
//结束字节流 包尾
byte[] be = System.BitConverter.GetBytes(Convert.ToChar(3));
//消息体类型
byte[] b1 = System.BitConverter.GetBytes(MsgType);
//总长度
int size = BArr == null ? 10 : BArr.Length + 10;
byte[] b2 = System.BitConverter.GetBytes(size);
byte[] b = new byte[size];
Array.Copy(bs, 0, b, 0, bs.Length);
Array.Copy(b1, 0, b, 2, b1.Length);
Array.Copy(b2, 0, b, 4, b2.Length);
if (BArr != null)
{
Array.Copy(BArr, 0, b, 8, BArr.Length);
}
Array.Copy(be, 0, b, size - 2, be.Length);
return b;
}
这个方法需要讲解下。前一篇博文我已经说到，做原异步socket通信时需要设计的数据包格式。
我的数据包格式 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
当然METRO APP 通信时也是需要设计数据包的，只是数据长度可以单独出来。
class Client 代码：
class Client
public class Client
{
/// <summary>
/// 客户端 Socket
/// </summary>
public Socket Socket { get; set; }
private byte[] _buffer;
/// <summary>
/// 为该客户端 Socket 开辟的缓冲区
/// </summary>
public byte[] Buffer
{
get
{
if (_buffer == null)
_buffer = new byte[102400];
return _buffer;
}
}
}
到这里简单的原异步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
StreamSocket sk = new StreamSocket();
private async void Button_Click_1(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
await sk.ConnectAsync(new HostName("127.0.0.1"), "4518");
await ShowMsg("发送连接完毕。");
if (sk.Information!= null)
{
await BeginReceived();
}
}
这段代码我就不解释了，看过前一篇的朋友应该都懂。
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[2];
//将刚才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];
//在读取下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[contentByteLenth];
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个字节的包头来做是否有数据的判断。
接下来的代码：
//临时处理读取器 的字节流数组
byte[] tempByteArr;
tempByteArr = new byte[2];
//将刚才reader读取到的数据填充到tempByteArr
reader.ReadBytes(tempByteArr);
char startChar = System.BitConverter.ToChar(tempByteArr, 0);//获取到包头
//如果不是包头
if (!startChar.Equals(Convert.ToChar(2)))
{
return;
}
定义一个临时的字节数组 tempByteArr 且数组大小与需要读取到的数据长度一样。
DataReader.ReadBytes()方法是根据传入的字节数组长度读取数据的。
所以接下来的代码：
//再读取下2个字节
await reader.LoadAsync(sizeof(UInt16));
reader.ReadBytes(tempByteArr);
Int16 msgType = System.BitConverter.ToInt16(tempByteArr,0);//获取到消息类型
await ShowMsg("获取到的消息类型：" + msgType.ToString());
tempByteArr = new byte[4];
//再读取下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[contentByteLenth];
reader.ReadBytes(tempByteArr);
await ShowMsg(System.Text.UnicodeEncoding.UTF8.GetString(tempByteArr, 0, int.Parse(contentByteLenth.ToString())));
我们读取到包长度后就能顺利的得到我们的消息内容了。
接下来的Button2 发送信息 代码：
Button_Click_2
DataWriter writer;
private async void Button_Click_2(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
if (this.SendText.Text != string.Empty)
{
if (writer == null)
{
writer = new DataWriter(sk.OutputStream);
}
//需要发送的数据
byte[] sendMsg = GetSendMsg(System.Text.UnicodeEncoding.UTF8.GetBytes(this.SendText.Text), 1);
//把数据写入到发送流
writer.WriteBytes(sendMsg);
//异步发送
await writer.StoreAsync();
}
}
ShowMsg GetSendMsg 代码：
ShowMsg GetSendMsg
protected async Task ShowMsg(string s)
{
MsgList.Items.Insert(0, s);
}
/// <summary>
/// 组装消息包
/// </summary>
/// <param name="BArr">内容字节流</param>
/// <param name="MsgType">消息类型</param>
/// <returns></returns>
private byte[] GetSendMsg(byte[] BArr, Int16 MsgType)
{
//数据包格式为 包头 + 消息类型 + 包长度 + 消息内容 + 包尾
//开始字节流 包头
byte[] bs = System.BitConverter.GetBytes(Convert.ToChar(2));
//结束字节流 包尾
byte[] be = System.BitConverter.GetBytes(Convert.ToChar(3));
//消息体类型
byte[] b1 = System.BitConverter.GetBytes(MsgType);
//总长度
int size = BArr == null ? 10 : BArr.Length + 10;
byte[] b2 = System.BitConverter.GetBytes(size);
byte[] b = new byte[size];
Array.Copy(bs, 0, b, 0, bs.Length);
Array.Copy(b1, 0, b, 2, b1.Length);
Array.Copy(b2, 0, b, 4, b2.Length);
if (BArr != null)
{
Array.Copy(BArr, 0, b, 8, BArr.Length);
}
Array.Copy(be, 0, b, size - 2, be.Length);
return b;
}
到这里基本解答了
在“原有的异步Socket”连接方式与现在WIN8 Metro App 的StreamSocket 如何通信呢？
StreamSocket在原有的数据包格式如何读取到数据？（没有DataWriter.WriteUInt32()，DataReader.ReadUInt32();）
WIN8 Metro App 如何像之前的Silverlight一样与服务器进行异步收发数据（问答数据）？