两位编辑之间的Unity 3D通信

Question

我正在尝试使用简单的tcp客户端/服务器设置在两个编辑器之间传输一些数据：

服务器：

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

public class TCPTestServer : MonoBehaviour {    
    #region private members     
    /// <summary>   
    /// TCPListener to listen for incomming TCP connection  
    /// requests.   
    /// </summary>  
    private TcpListener tcpListener; 
    /// <summary> 
    /// Background thread for TcpServer workload.   
    /// </summary>  
    private Thread tcpListenerThread;   
    /// <summary>   
    /// Create handle to connected tcp client.  
    /// </summary>  
    private TcpClient connectedTcpClient;   
    #endregion  

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

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

            SendMessage();         

    }   

    /// <summary>   
    /// Runs in background TcpServerThread; Handles incomming TcpClient requests    
    /// </summary>  
    private void ListenForIncommingRequests () {        
        try {           
            // Create listener on localhost port 8052.          
            tcpListener = new TcpListener(IPAddress.Parse("myip"), 65535);          
            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 incomming stream into byte arrary.                      
                        while ((length = stream.Read(bytes, 0, bytes.Length)) != 0) {                           
                            var incommingData = new byte[length];                           
                            Array.Copy(bytes, 0, incommingData, 0, length);                             
                            // Convert byte array to string message.                            
                            string clientMessage = Encoding.ASCII.GetString(incommingData);                             
                            Debug.Log("client message received as: " + clientMessage);                      
                        }                   
                    }               
                }           
            }       
        }       
        catch (SocketException socketException) {           
            Debug.Log("SocketException " + socketException.ToString());         
        }     
    }   
    /// <summary>   
    /// Send message to client using socket connection.     
    /// </summary>  
    private void SendMessage() {        
        if (connectedTcpClient == null) {             
            return;         
        }       

        try {           
            // Get a stream object for writing.             
            NetworkStream stream = connectedTcpClient.GetStream();          
            if (stream.CanWrite) {                 
                string serverMessage = this.gameObject.transform.position.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 sent his message - should be received by client");           
            }       
        }       
        catch (SocketException socketException) {             
            Debug.Log("Socket exception: " + socketException);         
        }   
    } 

    void OnApplicationQuit()
    {
        tcpListenerThread.Abort();
        connectedTcpClient.Close ();

    }
}

客户端：

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

public class TCPTestClient : MonoBehaviour {    
    #region private members     
    private TcpClient socketConnection;     
    private Thread clientReceiveThread;     
    #endregion      
    // 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>  
    private 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 incomming data.     
    /// </summary>     
    private void ListenForData() {      
        try {           
            socketConnection = new TcpClient("myip", 65535);            
            Byte[] bytes = new Byte[1024];             
            while (true) {              
                // Get a stream object for reading              
                using (NetworkStream stream = socketConnection.GetStream()) {                   
                    int length;                     
                    // Read incomming stream into byte arrary.                  
                    while ((length = stream.Read(bytes, 0, bytes.Length)) != 0) {                       
                        var incommingData = new byte[length];                       
                        Array.Copy(bytes, 0, incommingData, 0, length);                         
                        // Convert byte array to string message.                        
                        string serverMessage = Encoding.ASCII.GetString(incommingData);                         
                        Debug.Log("server message received as: " + serverMessage);                  
                    }               
                }           
            }         
        }         
        catch (SocketException socketException) {             
            Debug.Log("Socket exception: " + socketException);         
        }     
    }   
    /// <summary>   
    /// Send message to server using socket connection.     
    /// </summary>  
    private 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);         
        }     
    } 

    void OnApplicationQuit()
    {
        clientReceiveThread.Abort();
        socketConnection.Close ();

    }
}

如果我在两台不同的计算机上单独运行服务器和客户端，这在本地工作但不会工作。此外，即使我从我的防火墙设置转发，我triennd ping.eu和我的端口似乎关闭。我做错了什么？