C＃TCP异步BeginSend回调永远不会发生

时间：2015-02-03 10:35:24

标签： c# asynchronous tcp callback mono

我正在使用C＃在Unity中开发游戏，并使用TCP在服务器和客户端之间交换数据。

我使用异步调用来连接，这似乎工作正常。然后发生握手/身份验证，因为服务器提示客户端提供客户端版本，客户端回复，服务器请求播放器的名称，播放器回复，以及是否已接受所有正常的服务器通知客户端，否则连接将被关闭。 / p>

大部分时间都有效。但是，大约在20中，在第一个msg（服务器 - >客户端请求客户端版本，并在游戏启动的几秒内），来自第一个BeginSend 从不的异步回调获得调用，从而停止身份验证过程。客户端确实根据我的日志记录接收消息，并通过调试进行验证。

服务器的呼叫是：

m_isSending = true;
m_socket.BeginSend(byteArray.buffer, 0, byteArray.arrayLen, SocketFlags.None, new AsyncCallback(EndAsyncWrite), byteArray);

我添加了m_isSending以帮助更轻松地调试/跟踪是否正在发送消息以确认是否已调用回调。

使用EndAsyncWrite：

protected void EndAsyncWrite(IAsyncResult iar)
{
        m_isSending = false;
        m_socket.EndSend(iar);
        ByteArray byteArray = (iar.AsyncState as ByteArray);
        //Add prev msg's ByteArray to await recycling
        lock (m_byteArraysAwaitingRecycle)
        {
            m_byteArraysAwaitingRecycle.Add(byteArray);
        }
}

在20种情况中的1种情况下，即使客户端收到并处理了该消息，m_isSending仍然为真。我已经在调试器中探讨了一下，但是由于我所假设的是Unity使用单声道，因此无法进行同步。但是我已经在插槽中找到了消息＆＃39; s writeQ（我假设是写入队列）。通常它是空的，所以我想知道它是否能够解释为什么回调没有被调用。 Watch Snippet。唯一存在的条目是发送的消息和客户端收到的消息。

其他信息：nagle是禁用，阻塞设置为true。其他19/20尝试似乎没有问题，没有任何变化。我目前正在使用localhost作为目标进行测试。

所以我很困惑，因为据我所知，我正在做所有事情。为什么回调不会被调用？有任何想法吗？有什么建议？有什么方法可以解决这个问题吗？

1 个答案:

答案 0 :(得分：0)

在做了一些更多测试后，我得出结论，这是在Unity Editor中运行时对线程的错误/影响。以下是我得出这个结论的方法：

我注意到第一次打开Unity项目并开始游戏时更常出现问题。停止然后开始通常会起作用。它总是在2-3次尝试中工作并继续工作至少十几次尝试。这当然可以在我自己的代码中指出某种竞争条件或线程并发问题，所以我做了以下几点：1）在Unity中制作了一个非常简化的tcplistener / tcpclient项目，消除了byte []数组的任何缓存/回收或其他可能无意中影响异步或整体性能的事情。 2）我在编辑器中测试了这个新项目，并作为一个独立的构建来检查结果。

这当然需要统一，尽管它可能很容易被用于.net控制台应用程序以进行进一步评估。该项目由一个场景组成，游戏摄像机将以下三个脚本连接到摄像机。一旦附加到游戏对象，您需要将TCPClient和TCPServer引用拖放到ConnectGUI上。代码：

<强> ConnectGUI.cs 

using UnityEngine;
using System.Collections;

public class ConnectGUI : MonoBehaviour {

public enum ConnectionState
{
    NotConnected,
    AttemptingConnect,
    Connected
}

public TCPClient client;
public TCPServer server;

// Use this for initialization
void Start () 
{
    client.connectState = ConnectionState.NotConnected;
}

// Update is called once per frame
void Update () {

}

void OnGUI()
{
    GUI.Label(new Rect(10, 10, Screen.width - 20, 20), client.connectState.ToString());

    if (client.connectState == ConnectionState.NotConnected)
    {
        if (GUI.Button(new Rect(Screen.width * 0.5f - 200, Screen.height * 0.5f - 40, 400, 80), "Connect"))
        {
            server.StartServer();
            System.Threading.Thread.Sleep(10);
            client.StartConnect(); 
        }
    }
}
}

<强> TCPClient.cs 

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

public class TCPClient : MonoBehaviour {

public ConnectGUI.ConnectionState connectState;
Socket m_clientSocket;
byte[] m_readBuffer;

void Start()
{
    connectState = ConnectGUI.ConnectionState.NotConnected;
    m_readBuffer = new byte[1024];
}

public void StartConnect()
{
    m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    try
    {
       System.IAsyncResult result = m_clientSocket.BeginConnect("127.0.0.1", 10000, EndConnect, null);

       bool connectSuccess = result.AsyncWaitHandle.WaitOne(System.TimeSpan.FromSeconds(10));

       if (!connectSuccess)
       {
           m_clientSocket.Close();
           Debug.LogError(string.Format("Client unable to connect. Failed"));
       }
    }
    catch (System.Exception ex)
    {
        Debug.LogError(string.Format("Client exception on beginconnect: {0}", ex.Message));
    }

    connectState = ConnectGUI.ConnectionState.AttemptingConnect;
}

void EndConnect(System.IAsyncResult iar)
{
    m_clientSocket.EndConnect(iar);

    m_clientSocket.NoDelay = true;

    connectState = ConnectGUI.ConnectionState.Connected;

    BeginReceiveData();

    Debug.Log("Client connected");
}

void OnDestroy()
{
    if (m_clientSocket != null)
    {
        m_clientSocket.Close();
        m_clientSocket = null;
    }
}

void BeginReceiveData()
{
    m_clientSocket.BeginReceive(m_readBuffer, 0, m_readBuffer.Length, SocketFlags.None, EndReceiveData, null);
}

void EndReceiveData(System.IAsyncResult iar)
{
    int numBytesReceived = m_clientSocket.EndReceive(iar);

    ProcessData(numBytesReceived);

    BeginReceiveData();
}

void ProcessData(int numBytesRecv)
{
    string temp = TCPServer.CompileBytesIntoString(m_readBuffer, numBytesRecv);

    Debug.Log(string.Format("Client recv: '{0}'", temp));

    byte[] replyMsg = new byte[m_readBuffer.Length];
    System.Buffer.BlockCopy(m_readBuffer, 0, replyMsg, 0, numBytesRecv);

    //Increment first byte and send it back
    replyMsg[0] = (byte)((int)replyMsg[0] + 1);

    SendReply(replyMsg, numBytesRecv);
}

void SendReply(byte[] msgArray, int len)
{
    string temp = TCPServer.CompileBytesIntoString(msgArray, len);

    Debug.Log(string.Format("Client sending: len: {1} '{0}'", temp, len));

    m_clientSocket.BeginSend(msgArray, 0, len, SocketFlags.None, EndSend, msgArray);
}

void EndSend(System.IAsyncResult iar)
{
    m_clientSocket.EndSend(iar);

    byte[] msg = (iar.AsyncState as byte[]);

    string temp = TCPServer.CompileBytesIntoString(msg, msg.Length);

    Debug.Log(string.Format("Client sent: '{0}'", temp));

    System.Array.Clear(msg, 0, msg.Length);
    msg = null;
}
}

<强> TCPServer.cs 

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

public class TCPServer : MonoBehaviour 
{
public enum TestMessageOrder
{
    NotConnected,
    Connected,
    SendFirstMessage,
    ReceiveFirstMessageReply,
    SendSecondMessage,
    ReceiveSecondMessageReply,
    SendThirdMessage,
    ReceiveThirdMessageReply,
    Error,
    Done
}

protected TcpListener m_tcpListener;
protected Socket m_testClientSocket;
protected byte[] m_readBuffer;
[SerializeField]
protected TestMessageOrder m_testClientState;

public void StartServer()
{
    m_tcpListener = new TcpListener(IPAddress.Any, 10000);
    m_tcpListener.Start();

    StartListeningForConnections();
}

void StartListeningForConnections()
{
    m_tcpListener.BeginAcceptSocket(AcceptNewSocket, m_tcpListener);
    Debug.Log("SERVER ACCEPTING NEW CLIENTS");
}

void AcceptNewSocket(System.IAsyncResult iar)
{
    m_testClientSocket = null;
    m_testClientState = TestMessageOrder.NotConnected;
    m_readBuffer = new byte[1024];

    try
    {
        m_testClientSocket = m_tcpListener.EndAcceptSocket(iar);
    }
    catch (System.Exception ex)
    {
        //Debug.LogError(string.Format("Exception on new socket: {0}", ex.Message));
    }

    m_testClientSocket.NoDelay = true;
    m_testClientState = TestMessageOrder.Connected;

    BeginReceiveData();
    SendTestData();

    StartListeningForConnections();
}

void SendTestData()
{
    Debug.Log(string.Format("Server: Client state: {0}", m_testClientState));

    switch (m_testClientState)
    {
        case TestMessageOrder.Connected:
            SendMessageOne();
            break;

        //case TestMessageOrder.SendFirstMessage:
            //break;

        case TestMessageOrder.ReceiveFirstMessageReply:
            SendMessageTwo();
            break;

        //case TestMessageOrder.SendSecondMessage:
            //break;

        case TestMessageOrder.ReceiveSecondMessageReply:
            SendMessageTwo();
            break;

        case TestMessageOrder.SendThirdMessage:
            break;

        case TestMessageOrder.ReceiveThirdMessageReply:
            m_testClientState = TestMessageOrder.Done;
            Debug.Log("ALL DONE");
            break;

        case TestMessageOrder.Done:
            break;

        default:
            Debug.LogError("Server shouldn't be here");
            break;
    }
}

void SendMessageOne()
{
    m_testClientState = TestMessageOrder.SendFirstMessage;
    byte[] newMsg = new byte[] { 1, 100, 101, 102, 103, 104 };

    SendMessage(newMsg);
}

void SendMessageTwo()
{
    m_testClientState = TestMessageOrder.SendSecondMessage;
    byte[] newMsg = new byte[] { 3, 100, 101, 102, 103, 104, 105, 106 };

    SendMessage(newMsg);
}

void SendMessageThree()
{
    m_testClientState = TestMessageOrder.SendThirdMessage;
    byte[] newMsg = new byte[] { 5, 100, 101, 102, 103, 104, 105, 106, 107, 108 };

    SendMessage(newMsg);
}

void SendMessage(byte[] msg)
{
    string temp = TCPServer.CompileBytesIntoString(msg);

    Debug.Log(string.Format("Server sending: '{0}'", temp));

    m_testClientSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None, EndSend, msg);
}

void EndSend(System.IAsyncResult iar)
{
    m_testClientSocket.EndSend(iar);

    byte[] msgSent = (iar.AsyncState as byte[]);
    string temp = CompileBytesIntoString(msgSent);

    Debug.Log(string.Format("Server sent: '{0}'", temp));
}

void BeginReceiveData()
{
    m_testClientSocket.BeginReceive(m_readBuffer, 0, m_readBuffer.Length, SocketFlags.None, EndReceiveData, null);
}

void EndReceiveData(System.IAsyncResult iar)
{
    int numBytesReceived = m_testClientSocket.EndReceive(iar);

    ProcessData(numBytesReceived);

    BeginReceiveData();
}

void ProcessData(int numBytesRecv)
{
    string temp = TCPServer.CompileBytesIntoString(m_readBuffer, numBytesRecv);

    Debug.Log(string.Format("Server recv: '{0}'", temp));

    byte firstByte = m_readBuffer[0];

    switch (firstByte)
    {
        case 1:
            Debug.LogError(string.Format("Server should not receive first byte of 1"));
            m_testClientState = TestMessageOrder.Error;
            break;

        case 2:
            m_testClientState = TestMessageOrder.ReceiveSecondMessageReply;
            break;

        case 3:
            Debug.LogError(string.Format("Server should not receive first byte of 3"));
            m_testClientState = TestMessageOrder.Error;
            break;

        case 4:
            m_testClientState = TestMessageOrder.ReceiveThirdMessageReply;
            break;

        case 5:
            Debug.LogError(string.Format("Server should not receive first byte of 5"));
            m_testClientState = TestMessageOrder.Error;
            break;

        default:
            Debug.LogError(string.Format("Server should not receive first byte of {0}", firstByte));
            m_testClientState = TestMessageOrder.Error;
            break;
    }

    SendTestData();
}

void OnDestroy()
{

    if (m_testClientSocket != null)
    {
        m_testClientSocket.Close();
        m_testClientSocket = null;
    }

    if (m_tcpListener != null)
    {
        m_tcpListener.Stop();
        m_tcpListener = null;
    }
}

public static string CompileBytesIntoString(byte[] msg, int len = -1)
{
    string temp = "";

    int count = len;

    if (count < 1)
    {
        count = msg.Length;
    }

    for (int i = 0; i < count; i++)
    {
        temp += string.Format("{0} ", msg[i]);
    }

    return temp;
}
}

这样做是启动一个TcpListener，并开始一个异步连接套接字接受。然后创建一个客户端套接字并作为tcp套接字连接（在端口10000上，127.0.0.1）。它转变为nagle的算法，服务器发送第一条消息。客户端接收消息，将第一个字节从1-> 2递增并返回原始消息。然后，服务器接收该消息，并发送另一条以3开头的消息。客户端接收，增加3> 4并回显消息的其余部分。然后，服务器接收该消息，并发送以5开头的第3个和最后一个消息。客户端转到5-> 6并发送回消息。一旦发生这种情况，服务器将打印“ALL DONE”。服务器和客户端都应该打印以记录各种消息内容（由于线程的性质，并不总是以相同的顺序）。

如果由于某种原因“未完成”未打印，则实验失败。

在Unity Editor中运行它，在第一次运行时失败了10/10，在打开编辑器后立即运行。后来尝试运行它导致第二次和第三次尝试的混合成功。到第4次尝试时，我没有记录失败。

然后我将项目编译为独立程序，并重复相同次数的尝试。由于它依赖于日志中的“ALL DONE”，因此每次都会检查output.log是否为“ALL DONE”。

因此，除非我误解了结果，否则在Unity编辑器或其底层单声道版本中存在问题，这些版本与线程相关，导致tcp异步读/写在某些容量中失败。然而，在独立版本中，无论是什么东西，幸运的是，至少就Windows上的测试而言似乎并不是一个问题。

我完全承认测试是有限的，每次只有大约40次运行，但结果有显着差异，尽管我懒得计算实际意义。我很困惑，仍有点担心它可能是我自己的有缺陷的实施，因为这样的事情并不是更广泛;但Unity自己的网络主要依赖于RPC调用，大多数中间件完全采用独有的基于UDP的网络选项。

如果存在一些根本性的缺陷，请告诉我，否则我希望这可能会帮助一些失去的灵魂（就像我将近两周一样），因为在这个主题上几乎没有可搜索的结果。这一切都在Unity 4.6.1f1中完成，但也在目前的Unity 5 Beta中由朋友测试（不确定当前的beta版本号）。

就个人而言，虽然这非常令人讨厌，但我觉得我可以忽略这个仅仅是编辑器的问题，几乎没有可能影响实际播放编译版本的玩家。一旦构建经常发生，将会进行大量测试。

相关问题
最新问题