异步套接字在 Unity-iOS 上间歇性挂起

Question

我目前正在编写一个网络控制器脚本，它使用 C# Socket 类与专用服务器进行通信。

它利用异步回调方法，以便异步发送/接收数据并相应地处理它们。

大多数时候，它可以完美地跨平台运行（iOS 和 Android）。

但是，有时套接字会默默地“挂起”而没有任何明确的错误，既不发送也不接收来自服务器的更多数据。 （在我的测试中，它总是发生在 iOS 客户端上。）

我再次检查以确保这不是服务器端的问题。

有趣的是，服务器发现与受影响客户端的套接字连接仍然存在，强制退出客户端仍然会导致它断开连接。只是调用发送/接收失败。

其他未受影响的设备继续正常发送和接收数据。

从这种情况中恢复的唯一方法是强制关闭并重新打开套接字，这是不切实际的，因为发生这种情况时似乎没有引发异常。 （我曾经在调用我现在正在处理的 SendAsync 时遇到“InvalidOperationException：没有正在进行的操作”——但为什么会发生这种情况？）

可能是什么原因？

以下是部分代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Net;
using System.Net.Sockets;

public class NetworkController : MonoBehaviour
{
    public static NetworkController instance;

    private Socket _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    private byte[] _receiveBuffer = new byte[8142];

    private List<byte> _inBuffer;

    void Awake()
    {
        if (!instance)
        {
            instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    // Start is called before the first frame update
    void Start()
    {
        Connect();
    }

    private void Connect()
    {

        _inBuffer = new List<byte>();

        SetupServer();
    }

    private void Disconnect()
    {

        _clientSocket.Disconnect(true);
        _inBuffer = null;
    }

    IEnumerator Reconnect()
    {
        Disconnect();
        yield return new WaitForSeconds(5);
        Connect();
    }

    private void SetupServer()
    {
        try
        {
            _clientSocket.Connect(new IPEndPoint(IPAddress.Parse(IP), PORT));
        }
        catch (SocketException ex)
        {
            Debug.Log(ex.Message);

            StartCoroutine(Reconnect());
        }

        _clientSocket.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), null);

    }

    private void CheckForMessages()
    {
        while (true)
        {
            if (_inBuffer.Count < sizeof(int))
            {
                return;
            }

            int msgLength = BitConverter.ToInt32(_inBuffer.ToArray(), 0);
            msgLength = IPAddress.NetworkToHostOrder(msgLength);
            if (_inBuffer.Count < msgLength + 4)
            {
                return;
            }

            byte[] message = _inBuffer.GetRange(4, msgLength).ToArray();
            ProcessMessage(message);

            int amtRemaining = _inBuffer.Count - msgLength - sizeof(int);
            if (amtRemaining == 0)
            {
                _inBuffer = new List<byte>();
            }
            else
            {
                _inBuffer = _inBuffer.GetRange(msgLength + 4, amtRemaining);
            }

        }
    }

    private void ReceiveCallback(IAsyncResult AR)
    {
        try
        {
            int received = _clientSocket.EndReceive(AR);

            if (received <= 0)
            {
                StartCoroutine(Reconnect());
                return;
            }

            byte[] recData = new byte[received];
            Buffer.BlockCopy(_receiveBuffer, 0, recData, 0, received);

            _inBuffer.AddRange(recData);
            CheckForMessages();

            _clientSocket.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), null);
        }
        catch (SocketException)
        {
            StartCoroutine(Reconnect());
        }
    }

    private void SendData(byte[] data)
    {
        SocketAsyncEventArgs socketAsyncData = new SocketAsyncEventArgs();
        socketAsyncData.SetBuffer(data, 0, data.Length);
        try
        {
            _clientSocket.SendAsync(socketAsyncData);
        }
        catch (Exception)
        {
            StartCoroutine(Reconnect());
        }
    }
}

编辑

Here 是套接字在62.838564 挂起之前的完整数据包日志（由于大尺寸而建立链接）。

Answer 1

我似乎已经解决了这个问题。

这是我所做的：

使用BeginSend 代替SendAsync。在BeginSend 和调用EndSend 的回调中放置一个线程锁，以便每个BeginSend 在另一个BeginSend 之前获得一个EndSend。

代码如下：

    private ManualResetEvent sendDone =
        new ManualResetEvent(false);

    private void SendData(byte[] data)
    {
        _clientSocket.BeginSend(data, 0, data.Length, 0,
            new AsyncCallback(SendCallback), null);

        sendDone.WaitOne();
        sendDone.Reset();
    }

    private void SendCallback(IAsyncResult ar)
    {
        try
        {
            int bytesSent = _clientSocket.EndSend(ar);

            sendDone.Set();
        }
        catch (Exception)
        {
            StartCoroutine(Reconnect());
        }
    }