C #, асинхронные сокеты сервер / клиент, StackOverflowException

Question

Я пишу асинхронный сервер и клиент с C #. Я взял пример кода из MSDN, изменил и сделал его для отправки и получения сообщений несколько раз. Я попытался подключить 5 и более клиентов к серверу, и это сработало, но на 98-й итерации каждый клиент выдает исключение StackOverflow. Кто-нибудь может объяснить мне, почему я получаю эту ошибку? Я прочитал в MSDN, что моя проблема в бесконечных циклах, но я не понимаю, как я могу изменить свой код и написать его без циклов.

Этот сервер-клиент должен использоваться в многопользовательской гоночной игре, и мне нужно отправлять и получать координаты каждого игрока несколько раз в секунду. Как я могу сделать это без бесконечных циклов?

Вот мой код:

SERVER:

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


public class Server
{
    Socket main_tcp_Sock;
    private static ManualResetEvent acceptDone = new ManualResetEvent(false);
    private static ManualResetEvent sendDone = new ManualResetEvent(false);
    private static ManualResetEvent recvDone = new ManualResetEvent(false);
    private static ManualResetEvent closeDone = new ManualResetEvent(false);
    //int cl_Count = 0;
    List<StateObject> connection_List = new List<StateObject>();
    private static String response = String.Empty;


    public class StateObject
    {
        public Socket current_Socket = null;
        public byte[] data = new byte[256];
        public string id = string.Empty;
    }
    public Server()
    {
        Server_Start();
    }

    public void Server_Start()
    {

        //Creating socket
        main_tcp_Sock = new Socket(AddressFamily.InterNetwork,
                                  SocketType.Stream,
                                  ProtocolType.Tcp);
        IPEndPoint ipLocal = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2000);
        //Bind socket
        try
        {
            main_tcp_Sock.Bind(ipLocal);
            Console.WriteLine("Server has started successfully!");


            //Start listening
            main_tcp_Sock.Listen(100);
            while (true)
            {

                acceptDone.Reset();
                Console.WriteLine("Waiting for a connection...");

                //AsyncAccept
                main_tcp_Sock.BeginAccept(new AsyncCallback(On_Connect), main_tcp_Sock);
                acceptDone.WaitOne();
                Console.WriteLine("\nPress any button to continue...\n\n");
                Console.ReadKey(true);
            }
        }

        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }

    }

    public void On_Connect(IAsyncResult asyn)
    {

        try
        {

            Socket listener = (Socket)asyn.AsyncState;
            Socket handler = listener.EndAccept(asyn);
            acceptDone.Set();

            StateObject connection = new StateObject();
            connection.current_Socket = handler;

            if (!connection_List.Contains(connection))
            {
                lock (connection_List)
                {
                    connection_List.Add(connection);
                    connection.id = "00" + connection_List.Count.ToString() + " ";
                 }
            }
            recvDone.Reset();
            Receive(connection.current_Socket);
            recvDone.WaitOne();

            sendDone.Reset();
            Send(connection.current_Socket, response);
            sendDone.WaitOne();

            closeDone.Reset();
            Socket_Close(connection.current_Socket);
            closeDone.WaitOne();
        }

        catch (Exception e)
        {
            Console.WriteLine("On_Connect Error: {0}", e.ToString());
            Console.ReadKey(true);
        }
    }

    public void Receive(Socket handler)
        {
        try{
            StateObject connection = new StateObject();
            connection.current_Socket = handler;
            connection.current_Socket.BeginReceive(connection.data, 0, connection.data.Length, 0,
                new AsyncCallback(On_Receive), connection);
        }
        catch (Exception e){
        Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }

    }
    public void On_Receive(IAsyncResult asyn)
    {
        string content = "";
        string temp = "";
        StateObject connection = (StateObject)asyn.AsyncState;
        Socket handler = connection.current_Socket;
        int size = handler.EndReceive(asyn);


        Console.WriteLine("ConnID from receive: " + connection.id);
        if (size > 0)
        {
            temp += Encoding.ASCII.GetString(connection.data);
        }
        if (temp.IndexOf("<EOF>") > -1)
        {

            content += temp.Substring(0, temp.IndexOf("\0"));
            Console.WriteLine("Read {0} bytes from socket. \nMessage: {1}", content.Length, content);

            lock (connection_List)
            {
                foreach (StateObject conn in connection_List)
                {
                    if (conn != connection)
                    {
                    content.Insert(0, connection.id);
                    response = content;
                   }

                }
            }
            recvDone.Set();
        }
        else
        {
            handler.BeginReceive(connection.data, 0, connection.data.Length, 0, new AsyncCallback(On_Receive), connection);
        }

    }

    public void Send(Socket handler, String message)
    {
        byte[] data = Encoding.ASCII.GetBytes(message);
        handler.BeginSend(data, 0, data.Length, 0, new AsyncCallback(On_Send), handler);

    }

    public void On_Send(IAsyncResult result)
    {
        try
        {
            StateObject state = new StateObject();
            Socket handler = (Socket)result.AsyncState;
            state.current_Socket = handler;
            int size = state.current_Socket.EndSend(result);
            if (size > 0)
            {
                sendDone.Set();
            }

            else state.current_Socket.BeginSend(state.data, 0, state.data.Length, SocketFlags.None,
                new AsyncCallback(On_Send), state);
            Console.WriteLine("Bytes sent to client: {0}", size);

            sendDone.Set();
        }

        catch (Exception e)
        {
            Console.WriteLine("On_Send e, error: " + e.ToString());
             Console.ReadKey(true);
        }
    }
    public void Socket_Close(Socket sock)
    {
        sock.LingerState = new LingerOption(true, 3);

        sock.Shutdown(SocketShutdown.Both);
        sock.Close();
        closeDone.Set();
    }

}

И клиент:

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;

// State object for receiving data from remote device.
public class StateObject
{
    // Client socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 256;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}

public class AsynchronousClient
{
    public static int count = 0;

    // The port number for the remote device.
    private const int port = 2000;
    // ManualResetEvent instances signal completion.
    private static ManualResetEvent connectDone = new ManualResetEvent(false);
    private static ManualResetEvent sendDone = new ManualResetEvent(false);
    private static ManualResetEvent receiveDone = new ManualResetEvent(false);
    private static ManualResetEvent closeDone = new ManualResetEvent(false);
    // The response from the remote device.
    private static String response = String.Empty;

    private static void StartClient()
    {
        // Connect to a remote device.

        IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
        // Create a TCP/IP socket.
        Socket client = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);
        Start(client, remoteEP);

    }


    public static void Start(Socket client, EndPoint remoteEP)
    {
        try
        {
            while (true)
            {
                /*if (count >= 30)
                {

                    Thread.Sleep(1000);
                    if (count >= 100)
                    {
                        count = 0;
                        Thread.Sleep(1500);
                    }
                }*/

                Console.WriteLine(count);
                connectDone.Reset();
                client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
                connectDone.WaitOne();


                // Send test data to the remote device.
                sendDone.Reset();
                Send(client, "Some text and <EOF>");
                sendDone.WaitOne();

                // Receive the response from the remote device.
                receiveDone.Reset();
                Receive(client);
                receiveDone.WaitOne();

                // Write the response to the console.
                Console.WriteLine("Response received : {0}", response);

                // Release the socket.
                closeDone.Reset();
                Socket_Close(client);
                closeDone.WaitOne();

                ++count;
            }

        }
        catch (ObjectDisposedException)
        {
            Socket sock = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint remote = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);

            Start(sock, remote);

        }
        catch (SocketException)
        {
            Socket sock = new Socket(AddressFamily.InterNetwork,
                       SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint remote = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);

            Start(sock, remote);

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }
    }

    private static void ConnectCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket client = (Socket)ar.AsyncState;

            // Complete the connection.
            client.EndConnect(ar);

            Console.WriteLine("Socket connected to {0}",
                client.RemoteEndPoint.ToString());

            // Signal that the connection has been made.
            connectDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }
    }

    private static void Receive(Socket client)
    {
        try
        {
            // Create the state object.
            StateObject state = new StateObject();
            state.workSocket = client;

            // Begin receiving the data from the remote device.
            client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReceiveCallback), state);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);

        }
    }

    private static void ReceiveCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the state object and the client socket 
            // from the asynchronous state object.
            StateObject state = (StateObject)ar.AsyncState;
            Socket client = state.workSocket;

            // Read data from the remote device.
            int bytesRead = client.EndReceive(ar);

            if (bytesRead > 0)
            {
                // There might be more data, so store the data received so far.
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                // Get the rest of the data.
                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReceiveCallback), state);
            }
            else
            {
                // All the data has arrived; put it in response.
                if (state.sb.Length > 1)
                {
                    response = state.sb.ToString();
                }
                // Signal that all bytes have been received.
                receiveDone.Set();
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);

        }
    }

    private static void Send(Socket client, String data)
    {
        try
        {
            // Convert the string data to byte data using ASCII encoding.
            byte[] byteData = Encoding.ASCII.GetBytes(data);

            // Begin sending the data to the remote device.
            client.BeginSend(byteData, 0, byteData.Length, 0,
                new AsyncCallback(SendCallback), client);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }
    }

    private static void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket client = (Socket)ar.AsyncState;

            // Complete sending the data to the remote device.
            int bytesSent = client.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to server.", bytesSent);

            // Signal that all bytes have been sent.
            sendDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }
    }

    public static void Socket_Close(Socket sock)
    {
        try
        {
            sock.LingerState = new LingerOption(true, 3);
            sock.Shutdown(SocketShutdown.Both);
            sock.Close();
            closeDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
            Console.ReadKey(true);
        }
    }

    public static int Main(String[] args)
    {

        StartClient();
        return 0;
    }
}

Я новичок в C #. Пожалуйста, помогите кому-нибудь.

Answer 1

Стек - это очередь «последний пришел - первый вышел».Когда вы выполняете вызов функции, необходимо сохранить состояние, относящееся к функции, в которой вы находитесь (например, локальные переменные), чтобы программа могла обработать вызванную функцию.Когда вызываемая функция возвращается, состояние вызывающей функции должно быть восстановлено, поэтому она извлекается из стека.В обычных программах стек увеличивается по мере того, как вы вызываете все больше и больше глубоко вложенных функций, но затем снова уменьшается по мере их возврата.

Конечно, стек не безграничен, и на самом деле обычно выделяется фиксированный объем памяти, поэтому, если у вас есть программа, в которой уровень вызовов вложенных функций продолжает расти, в конечном итоге стек будет заполнен,и вы получите исключение переполнения стека.

Самый простой способ продемонстрировать это - написать функцию, которая всегда вызывает себя рекурсивно.Следующее всегда создаст переполнение стека:

private void blowTheStack(){
  blowTheStack();
}

Конечно, мы также можем писать рекурсивные программы без этой проблемы:

private void doSomethingUseful(){
  if (!terminatingConditionReached()){
    doSomethingUseful();
  }
}

, и это очень мощный метод.Трюк с написанием такого кода состоит в том, чтобы получить правильное условие завершения!

Когда все это происходит в одной функции, логика легко заметна, однако, вы также можете иметь аналогичную логику, когда одна функция вызывает другую,который вызывает другой, который вызывает первую функцию.

Когда вы работаете с кодом обработки событий, ситуация ухудшается, потому что вызовы функций больше не похожи на вызовы функций.Допустим, одна функция запускает условие, которое запускает обработчик события, а обработчик события запускает некоторый код, который вызывает первую функцию, у вас также будут циклические вызовы функций, и если условие завершения не является правильным, вы получите переполнение стека.,

В любом случае - я просто хочу +1 к вопросу, потому что речь идет о переполнении стека!

Answer 2

while (true) никогда не остановится ... вы должны сделать что-то вроде while (foo) { if (somecondition) foo=false }

РЕДАКТИРОВАТЬ: Может быть, этот учебник поможет

http://www.codeguru.com/csharp/csharp/cs_date_time/timeroutines/article.php/c7763

сниппет:

using System;
using System.Timers;

class myApp
{
  public static void Main()
  {
    Timer myTimer = new Timer();
    myTimer.Elapsed += new ElapsedEventHandler( DisplayTimeEvent );
    myTimer.Interval = 1000;
    myTimer.Start();

    while ( Console.Read() != 'q' )
    {
        ;    // do nothing...
    }
  }

  public static void DisplayTimeEvent( object source, ElapsedEventArgs e )
  {
      Console.Write("\r{0}", DateTime.Now);
  }
}