更新

我想出了问题所在。我试图通过 TCP 移动太多数据，这导致了卡住。出于某种原因，这并没有体现在编辑器中……谁知道是什么原因。如果其他人偶然发现了这个问题(在像 Unity 这样的程序中，函数不断循环并且数据总是被处理)，请考虑您移动了太多不相关的数据。

原帖

我遇到了很多问题，希望能得到一些指导。

简而言之，我想知道如何使用 TCP 在同一台计算机上与两个 Unity 应用程序进行通信。我已经让它在编辑器中运行，但是当两个应用程序都构建好后，通信很快就中断了。

这真的让我很困惑，因为我不明白为什么应用程序可以在编辑器环境中运行，但不能在官方构建中运行。

当我使用 TCP 在两个 Unity 应用程序(在同一台计算机上)之间进行通信时，只要其中一个应用程序保留在 Unity 环境中，它就可以工作。也就是说，如果我构建一个应用程序，然后在 Unity 编辑器中打开另一个应用程序，TCP 通信将完美无缺。

这里是更多背景信息:我的一个应用程序用作用户界面，另一个应用程序与 Looking Glass 连接以提供游戏中对象的全息显示。最初，它们被合并到一个应用程序中——但我在让 Unity 的多显示器支持在两个不同分辨率的显示器之间运行时遇到了很多麻烦。 Looking Glass factory 甚至提供了一个预制件来做到这一点，但它在当前的 SDK 中被破坏了。因此，我求助于使用套接字在两个应用程序之间进行交互，每个应用程序一个。

我正在使用 C# 的 TCP 监听器类:https://learn.microsoft.com/en-us/dotnet/api/system.net.sockets.tcplistener?view=netframework-4.8

和 TCP 客户端类:https://learn.microsoft.com/en-us/dotnet/api/system.net.sockets.tcpclient?view=netframework-4.8

目前，UI充当TCPListener，产生全息图的应用程序是TCPClient。在每个应用程序中，我都使用了两个队列——一个 IncomingMessages 队列和一个 Outgoing Messages 队列——它们是在主线程和网络线程之间共享的全局变量。

TCP 监听器:

private void Start()
{
    incomingMessages = new Queue();
    outgoingMessages = new Queue();

    Application.runInBackground = true;
    thread = new Thread(new ThreadStart(Receive));
    thread.Start();

    //stuff happens that's irrelevant to this question.  And then...   
}

void Receive()
{
    TcpListener server = null;

    try
    {
        // Set the TcpListener on port 13000.
        Int32 port = 13000;
        IPAddress localAddr = IPAddress.Parse("127.0.0.1");

        // TcpListener server = new TcpListener(port);
        server = new TcpListener(localAddr, port);

        // Start listening for client requests.
        server.Start();

        // Buffer for reading data
        Byte[] bytes = new Byte[256];
        String data = null;

        // Enter the listening loop.

        Debug.Log("About to reenter main while in Server...");

        while (threadContinue)
        {
            Debug.Log("Waiting for a connection... ");

            // Perform a blocking call to accept requests.
            // You could also user server.AcceptSocket() here.

            TcpClient client = server.AcceptTcpClient();
            Debug.Log("Connected!");

            data = null;

            // Get a stream object for reading and writing
            NetworkStream stream = client.GetStream();

            int i;

            // Loop to receive all the data sent by the client.
            while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
            {
                // Translate data bytes to a ASCII string.
                data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
                Debug.Log("Received from Client: " + data);

                lock (this)

                incomingMessages.Enqueue(data);

                string response = supplyData();
                byte[] msg = System.Text.Encoding.ASCII.GetBytes(response);
                // Send back a response.
                stream.Write(msg, 0, msg.Length);
                Debug.Log("Sent to Client: " + response);
            }

            // Shutdown and end connection
            client.Close();  
        }
    }


    catch (SocketException e)
    {
        Debug.Log("SocketException: ");
        Debug.Log(e);
    }
    finally
    {
        // Stop listening for new clients.
        server.Stop();
    }
        Debug.Log("Exiting 'Receive'");
}

这是 TCP 客户端。它会定期尝试连接，并且在有新数据可用时也会尝试连接。这是为了它可以定期从服务器接收信息并在可用时共享新数据:

void Start()
{
    //prepare networking
    Application.runInBackground = true;

    outgoingMessages = new Queue();
    incomingMessages = new Queue();

    thread = new Thread(new ThreadStart(Connect));
    thread.Start();

    //stuff happens that's irrelevant to this question...
}

private void Connect()
{
    String server = "127.0.0.1";
    Int32 port = 13000;
    string message = "";
    while (threadContinue == true)
    {
        if (timeToConnect())
        {
            lastConnection = ourTime;
            if (outgoingMessages.Count > 0)
                message = outgoingMessages.Dequeue().ToString();
            else
                message = "Nothing to report.";

            try
            {
                // Create a TcpClient.
                // Note, for this client to work you need to have a TcpServer 
                // connected to the same address as specified by the server, port
                // combination.

                client = new TcpClient(server, port);

                // Translate the passed message into ASCII and store it as a Byte array.
                Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);

                // Get a client stream for reading and writing.
                //  Stream stream = client.GetStream();

                stream = client.GetStream();

                // Send the message to the connected TcpServer. 
                stream.Write(data, 0, data.Length);

                Debug.Log("Sent to Server: " + message);


                // Buffer to store the response bytes.
                data = new Byte[256];

                // String to store the response ASCII representation.
                String responseData = String.Empty;

                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = stream.Read(data, 0, data.Length);
                responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);

                lock (this)

                    incomingMessages.Enqueue(responseData);

                Debug.Log("Received from Server: " + responseData);


                stream.Close();
                client.Close();

            }
            catch (ArgumentNullException e)
            {
                Debug.Log("ArgumentNullException: ");
                Debug.Log(e);

                outgoingMessages.Enqueue(message);
            }
            catch (SocketException e)
            {
                Debug.Log("SocketException: ");
                Debug.Log(e);
                outgoingMessages.Enqueue(message);
            }
        }
    }
}


private bool timeToConnect()
{
    if ((ourTime - lastConnection > NETWORK_DELAY) || (outgoingMessages.Count > 0))
        return true;
    return false;
}

在单独的线程中实例化，以便 Unity 的主线程可以不受阻碍地继续运行。

再次 - 它在编辑器中工作，但当我构建它时，它会中断。

最佳答案

更新

我想出了问题所在。我试图通过 TCP 移动太多数据，这导致了卡住。出于某种原因，这并没有出现在编辑器中……只是出现在导出的应用程序中。谁知道是什么原因。如果其他人偶然发现了这个问题……您通过构建多个通过网络通信的应用程序来绕过 Unity 的多显示功能……请考虑一下，您正在为队列增加过多的数据负担。

关于c# - 如何使用 TCP 在两个 Unity 应用程序之间进行通信？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57776346/