Windows 下 C++ 和 C# 中的套接字无法正常工作

Question

我正在使用 UDP 套接字将 C++ 应用程序与 C# 应用程序通信。

在 C# -> C++ 方向上，一切似乎都运行良好，但反过来却让我发疯。

通信确实有效，但消息在 C# 应用程序中变得很晚（例如延迟 2 秒），即使它们每帧都发送（它是一个 3D 应用程序），并且接收代码每 10 毫秒执行一次。

我需要实时，所以这是一个非常痛苦的问题。您认为这可能与丢包有关吗？那他们为什么不迷路呢？

编辑：

用于同步数据的 C# 应用代码：

    public void RecibeDatos()
    {
       if (MessageReceived && U != null && S != null)
       {
          MessageReceived = false;
          //Console.WriteLine("listening for messages");
          U.BeginReceive(ReceiveCallback, S);
       }
    }

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

        receivedBytes = u.EndReceive(ar, ref e);
        //int currentProtocol = (int) numero;
        //ResetSignal = reset > 0;

        //Console.WriteLine("Received: " + currentProtocol);
        MessageReceived = true;
    }

发送数据的C++代码：

    float indiceFloat[1];
    indiceFloat[0] = indice_protocolo_actual;
    sender->setBuffer((void *)indiceFloat, sizeof(indiceFloat));
    sender->sync();

J_Enviar（发送者）类的同步方法：

    void J_Enviar::sync( void )
    {
        if(!_initialized) init();

        if( _buffer == 0L )
        {
            fprintf( stderr, "Broadcaster::sync() - No buffer\n" );
            return;
        }

    #if defined (WIN32) && !defined(__CYGWIN__)
        unsigned int size = sizeof( SOCKADDR_IN );
        sendto( _so, (const char *)_buffer, _buffer_size, 0, (struct sockaddr *)&saddr, size );
        int err = WSAGetLastError ();
        if (err!=0) 
            fprintf( stderr, "Broadcaster::sync() - error %d\n",err );
    #else
        unsigned int size = sizeof( struct sockaddr_in );
        sendto( _so, (const void *)_buffer, _buffer_size, 0, (struct sockaddr *)&saddr, size );
    #endif

    }

为接收 C# 端提供完整的 SocketManager 代码：

using System;
using System.Net;
using System.Net.Sockets;

namespace WpfApplication1
{
public class SocketManager
{
    private static SocketManager _instance = null;
    static readonly object Padlock = new object();

    private IPEndPoint E;
    private UdpClient U;
    private UdpState S;

    private byte[] receivedBytes;


    public static bool MessageReceived = true;

    private SocketManager()
    {

    }

    public byte[] ReceivedBytes
    {
        get { return receivedBytes; }
    }

    public static SocketManager Instance
    {
        get
        {
            lock(Padlock)
            {
                return _instance ?? (_instance = new SocketManager());
            }
        }
    }

    public void CreateReceivingSocket(IPAddress a, int puerto)
    {

        if(E==null || (E.Address != a && E.Port != puerto))
        {
            E = new IPEndPoint(a, puerto);
            U = new UdpClient(puerto);
            S = new UdpState { E = E, U = U };
        }

    }


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

        receivedBytes = u.EndReceive(ar, ref e);
        //int currentProtocol = (int) numero;
        //ResetSignal = reset > 0;

        //Console.WriteLine("Received: " + currentProtocol);
        MessageReceived = true;
    }

    public void RecibeDatos()
    {
        if (MessageReceived && U != null && S != null)
        {
            MessageReceived = false;
            //Console.WriteLine("listening for messages");
            U.BeginReceive(ReceiveCallback, S);
        }
    }

    public void CloseConnection()
    {
        if (E != null)
        {
            E.Port = 5502;
            E = null;
        }
        if (U != null)
            U.Close();

    }
}

public class UdpState
{
    public IPEndPoint E;
    public UdpClient U;
}
}

这是我的 dispatchertimerclick，它使程序每 10 毫秒接收一次：

        _dispatcherTimer.Tick += DispatcherTimerTick;
        _dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 1);
        _dispatcherTimer.Start();

    private void DispatcherTimerTick(object sender, EventArgs e)
    {
        _exp1Class.sendData();
        _sm.RecibeDatos();
        byte[] recibidos = _sm.ReceivedBytes;
        if (recibidos != null)
        {
            float numero = BitConverter.ToSingle(recibidos, 0);

            _exp1Class.CurrentProtocol = (int) numero;
        }
    }

Answer 1

我看不到您何时开始您的第一个 BeginReceive。 （啊，我认为它是从您的第一个计时器滴答声开始的？）它应该在您准备好接收数据后立即启动。其次，您的 ReceiveCallback 应该获取接收到的数据并将其放入某种队列中，然后立即再次调用 BeginReceive。否则，您将等待下一个数据帧的到达，直到前一个数据帧被消耗。最后，注意线程问题，因为线程计时器和 UDP 回调都将在与应用程序主线程不同的线程上运行。

您的代码完全有效的唯一原因是因为您甚至在收到任何回调之前就预先初始化了 MessageReceived = true。当第一个滴答发生时，对 RecibeDatos 的调用会调用 BeginReceive，因为该 bool 设置为 true。

将 BeginReceive 想象为“当您有来自网络的一些数据时给我回电”。您无需使用计时器轮询网络。 （如果您的应用程序需要，您可以选择通过计时器使用该数据，但我们暂时将其放在一边）。

以下是粗略的步骤：

首先，在启动（或启用、运行等）时，您应该调用 BeginReceive。现在，您将在数据到达时收到通知。

其次，当回调发生时，您使用 EndReceive 完成数据字节的读取。该数据通常会被缓冲或以其他方式分派。然后，您应该再次调用 BeginReceive（在回调中），以便在下一组数据可用时，您将再次收到通知。它变成了一种异步循环。

问题是如何处理您正在阅读的数据。您可能会考虑将数据放入队列中，然后让 Timer 将这些数据帧从队列中弹出以进行处理。请注意，数据可能会在您的 Ticks 之间多次到达。