我正在用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＃的新手。请帮助别人。
答案 0 :(得分：1)
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);
}
}
答案 1 :(得分：1)
堆栈是后进先出队列。当您进行函数调用时，需要保存与您所在函数相关的状态（例如局部变量），以便程序可以处理被调用函数。当被调用函数返回时，必须恢复调用函数的状态，以便从堆栈中检索它。在普通程序中，当您调用越来越深的嵌套函数时，堆栈会增长，但随后会在它们返回时再次收缩。
当然，堆栈并非无限制，实际上通常会分配一定数量的内存，所以如果你有一个程序，嵌套函数调用的级别会不断增长，最终堆栈就会满了，你'将收到堆栈溢出异常。
最简单的方法是编写一个总是以递归方式调用自身的函数。以下将始终创建堆栈溢出：
private void blowTheStack(){
blowTheStack();
}
当然，我们也可以编写没有这个问题的递归程序：
private void doSomethingUseful(){
if (!terminatingConditionReached()){
doSomethingUseful();
}
}
这是一项非常强大的技术。编写此类代码的诀窍是让您的终止条件正确！
当这一切都发生在一个函数中时，逻辑很容易看到，但是，你也可以有一个类似的逻辑，其中一个函数调用另一个函数，调用另一个函数调用第一个函数。
当您处理事件处理代码时，它会变得更糟，因为函数调用看起来不再像函数调用那样。假设一个函数触发一个触发事件处理程序的条件，并且事件处理程序触发一些调用第一个函数的代码，你也会有循环函数调用，如果终止条件不正确，你会得到一个堆栈溢出。
无论如何 - 我只是想问一下这个问题，因为它是关于Stack Overflow的！