统一构建游戏后tcp网络无法正常工作

Question

当我在编辑器上进行测试时，我在我的游戏上实现了 tcp 网络，一切正常，但在构建之后没有任何工作。

我已尝试多次更改代码以使其正常工作，但似乎我的代码中缺少某些内容。

我还使用 debug.log 来控制其上的操作，并且在编辑器中一切正常，但在构建中却没有，我已经在两个版本中构建了它，即普通版本和调试版本。

我的代码没有错误。

在调试版本中，debug.log 根本不起作用。

这是我的服务器代码

using System;
using System.Collections; 
using System.Collections.Generic; 
using System.Net; 
using System.Net.Sockets; 
using System.Text; 
using System.Threading; 
using UnityEngine;  
using UnityEngine.UI;  

public class TCPTestServer : MonoBehaviour 
{   
    #region private members     
    /// <summary>   
    /// TCPListener to listen for incoming TCP connection   
    /// requests.   
    /// </summary>  
    public TcpListener tcpListener; 
    /// <summary> 
    /// Background thread for TcpServer workload.   
    /// </summary>  
    public Thread tcpListenerThread;    
    /// <summary>   
    /// Create handle to connected tcp client.  
    /// </summary>  
    public TcpClient connectedTcpClient;    
    #endregion  
    public Text ipadresstoconnect;
    public InputField inputip;
    public InputField inputport;
    public Text iptext;
    public int port;
    public Image online;
    public Image offline;
    public string ipv4 = IPManager.GetIP(ADDRESSFAM.IPv4);
    public bool isclienton;

    // Use this for initialization
    void Start () 
    {       
        // Start TcpServer background thread        
        //tcpListenerThread = new Thread (new ThreadStart(ListenForIncomingRequests));      
        //tcpListenerThread.IsBackground = true;        
        //tcpListenerThread.Start(); 

        iptext.text = ipv4;
        inputip.text = ipv4;
        inputport.text = "8052";
        online.enabled = false;
        offline.enabled = true;
        port = 8052;
    }   

    // Update is called once per frame
    void Update ()
    {   
        if (Input.GetKeyDown(KeyCode.Space)) 
        {             
            SendMessage();         
        }
        if (connectedTcpClient != null) 
        {             
            isclienton=true;
            isclientconnect();
        }

    }   

    /// <summary>   
    /// Runs in background TcpServerThread; Handles incoming TcpClient requests     
    /// </summary>  
    public void ListenForIncomingRequests () 
    {       
        try 
        {           
            // Create listener on localhost port 8052.

            tcpListener = new TcpListener(IPAddress.Parse(ipv4), port);             
            tcpListener.Start();              
            Debug.Log("Server is listening");              
            Byte[] bytes = new Byte[1024];              
            while (true) 
            {               
                using (connectedTcpClient = tcpListener.AcceptTcpClient()) 
                {                   
                    // Get a stream object for reading                  
                    using (NetworkStream stream = connectedTcpClient.GetStream()) 
                    {                       
                        int length;                         
                        // Read incoming stream into byte arrary.                       
                        while ((length = stream.Read(bytes, 0, bytes.Length)) != 0) 
                        {                           
                            var incomingData = new byte[length];                            
                            Array.Copy(bytes, 0, incomingData, 0, length);                              
                            // Convert byte array to string message.                            
                            string clientMessage = Encoding.ASCII.GetString(incomingData);                          
                            Debug.Log("client message received as: " + clientMessage);                      
                        }                   
                    }               
                }           
            }       
        }       
        catch (SocketException socketException) 
        {           
            Debug.Log("SocketException " + socketException.ToString());         
        }     
    }   

    /// <summary>   
    /// Send message to client using socket connection.     
    /// </summary>  
    public void SendMessage() 
    {       
        if (connectedTcpClient == null) 
        {             
            return;         
        }       

        try 
        {           
            // Get a stream object for writing.             
            NetworkStream stream = connectedTcpClient.GetStream();          
            if (stream.CanWrite) 
            {                 
                string serverMessage = "This is a message from your server.";           
                // Convert string message to byte array.                 
                byte[] serverMessageAsByteArray = Encoding.ASCII.GetBytes(serverMessage);               
                // Write byte array to socketConnection stream.               
                stream.Write(serverMessageAsByteArray, 0, serverMessageAsByteArray.Length);               
                Debug.Log("Server sent his message - should be received by client");           
            }       
        }       
        catch (SocketException socketException) 
        {             
            Debug.Log("Socket exception: " + socketException);         
        }   
    }

    public void SendMessage2() 
    {       
        if (connectedTcpClient == null) 
        {             
            return;         
        }       

        try 
        {           
            // Get a stream object for writing.             
            NetworkStream stream = connectedTcpClient.GetStream();          
            if (stream.CanWrite) 
            {                 
                string serverMessage = "A new server is about start listen in -->" + ipadresstoconnect.text.ToString();             
                // Convert string message to byte array.                 
                byte[] serverMessageAsByteArray = Encoding.ASCII.GetBytes(serverMessage);               
                // Write byte array to socketConnection stream.               
                stream.Write(serverMessageAsByteArray, 0, serverMessageAsByteArray.Length);               
                Debug.Log("Server has sent the message...");
                isclienton=false;
            }       
        }       
        catch (SocketException socketException) 
        {             
            Debug.Log("Socket exception: " + socketException);         
        }   
    }

    public void start_server()
    {
        // Start TcpServer background thread        
        tcpListenerThread = new Thread (new ThreadStart(ListenForIncomingRequests));        
        tcpListenerThread.IsBackground = true;      
        tcpListenerThread.Start();
        SendMessage2 ();
    }

    public void isclientconnect()
    {
        if (isclienton=true) 
        {
            if (connectedTcpClient != null) 
            {             
                SendMessage2();          
            }
        }
    }
}

这是我的客户代码

using System;
using System.Collections;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Net;
using System.Text;
using System.Threading;
using UnityEngine;
using UnityEngine.UI;

public class TCPTestClient : MonoBehaviour 
{   
    #region private members     
    public TcpClient socketConnection;  
    public Thread clientReceiveThread;  
    #endregion      
    public Text nickname;
    public int id;
    public string ipv4_v2 = IPManager.GetIP(ADDRESSFAM.IPv4);

    // Use this for initialization  
    void Start () 
    {
        //ConnectToTcpServer();     
    }   
    // Update is called once per frame
    void Update () 
    {         
        if (Input.GetKeyDown(KeyCode.Space)) 
        {             
            SendMessage();         
        }     
    }   

    /// <summary>   
    /// Setup socket connection.    
    /// </summary>  
    public void ConnectToTcpServer () 
    {       
        try 
        {           
            clientReceiveThread = new Thread (new ThreadStart(ListenForData));          
            clientReceiveThread.IsBackground = true;            
            clientReceiveThread.Start();        
        }       
        catch (Exception e) 
        {           
            Debug.Log("On client connect exception " + e);      
        }   
    }   

    /// <summary>   
    /// Runs in background clientReceiveThread; Listens for incoming data.  
    /// </summary>     
    public void ListenForData() 
    {       
        try 
        {           
            socketConnection = new TcpClient("169.254.87.130", 8052);           
            Byte[] bytes = new Byte[1024];             
            while (true) 
            {               
                // Get a stream object for reading              
                using (NetworkStream stream = socketConnection.GetStream()) 
                {                   
                    int length;                     
                    // Read incoming stream into byte arrary.                   
                    while ((length = stream.Read(bytes, 0, bytes.Length)) != 0) 
                    {                       
                        var incomingData = new byte[length];                        
                        Array.Copy(bytes, 0, incomingData, 0, length);                      
                        // Convert byte array to string message.                        
                        string serverMessage = Encoding.ASCII.GetString(incomingData);                      
                        Debug.Log("server message received as: " + serverMessage);                  
                    }               
                }           
            }         
        }         
        catch (SocketException socketException) 
        {             
            Debug.Log("Socket exception: " + socketException);         
        }     
    }   

    /// <summary>   
    /// Send message to server using socket connection.     
    /// </summary>  
    public void SendMessage() 
    {         
        if (socketConnection == null) 
        {             
            return;         
        }       
        try 
        {           
            // Get a stream object for writing.             
            NetworkStream stream = socketConnection.GetStream();            
            if (stream.CanWrite) 
            {                 
                string clientMessage = "This is a message from one of your clients.";               
                // Convert string message to byte array.                 
                byte[] clientMessageAsByteArray = Encoding.ASCII.GetBytes(clientMessage);               
                // Write byte array to socketConnection stream.                 
                stream.Write(clientMessageAsByteArray, 0, clientMessageAsByteArray.Length);                 
                Debug.Log("Client sent his message - should be received by server");             
            }         
        }       
        catch (SocketException socketException) 
        {             
            Debug.Log("Socket exception: " + socketException);         
        }     
    }

    public void connect()
    {
        ConnectToTcpServer();
    }

    public void SendMessageonconnect() 
    {         
        if (socketConnection == null) 
        {             
            return;         
        }       
        try 
        {           
            // Get a stream object for writing.             
            NetworkStream stream = socketConnection.GetStream();            
            if (stream.CanWrite) 
            {                 
                string clientMessage = nickname.ToString();                 
                // Convert string message to byte array.                 
                byte[] clientMessageAsByteArray = Encoding.ASCII.GetBytes(clientMessage);               
                // Write byte array to socketConnection stream.                 
                stream.Write(clientMessageAsByteArray, 0, clientMessageAsByteArray.Length);                 
                Debug.Log("Client sent his message - should be received by server-->" + nickname.text.ToString());             
            }         
        }       
        catch (SocketException socketException) 
        {             
            Debug.Log("Socket exception: " + socketException);         
        }     
    }
}

Answer 1

在服务器代码中以tcpListenerThread 开头并在客户端代码中调用ConnectToTcpServer(); 的行被注释掉。 有两种方法 start_server() 和 connect() 似乎没有被调用。 这可能就是为什么在构建中它不起作用的原因。

此外，您还没有实现在应用退出时终止这些进程的例程，Unity 不会跟踪您创建的线程，也不会自行终止它们。这可能是您的应用程序似乎可以在编辑器中运行的原因。我想你首先用这些行运行它，然后它们稍后注释掉。在随后的时间你点击play，线程仍然从第一次开始运行。

当你完成这些线程时，你绝对应该实现某种例程来杀死它们。

Answer 2

即使这个问题很老 - 我最近遇到了类似的问题并想分享问题所在。

1. 如果您构建到 Android，请确保在播放器配置文件中启用互联网连接

2. 当应用程序“从编辑器运行”时，Unity 似乎有一个虚拟网络。因此，您不仅要构建客户端，还要构建服务器应用程序。构建客户端无法连接到“在编辑器中运行”服务器。