Как использовать UdpClient.BeginReceive в цикле

Казалось бы, UdpClient.BeginReceive() и UdpClient.EndReceive() плохо реализованы/понятны. И, конечно же, по сравнению с тем, как реализован TcpListener, их намного сложнее использовать.

Есть несколько вещей, которые вы можете сделать, чтобы использование UdpClient.Receive() работало на вас лучше. Во-первых, установка тайм-аутов на базовом клиенте сокета позволит пропустить управление (к исключению), позволяя потоку управления продолжаться или зацикливаться, как вам нравится. Во-вторых, создав прослушиватель UDP в новом потоке (создание которого я не показывал), вы можете избежать полублокирующего эффекта функции UdpClient.Receive() и эффективно прервать этот поток позже, если сделаете это правильно.

Код ниже состоит из трех частей. Первая и последняя части должны быть в вашем основном цикле в точках входа и выхода соответственно. Вторая часть должна быть в новом потоке, который вы создали.

Простой пример:

// Define this globally, on your main thread
UdpClient listener = null;
// ...


// ...
// Create a new thread and run this code:

IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 9999);
byte[] data = new byte[0];
string message = "";

listener.Client.SendTimeout = 5000;
listener.Client.ReceiveTimeout = 5000;

listener = new UdpClient(endPoint);
while(true)
{
    try
    {
        data = listener.Receive(ref endPoint);
        message = Encoding.ASCII.GetString(data);
    }
    catch(System.Net.Socket.SocketException ex)
    {
        if (ex.ErrorCode != 10060)
        {
            // Handle the error. 10060 is a timeout error, which is expected.
        }
    }

    // Do something else here.
    // ...
    //
    // If your process is eating CPU, you may want to sleep briefly
    // System.Threading.Thread.Sleep(10);
}
// ...


// ...
// Back on your main thread, when it's exiting, run this code
// in order to completely kill off the UDP thread you created above:
listener.Close();
thread.Close();
thread.Abort();
thread.Join(5000);
thread = null;

В дополнение ко всему этому вы также можете проверить UdpClient.Available > 0, чтобы определить, поставлены ли какие-либо запросы UDP в очередь перед выполнением UdpClient.Receive() — это полностью устраняет блокирующий аспект. Я предлагаю вам попробовать это с осторожностью, поскольку это поведение не указано в документации Microsoft, но, похоже, работает.

Примечание:

MSDN пример кода, который вы, возможно, обнаружили при исследовании этой проблемы, требует дополнительной определяемый пользователем класс - UdpState. Это не класс библиотеки .NET. Это, кажется, сбивает с толку многих людей, когда они исследуют эту проблему.

Для тайм-аутов не обязательно устанавливать значение позволяют вашему приложению полностью выйти, но они позволят вам делать другие вещи в этом цикле, а не блокировать навсегда.

Команда listener.Close() важна, поскольку она заставляет UdpClient генерировать исключение и выйти из цикла, позволяя обработать Thread.Abort(). Без этого вы, возможно, не сможете правильно завершить поток слушателя, пока не истечет время ожидания или не будет получен пакет UDP, что приведет к продолжению кода после блока UdpClient.Receive().

Чтобы добавить к этому бесценному ответу, вот рабочий и проверенный фрагмент кода. (Здесь в контексте Unity3D, но, конечно, для любого С#.)

// minmal flawless UDP listener per PretorianNZ

using System.Collections;
using System;
using System.Net.Sockets;
using System.Net;
using System.Threading;

void Start()
   {
   listenThread = new Thread (new ThreadStart (SimplestReceiver));
   listenThread.Start();
   }

private Thread listenThread;
private UdpClient listenClient;
private void SimplestReceiver()
   {
   Debug.Log(",,,,,,,,,,,, Overall listener thread started.");

   IPEndPoint listenEndPoint = new IPEndPoint(IPAddress.Any, 1260);
   listenClient = new UdpClient(listenEndPoint);
   Debug.Log(",,,,,,,,,,,, listen client started.");

   while(true)
      {
      Debug.Log(",,,,, listen client listening");

      try
         {
         Byte[] data = listenClient.Receive(ref listenEndPoint);
         string message = Encoding.ASCII.GetString(data);
         Debug.Log("Listener heard: " +message);
         }
      catch( SocketException ex)
         {
         if (ex.ErrorCode != 10060)
            Debug.Log("a more serious error " +ex.ErrorCode);
         else
            Debug.Log("expected timeout error");
         }

      Thread.Sleep(10); // tune for your situation, can usually be omitted
      }
   }

void OnDestroy() { CleanUp(); }
void OnDisable() { CleanUp(); }
// be certain to catch ALL possibilities of exit in your environment,
// or else the thread will typically live on beyond the app quitting.

void CleanUp()
   {
   Debug.Log ("Cleanup for listener...");

   // note, consider carefully that it may not be running
   listenClient.Close();
   Debug.Log(",,,,, listen client correctly stopped");

   listenThread.Abort();
   listenThread.Join(5000);
   listenThread = null;
   Debug.Log(",,,,, listener thread correctly stopped");
   }

Я думаю, что вы не должны использовать его в цикле, но вместо этого всякий раз, когда вызывается обратный вызов BeginReceive, вы вызываете BeginReceive еще раз и сохраняете общедоступную переменную для подсчета, если хотите ограничить число до 100.

сначала посмотрите на MSDN. Они подают хороший пример. http://msdn.microsoft.com/en-us/library/system.net.sockets.udpclient.beginreceive.aspx

Я бы сделал сетевое взаимодействие в фоновом потоке, чтобы оно не блокировало что-либо еще в вашем приложении.

Проблема с BeginReceive заключается в том, что в какой-то момент вы должны вызвать EndReceive (в противном случае у вас просто будут сидеть дескрипторы ожидания) - и вызов EndReceive будет блокироваться до тех пор, пока получение не будет завершено. Вот почему проще просто поместить сообщение в другую ветку.

Вы должны выполнять сетевые операции, манипулировать файлами и тому подобное, что зависит от других вещей, а не от вашей собственной программы в другом потоке (или task), потому что они могут заморозить вашу программу. Причина этого в том, что ваш код выполняется последовательно. Вы использовали его в цикле, который не подходит. Всякий раз, когда вызывается обратный вызов BeginRecieve, вы должны вызывать его снова. Взгляните на следующий код:

public static bool messageReceived = false;

public static void ReceiveCallback(IAsyncResult ar)
{
  UdpClient u = (UdpClient)((UdpState)(ar.AsyncState)).u;
  IPEndPoint e = (IPEndPoint)((UdpState)(ar.AsyncState)).e;

  Byte[] receiveBytes = u.EndReceive(ar, ref e);
  string receiveString = Encoding.ASCII.GetString(receiveBytes);

  Console.WriteLine("Received: {0}", receiveString);
  messageReceived = true;
}

public static void ReceiveMessages()
{
  // Receive a message and write it to the console.
  IPEndPoint e = new IPEndPoint(IPAddress.Any, listenPort);
  UdpClient u = new UdpClient(e);

  UdpState s = new UdpState();
  s.e = e;
  s.u = u;

  Console.WriteLine("listening for messages");
  u.BeginReceive(new AsyncCallback(ReceiveCallback), s);

  // Do some work while we wait for a message. For this example,
  // we'll just sleep
  while (!messageReceived)
  {
    Thread.Sleep(100);
  }
}