C# PeerFinder不稳定性

这是我第一次在堆栈溢出上发表文章，因为我总是在将问题发布到网站之前在网络上搜索。然而，两周多以来，我一直坚持应用程序功能

背景： 操作系统：Windows 8.1 目标：目前，戴尔场馆11 pro（2014年9月1日起提供WiFi驱动程序），但最终目标是戴尔场馆8 pro 语言：.NET 4.5.1（C） 应用程序类型：WinRT商店应用程序

目标是： 我想设计一个应用程序，可以通过WiFi直接连接到另一个应用程序，以便传输消息（字节数据）。 我使用DistacherTimer（每4个）处理所有PeerFinder步骤。 以下是Dispatchermer方法的步骤： 1-浏览对等点（我使用wait PeerFinder.FindAllPeerAsync（）；） 2-接受来自请求对等方的连接：打开1个连接，接收消息，然后关闭连接。使用PeerFinder的ConnectionRequested事件在可观察集合中注册请求的对等方。 3-存储在队列中的SendMessage：对于浏览的对等方中的每个对等方=>connect、send、close（一次一个）

我的问题是： 当我在两个平板电脑上启动应用程序时，第一条消息成功传输。但是，我无法发送另一个，因为我遇到了许多不同的错误：连接超时、连接被拒绝、设备或资源未处于正确状态、设备未正确连接

我不明白问题出在哪里。我尝试了很多东西。 以下是代码示例：

//Code used for accept the connection of one peer and receive message
using (var socket = await PeerFinder.ConnectAsync(peer))
{
    if (socket != null)
    {
        DisplayStatus("Connection Accepted...");

        var message = NetworkMessage.Deserialize(await _socketHelper.ReceiveMessage(socket));
        message.SenderId = peer.Id;
        OnReceiveMessage(message);

        socket.Dispose();
    }
}

//Code used for connecting to a peer and send message
using (var socket = await PeerFinder.ConnectAsync(pPeerInformation))
{
    var messageData = NetworkMessage.Serialize(pMessage);

    DisplayStatus("Sending message...");
    success = await _socketHelper.SendMessage(messageData, socket, pMessage.Id);

    socket.Dispose();
}

//Code used for receiving the data
//pSocket is the socket defined by PeerFinder.ConnectAsync
using (var socketWriter = new Windows.Storage.Streams.DataWriter(pSocket.OutputStream))
{
    using (var socketReader = new Windows.Storage.Streams.DataReader(pSocket.InputStream))
    {
        OnDownloadProgressChangeEvent(new DownloadProgressArgs(0, 4, "Accept connection"));
        socketWriter.WriteByte(1);
        await socketWriter.StoreAsync();
        await socketWriter.FlushAsync();


        OnDownloadProgressChangeEvent(new DownloadProgressArgs(1, 4, "Waiting for message ID"));
        var count = await socketReader.LoadAsync(16);
        if (count == 0)
        {
            socketWriter.WriteByte(0);
            await socketWriter.StoreAsync();
            await socketWriter.FlushAsync();                                
            return new byte[0];
         }
         var dataId = new byte[16];
         socketReader.ReadBytes(dataId);

         if (IdLogs.Contains(dataId))
         {
             socketWriter.WriteByte(100);
             OnDownloadProgressChangeEvent(new DownloadProgressArgs(4, 4, "Message already receive, closing connection"));
             await socketWriter.StoreAsync();
             await socketWriter.FlushAsync();
             return new byte[0];
          }

          IdLogs.Add(dataId);

          OnDownloadProgressChangeEvent(new DownloadProgressArgs(2, 4, "Accepting message"));
          socketWriter.WriteByte(2);
          await socketWriter.StoreAsync();
          await socketWriter.FlushAsync();

          OnDownloadProgressChangeEvent(new DownloadProgressArgs(2, 4, "Waiting for message size"));
          count = await socketReader.LoadAsync(sizeof(uint));
          if (count == 0)
          {
              socketWriter.WriteByte(0);
              await socketWriter.StoreAsync();
              await socketWriter.FlushAsync();
              return new byte[0];
          }

          var size = socketReader.ReadUInt32();

          OnDownloadProgressChangeEvent(new DownloadProgressArgs(3, 4, "Size : " + size));
          socketWriter.WriteByte(3);
          await socketWriter.StoreAsync();
          await socketWriter.FlushAsync();

          OnDownloadProgressChangeEvent(new DownloadProgressArgs(4, 4, "Downloading message"));

          uint sum = 0;
          var totalData = new List<byte>();
          while (sum < size)
          {
              count = await socketReader.LoadAsync(size);
              if (count == 0)
              {
                  socketWriter.WriteByte(0);
                  await socketWriter.StoreAsync();
                  await socketWriter.FlushAsync();
                  return new byte[0];
              }

              var tempData = new byte[count];
              socketReader.ReadBytes(tempData);

              sum += count;

              totalData.AddRange(tempData);

              OnDownloadProgressChangeEvent(new DownloadProgressArgs(sum, size, "Data downloaded"));
          }

          OnDownloadProgressChangeEvent(new DownloadProgressArgs(4, 4, "Download finished"));
          socketWriter.WriteByte(4);
          await socketWriter.StoreAsync();
          await socketWriter.FlushAsync();

          socketReader.DetachStream();
          socketWriter.DetachStream();

          socketWriter.Dispose();
          socketReader.Dispose();

          return totalData.ToArray();
      }
 }

 //Code used to send data
 //pSocket is the socket defined by PeerFinder.ConnectAsync
 using (var socketWriter = new Windows.Storage.Streams.DataWriter(pSocket.OutputStream))
 {
     using (var socketReader = new Windows.Storage.Streams.DataReader(pSocket.InputStream))
     {
         OnDownloadProgressChangeEvent(new DownloadProgressArgs(0, 4, "Waiting for connection acceptance"));
         var signal = await ReadSignal(socketReader);
         if (signal != 1)
         {
             return false;
         }

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(1, 4, "Sending ID"));
         socketWriter.WriteBytes(pId);
         await socketWriter.StoreAsync();
         await socketWriter.FlushAsync();

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(1, 4, "Waiting for ID acceptance"));
         signal = await ReadSignal(socketReader);
         if (signal != 2)
         {
             return false;
         }
         else if (signal == 100)
         {
             OnDownloadProgressChangeEvent(new DownloadProgressArgs(1, 4, "Message already managed by peer"));
             return true;
         }

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(2, 4, "Sending data size"));
         socketWriter.WriteUInt32((uint)pData.Length);
         await socketWriter.StoreAsync();
         await socketWriter.FlushAsync();

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(2, 4, "Waiting for size acceptance"));
         signal = await ReadSignal(socketReader);
         if (signal != 3)
         {
             return false;
         }

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(3, 4, "Sending data"));
         socketWriter.WriteBytes(pData);
         await socketWriter.StoreAsync();
         await socketWriter.FlushAsync();

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(3, 4, "Waiting for data acceptance"));
         signal = await ReadSignal(socketReader);
         if (signal != 4)
         {
             return false;
         }

         OnDownloadProgressChangeEvent(new DownloadProgressArgs(4, 4, "Sending completed"));

         socketReader.DetachStream();
         socketWriter.DetachStream();

         socketWriter.Dispose();
         socketReader.Dispose();

         return true;
     }
 }

//用于接受一个对等方的连接并接收消息的代码
使用（var socket=await PeerFinder.ConnectAsync（对等））
{
if（套接字！=null）
{
显示状态（“已接受连接…”）；
var message=NetworkMessage.Deserialize（wait_socketHelper.ReceiveMessage（socket））；
message.SenderId=peer.Id；
OnReceiveMessage（消息）；
socket.Dispose（）；
}
}
//用于连接到对等方并发送消息的代码
使用（var socket=await PeerFinder.ConnectAsync（pPeerInformation））
{
var messageData=NetworkMessage.Serialize（pMessage）；
显示状态（“发送消息…”）；
success=wait _socketHelper.SendMessage（messageData，socket，pMessage.Id）；
socket.Dispose（）；
}
//用于接收数据的代码
//pSocket是由PeerFinder.ConnectAsync定义的套接字
使用（var socketWriter=new Windows.Storage.Streams.DataWriter（pSocket.OutputStream））
{
使用（var socketReader=newwindows.Storage.Streams.DataReader（pSocket.InputStream））
{
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（0,4，“接受连接”））；
socketWriter.WriteByte（1）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（1,4，“等待消息ID”）；
var count=await socketReader.LoadAsync（16）；
如果（计数=0）
{
socketWriter.WriteByte（0）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
返回新字节[0]；
}
var dataId=新字节[16]；
socketReader.ReadBytes（数据ID）；
if（IdLogs.Contains（dataId））
{
socketWriter.WriteByte（100）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（4,4，“消息已收到，关闭连接”）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
返回新字节[0]；
}
添加（dataId）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（2,4，“接受消息”））；
socketWriter.WriteByte（2）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（2,4，“等待消息大小”）；
count=wait socketReader.LoadAsync（sizeof（uint））；
如果（计数=0）
{
socketWriter.WriteByte（0）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
返回新字节[0]；
}
var size=socketReader.ReadUInt32（）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（3,4，“大小：”+Size））；
socketWriter.WriteByte（3）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（4,4，“下载消息”））；
单位和=0；
var totalData=新列表（）；
while（总和<大小）
{
计数=等待socketReader.LoadAsync（大小）；
如果（计数=0）
{
socketWriter.WriteByte（0）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
返回新字节[0]；
}
var tempData=新字节[计数]；
socketReader.ReadBytes（tempData）；
总和+=计数；
totalData.AddRange（tempData）；
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（总和、大小、“下载数据”））；
}
OnDownloadProgressChangeEvent（新的DownloadProgressArgs（4,4，“下载完成”）；
socketWriter.WriteByte（4）；
等待socketWriter.StoreAsync（）；
等待socketWriter.FlushAsync（）；
socketReader.DetachStream（）；
socketWriter.DetachStream（）；
socketWriter.Dispose（）；
socketReader.Dispose（）；
返回totalData.ToArray（）；
}
}
//用于发送数据的代码
//pSocket是由PeerFinder.ConnectAsync定义的套接字
使用（var socketWriter=new Windows.Storage.Streams.DataWriter（pSocket.OutputStream））
{
使用（var socketReader=newwindows.Storage.Streams.DataReader（pSocket.InputStream））
{
OnDownloadProgressChangeEvent（新下载程序