使用套接字从服务器向客户端发送值

我正在使用以下项目,以便在服务器和客户端套接字之间创建异步通信.当我运行这些项目时,我正在从客户端向服务器发送消息,因此我收到了消息:

数据:记录EOF,向客户端发送14个字节.

我想要实现的是使用套接字从服务器向客户端发送布尔变量.这样做是否可行,我想知道因为在代码中我有等待和监听的服务器以及发送数据的客户端,我可以这样做吗？一般来说,我想要的是向几个客户端发送一个布尔值.为什么我需要文件结束才能发送字符串？是否有必要将所有内容转换为字符串？

编辑:一般来说,我想要的是将一个变量从一台计算机发送到另外两台,以便在所有计算机上同时开始一个过程.事实上,要创建一个切换器,它可以同时在2-3台机器上发出信号.

我尝试将以下代码用于服务器:

class Program
{
    const int PORT_NO = 2201;
    const string SERVER_IP = "127.0.0.1";
    static void Main(string[] args)
    {
        //---listen at the specified IP and port no.---
        IPAddress localAdd = IPAddress.Parse(SERVER_IP);
        TcpListener listener = new TcpListener(localAdd, PORT_NO);
        Console.WriteLine("Listening...");
        listener.Start();
        //---incoming client connected---
        TcpClient client = listener.AcceptTcpClient();
        //---get the incoming data through a network stream---
        NetworkStream nwStream = client.GetStream();
        byte[] buffer = new byte[client.ReceiveBufferSize];
        //---read incoming stream---
        int bytesRead = nwStream.Read(buffer, 0, client.ReceiveBufferSize);
        //---convert the data received into a string---
        string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
        Console.WriteLine("Received : " + dataReceived);
        //---write back the text to the client---
        Console.WriteLine("Sending back : " + dataReceived);
        nwStream.Write(buffer, 0, bytesRead);
        client.Close();
        listener.Stop();
        Console.ReadLine();
    }
}

并为客户:

class Program
{
    const int PORT_NO = 2201;
    const string SERVER_IP = "127.0.0.1";
    static void Main(string[] args)
    {
        //---data to send to the server---
        string textToSend = DateTime.Now.ToString();
        //---create a TCPClient object at the IP and port no.---
        TcpClient client = new TcpClient(SERVER_IP, PORT_NO);
        NetworkStream nwStream = client.GetStream();
        byte[] bytesToSend = ASCIIEncoding.ASCII.GetBytes(textToSend);
        //---send the text---
        Console.WriteLine("Sending : " + textToSend);
        nwStream.Write(bytesToSend, 0, bytesToSend.Length);
        //---read back the text---
        byte[] bytesToRead = new byte[client.ReceiveBufferSize];
        int bytesRead = nwStream.Read(bytesToRead, 0, client.ReceiveBufferSize);
        Console.WriteLine("Received : " + Encoding.ASCII.GetString(bytesToRead, 0, bytesRead));
        Console.ReadLine();
        client.Close();
    }
}

就在我在同一台机器上工作的情况.我将共有4台机器,我希望其中一台机器给其他人一个信号,开始录制rgb流.因此,服务器应该向客户端发送信号以开始记录.我该怎么做才能改变服务器发送数据而不是监听的行为.有几台机器可以监听并等待发出信号吗？

编辑:

private void mouseClick1(object sender, MouseEventArgs e)
    {

        Thread thread = new Thread(() => StartServer());
        thread.Start();

        if (e.Button == MouseButtons.Left)
        {
            button5.Enabled = false;
            button3.Enabled = true;

            try
            {
                obj = new Capturer();
            }
            catch (Exception e1)
            {
                Console.WriteLine("The process failed: {0}", e1.ToString());
            }
        }
    }

    private void mouseClick2(object sender, MouseEventArgs e)
    {
        if (e.Button == MouseButtons.Right)
        {
            obj.flag2 = true;
        }
    }

我的代码现在是左键单击调用startServer()函数,带有一个新线程,这是@Ians实现中的主要代码,然后调用我的对象.当我单击右键单击时,我更改了一个标志,捕获器停止.如何通过左键单击停止服务器或暂停以再次打开它？

Answers to the questions first:

Q: Is it necessary to convert everything to string?...In general what I want is to send a variable from one computer to two others in order a process to begin simultaneously in all computers.

A: No, it is not necessary to convert everything to string when sending using Socket. You may send byte[] which you most probably want.

Q: What I want to achieve is to send a boolean variable from the server to the client with the sockets

A: Do you mean boolean or byte? Because the basic variable type which you will get from the Socket is byte. You could always change byte to bool from the sender/receiver side by doing like

bool val = byteToCheck > 0;

A2: And since your server is Console Application, I recommend to take a look on hex string to byte[] conversion. This way, you could write something in string but interprets it as byte[]. Check this. The whole idea here is pretty simple. That is: you type in string, but it will be sent as byte[]. And since it is byte[] you can have any value in it.

And here I present my solution to handle your (1) multiple clients, (2) Async connect & accept & receive, but having (3) send sync, as well as (4) conversion from hex string to byte[] (the structure & idea), and last but not least (5) working code with user input (for you to change this part) for testing!

我会用简单的Socket类来解决这个问题,因为它是我最熟悉的解决方案.但是如果你使用你的TcpListener.Server(这是Socket类的底层网络),你总是可以做类似的事情.而且,正如你所愿,我会这样做ASync.

在服务器和客户端中实现所需的步骤需要几个步骤:

服务器

使你的Socket类字段而不是方法字段,因为你将使用if无处不在,你需要多种方法来实现你想要的.并在您开始主程序时立即初始化它.

const int PORT_NO = 2201;
const string SERVER_IP = "127.0.0.1";
static Socket serverSocket; //put here as static
static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    //your next main routine
}

由于服务器将为许多客户端提供服务,因此我建议您使用ASync而不是Sync使用该过程.Socket通过使用BeginAccept而不是使用来初始化您Accept,放入 acceptCallback您的BeginAccept

static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      
    //other stuffs
}

Define acceptCallback, which is where you will go when you accept a Socket. Put EndAccept there.

private void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
    System.Net.Sockets.Socket socket = null;
    try {
        socket = serverSocket.EndAccept(result); // To get your client socket
        //do something later
    } catch (Exception e) { // this exception will happen when "this" is be disposed...        
        //do something later
    }
}

I would typically list my client sockets, and do something on client disposal (that is unlisted it) - but this depends on the need. In this case, you seem to need it. And don't forget to create buffers, etc... This is for buffering the incoming data.

Start to accept something received from the client, using another ASync BeginReceive on the client Socket (and now you need receiveCallback). Then, very important, repeat your BeginAccept to accept other clients!

private const int BUFFER_SIZE = 4096;
private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
private static List clientSockets = new List(); //may be needed by you
private static void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
    Socket socket = null;
    try {
        socket = serverSocket.EndAccept(result); // The objectDisposedException will come here... thus, it is to be expected!
        //Do something as you see it needs on client acceptance such as listing
        clientSockets.Add(socket); //may be needed later
        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
        serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null); //to receive another client
    } catch (Exception e) { // this exception will happen when "this" is be disposed...        
        //Do something here
        Console.WriteLine(e.ToString());
    }
}

定义您的receiveCallback,即从您的客户收到的东西.由于失败,这部分可能非常棘手!但基本上,你现在需要的是EndReceive一次又一次,非常重要,重复BeginReceive来自同一个客户端,以便你可以收到它的下一条消息!

const int MAX_RECEIVE_ATTEMPT = 10;
static int receiveAttempt = 0; //this is not fool proof, obviously, since actually you must have multiple of this for multiple clients, but for the sake of simplicity I put this
private static void receiveCallback(IAsyncResult result) {
    Socket socket = null;
    try {
        socket = (Socket)result.AsyncState; //this is to get the sender
        if (socket.Connected) { //simple checking
            int received = socket.EndReceive(result);
            if (received > 0) {
                byte[] data = new byte[received]; //the data is in the byte[] format, not string!
                Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //There are several way to do this according to /sf/ask/17360801/ in general, System.Buffer.memcpyimpl is the fastest
                //DO SOMETHING ON THE DATA IN byte[] data!! Yihaa!!
                Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else
                receiveAttempt = 0; //reset receive attempt
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
            } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //fail but not exceeding max attempt, repeats
                ++receiveAttempt; //increase receive attempt;
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
            } else { //completely fails!
                Console.WriteLine("receiveCallback fails!"); //don't repeat beginReceive
                receiveAttempt = 0; //reset this for the next connection
            }
        }
    } catch (Exception e) { // this exception will happen when "this" is be disposed...
        Console.WriteLine("receiveCallback fails with exception! " + e.ToString());
    }
}

并且假设您希望在收到消息后回复发件人,只需在if (received > 0)部分中执行此操作:

if (received > 0) {
    byte[] data = new byte[received]; //the data is in the byte[] format, not string!
    //DO SOMETHING ON THE DATA int byte[]!! Yihaa!!
    Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else                     

    //Message retrieval part
    //Suppose you only want to declare that you receive data from a client to that client
    string msg = "I receive your message on: " + DateTime.Now;
    socket.Send(Encoding.ASCII.GetBytes(msg)); //Note that you actually send data in byte[]
    Console.WriteLine("I sent this message to the client: " + msg);

    receiveAttempt = 0; //reset receive attempt
    socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
}

在你的主程序中添加了一些东西后,你就完成了(!) - 如果你没有要求发送给客户端byte[]

现在,如果您想向所有客户发送内容,byte[]只需要列出所有客户端(请参阅步骤4-5).看到这个并转换result string上面的内容(记得string根据需要以十六进制格式输入),byte[]然后使用客户端套接字列表将其发送给所有客户端(这里是需要的地方!):

static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      

    //normally, there isn't anything else needed here
    string result = "";
    do {
        result = Console.ReadLine();
        if (result.ToLower().Trim() != "exit") {
            byte[] bytes = null;
            //you can use `result` and change it to `bytes` by any mechanism which you want
            //the mechanism which suits you is probably the hex string to byte[]
            //this is the reason why you may want to list the client sockets
            foreach(Socket socket in clientSockets)
                socket.Send(bytes); //send everything to all clients as bytes
        }
    } while (result.ToLower().Trim() != "exit");
}

在这里,您或多或少地完成了您的服务器.接下来是您的客户

客户:

同样,将Socket类放在类上下文而不是方法上下文中,并在启动程序后立即对其进行初始化

const int PORT_NO = 2201;
const string SERVER_IP = "127.0.0.1";
static Socket clientSocket; //put here
static void Main(string[] args) {
    //Similarly, start defining your client socket as soon as you start. 
    clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

    //your other main routines
}

然后开始连接ASync BeginConnect.我通常会LoopConnect因为这样的失败处理而走得更远.

static void loopConnect(int noOfRetry, int attemptPeriodInSeconds) {
    int attempts = 0;
    while (!clientSocket.Connected && attempts < noOfRetry) {
        try {
            ++attempts;
            IAsyncResult result = clientSocket.BeginConnect(IPAddress.Parse(SERVER_IP), PORT_NO, endConnect, null);
            result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(attemptPeriodInSeconds));
            System.Threading.Thread.Sleep(attemptPeriodInSeconds * 1000);
        } catch (Exception e) {
            Console.WriteLine("Error: " + e.ToString());
        }
    }
    if (!clientSocket.Connected) {
        Console.WriteLine("Connection attempt is unsuccessful!");
        return;
    }
}

Similar concept to what you do to the server BeginAccept you need to define endConnectCallback for the ASync BeginConnect you use. But here, unlike server which needs to re-calling BeginAccept, once you are connected, you do not need to do any new BeginConnect since you only need to be connected once.

You may want to declare buffer etc. Then, after you connect, don't forget the next ASync BeginReceive to handle the message retrieval part (similar with the server)

private const int BUFFER_SIZE = 4096;
private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
private static void endConnectCallback(IAsyncResult ar) {
    try {
        clientSocket.EndConnect(ar);
        if (clientSocket.Connected) {
            clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), clientSocket);
        } else {
            Console.WriteLine("End of connection attempt, fail to connect...");
        }
    } catch (Exception e) {
        Console.WriteLine("End-connection attempt is unsuccessful! " + e.ToString());
    }
}

Naturally, you need to define your receiveCallback, just like what you did for the server. And yes, it is as you have guessed, it is almost identical to what you did for the server!

You can do anything you want with your data. Note that the data you receive is actually in byte[], not string. So you can do anything with it. But for example's sake, I will just use string to display.

const int MAX_RECEIVE_ATTEMPT = 10;
static int receiveAttempt = 0;
private static void receiveCallback(IAsyncResult result) {
    System.Net.Sockets.Socket socket = null;
    try {
        socket = (System.Net.Sockets.Socket)result.AsyncState;
        if (socket.Connected) {
            int received = socket.EndReceive(result);
            if (received > 0) {
                receiveAttempt = 0;
                byte[] data = new byte[received];
                Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //copy the data from your buffer
                //DO ANYTHING THAT YOU WANT WITH data, IT IS THE RECEIVED PACKET!
                //Notice that your data is not string! It is actually byte[]
                //For now I will just print it out
                Console.WriteLine("Server: " + Encoding.UTF8.GetString(data));
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
            } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //not exceeding the max attempt, try again
                ++receiveAttempt;
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
            } else { //completely fails!
                Console.WriteLine("receiveCallback is failed!");
                receiveAttempt = 0;
                clientSocket.Close();
            }
        }
    } catch (Exception e) { // this exception will happen when "this" is be disposed...
        Console.WriteLine("receiveCallback is failed! " + e.ToString());
    }
}

And at the very very last... Yes, again, as you have already guessed, you just need to do something on your main routine - suppose you want to use it to send data. Because you use Console but you want it to send things as byte[], you need to do the conversion (see the explanation in server 9.). And afterwards you are completely done!!

static void Main(string[] args) {
    //Similarly, start defining your client socket as soon as you start. 
    clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    loopConnect(3, 3); //for failure handling
    string result = "";
    do {
        result = Console.ReadLine(); //you need to change this part
        if (result.ToLower().Trim() != "exit") {
            byte[] bytes = Encoding.ASCII.GetBytes(result); //Again, note that your data is actually of byte[], not string
            //do something on bytes by using the reference such that you can type in HEX STRING but sending thing in bytes
            clientSocket.Send(bytes);
        }
    } while (result.ToLower().Trim() != "exit");
}

Results:

Here you go! I tested it by sending string for display, but I already put up what is needed when you want to change it to byte[]

Code for your test:

Server

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

namespace TcpListenerConsoleApplication {
    class Program {
        const int PORT_NO = 2201;
        const string SERVER_IP = "127.0.0.1";
        static Socket serverSocket;
        static void Main(string[] args) {
            //---listen at the specified IP and port no.---
            Console.WriteLine("Listening...");
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
            serverSocket.Listen(4); //the maximum pending client, define as you wish
            serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      
            string result = "";
            do {
                result = Console.ReadLine();
            } while (result.ToLower().Trim() != "exit");
        }

        private const int BUFFER_SIZE = 4096;
        private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
        private static void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
            Socket socket = null;
            try {
                socket = serverSocket.EndAccept(result); // The objectDisposedException will come here... thus, it is to be expected!
                //Do something as you see it needs on client acceptance
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
                serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null); //to receive another client
            } catch (Exception e) { // this exception will happen when "this" is be disposed...        
                //Do something here             
                Console.WriteLine(e.ToString());
            }
        }

        const int MAX_RECEIVE_ATTEMPT = 10;
        static int receiveAttempt = 0; //this is not fool proof, obviously, since actually you must have multiple of this for multiple clients, but for the sake of simplicity I put this
        private static void receiveCallback(IAsyncResult result) {
            Socket socket = null;
            try {
                socket = (Socket)result.AsyncState; //this is to get the sender
                if (socket.Connected) { //simple checking
                    int received = socket.EndReceive(result);
                    if (received > 0) {
                        byte[] data = new byte[received]; //the data is in the byte[] format, not string!
                        Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //There are several way to do this according to /sf/ask/17360801/ in general, System.Buffer.memcpyimpl is the fastest
                        //DO SOMETHING ON THE DATA int byte[]!! Yihaa!!
                        Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else                     

                        //Message retrieval part
                        //Suppose you only want to declare that you receive data from a client to that client
                        string msg = "I receive your message on: " + DateTime.Now;                      
                        socket.Send(Encoding.ASCII.GetBytes(msg)); //Note that you actually send data in byte[]
                        Console.WriteLine("I sent this message to the client: " + msg);

                        receiveAttempt = 0; //reset receive attempt
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
                    } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //fail but not exceeding max attempt, repeats
                        ++receiveAttempt; //increase receive attempt;
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
                    } else { //completely fails!
                        Console.WriteLine("receiveCallback fails!"); //don't repeat beginReceive
                        receiveAttempt = 0; //reset this for the next connection
                    }
                }
            } catch (Exception e) { // this exception will happen when "this" is be disposed...
                Console.WriteLine("receiveCallback fails with exception! " + e.ToString());
            }
        }

    }
}

Client

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

namespace TcpClientConsoleApplication {
    class Program {
        const int PORT_NO = 2201;
        const string SERVER_IP = "127.0.0.1";
        static Socket clientSocket; //put here
        static void Main(string[] args) {
            //Similarly, start defining your client socket as soon as you start. 
            clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            loopConnect(3, 3); //for failure handling
            string result = "";
            do {
                result = Console.ReadLine(); //you need to change this part
                if (result.ToLower().Trim() != "exit") {
                    byte[] bytes = Encoding.ASCII.GetBytes(result); //Again, note that your data is actually of byte[], not string
                    //do something on bytes by using the reference such that you can type in HEX STRING but sending thing in bytes
                    clientSocket.Send(bytes);
                }
            } while (result.ToLower().Trim() != "exit");
        }

        static void loopConnect(int noOfRetry, int attemptPeriodInSeconds) {
            int attempts = 0;
            while (!clientSocket.Connected && attempts < noOfRetry) {
                try {
                    ++attempts;
                    IAsyncResult result = clientSocket.BeginConnect(IPAddress.Parse(SERVER_IP), PORT_NO, endConnectCallback, null);
                    result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(attemptPeriodInSeconds));
                    System.Threading.Thread.Sleep(attemptPeriodInSeconds * 1000);
                } catch (Exception e) {
                    Console.WriteLine("Error: " + e.ToString());
                }
            }
            if (!clientSocket.Connected) {
                Console.WriteLine("Connection attempt is unsuccessful!");
                return;
            }
        }

        private const int BUFFER_SIZE = 4096;
        private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
        private static void endConnectCallback(IAsyncResult ar) {
            try {
                clientSocket.EndConnect(ar);
                if (clientSocket.Connected) {
                    clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), clientSocket);
                } else {
                    Console.WriteLine("End of connection attempt, fail to connect...");
                }
            } catch (Exception e) {
                Console.WriteLine("End-connection attempt is unsuccessful! " + e.ToString());
            }
        }

        const int MAX_RECEIVE_ATTEMPT = 10;
        static int receiveAttempt = 0;
        private static void receiveCallback(IAsyncResult result) {
            System.Net.Sockets.Socket socket = null;
            try {
                socket = (System.Net.Sockets.Socket)result.AsyncState;
                if (socket.Connected) {
                    int received = socket.EndReceive(result);
                    if (received > 0) {
                        receiveAttempt = 0;
                        byte[] data = new byte[received];
                        Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //There are several way to do this according to /sf/ask/17360801/ in general, System.Buffer.memcpyimpl is the fastest
                        //DO ANYTHING THAT YOU WANT WITH data, IT IS THE RECEIVED PACKET!
                        //Notice that your data is not string! It is actually byte[]
                        //For now I will just print it out
                        Console.WriteLine("Server: " + Encoding.UTF8.GetString(data));
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
                    } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //not exceeding the max attempt, try again
                        ++receiveAttempt;
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
                    } else { //completely fails!
                        Console.WriteLine("receiveCallback is failed!");
                        receiveAttempt = 0;
                        clientSocket.Close();
                    }
                }
            } catch (Exception e) { // this exception will happen when "this" is be disposed...
                Console.WriteLine("receiveCallback is failed! " + e.ToString());
            }
        }
    }
}

Last Remarks (Edit)

Since the code above is run using Console Application it must be run with static main void keyword. And thus client Socket defined above is of static type. This may prevent the client Socket to be defined multiple times as each time it is "defined", since it is of the same class named Program, it will refer to the same Socket (though this may not always the case, at least according to the OP's experiment: he can run multiple clients successfully in the same computer).

Nevertheless, to overcome this is not that hard. Simply port the client application to the platform which is non-initiated as static class (such as WinForms) and all the above code would still run as per normal. Alternatively, if it must be run using the Console Applications, and the problem occurs, simply copy the client application and re-define it using different namespace or different class name to avoid defining identical Socket due to identical namespace or class.

But the most important part on this problem solving is the use of Async and Sync wisely to solve the given issue.

Continuation of this topic can be found here

为什么不让您的生活更轻松并使用SignalR？
在下面，您可以看到一个简单的示例，其中服务器和客户端是控制台应用程序

客户端（多次运行此.exe）

using System;
using Microsoft.AspNet.SignalR.Client;

namespace SignalRClient
{
    class Program
    {
        private static IHubProxy HubProxy { get; set; }
        const string ServerURI = "http://localhost:1234/signalr";
        private static HubConnection Connection { get; set; }

        static void Main(string[] args)
        {
            Connection = new HubConnection(ServerURI);
            HubProxy = Connection.CreateHubProxy("MyHub");

            HubProxy.On("SendMessage", (name, message) => Console.WriteLine(name + ":" + message));
            Connection.Start().Wait();

            Console.WriteLine("Press Enter to stop client");
            Console.ReadLine();
        }
    }
}

服务器（在运行客户端之前运行此.exe）

using System;
using System.Threading.Tasks;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Client;
using Microsoft.Owin.Hosting;
using Owin;

namespace SignalRServer
{
    class Program
    {
        static private IDisposable SignalR { get; set; }
        const string ServerURI = "http://localhost:1234";
        private static IHubProxy HubProxy { get; set; }
        private static HubConnection Connection { get; set; }
        static void Main(string[] args)
        {
            SignalR = WebApp.Start(ServerURI);
            Console.WriteLine("Server running at " + ServerURI);

            Connection = new HubConnection(ServerURI);
            HubProxy = Connection.CreateHubProxy("MyHub");
            HubProxy.On("SendMessage", (name, message) => Console.WriteLine(name + ":" + message));
            Connection.Start().Wait();

            string messageToSentToClients;
            do
            {
                Console.WriteLine("Type someting to send to clients and press enter");
                messageToSentToClients = Console.ReadLine();
               HubProxy.Invoke("Send", "Server", messageToSentToClients);
           } while (messageToSentToClients != "exit");

       }
    }

    public class MyHub : Hub
    {
        public void Send(string name, string message) { Clients.All.sendMessage(name, message); }
    }

    class Startup
    {
        public void Configuration(IAppBuilder app) { app.MapSignalR(); }
    }
}

为了使上述工作正常，您需要以下NuGet软件包：

客户端：
Microsoft.AspNet.SignalR.Client
服务器
Microsoft.AspNet.SignalR
Microsoft.AspNet.SignalR.Client
Microsoft.AspNet.SignalR.SelfHost
Microsoft.Owin.Host.HttpListener

如果您希望服务器/客户端位于不同的计算机上，那么您要做的就是更改两个项目中的ServeURI属性：

//Clients
const string ServerURI = "http://SERVER_IP:PORT/signalr";
//Server
const string ServerURI = "http://SERVER_IP:PORT"; 

您可以在WinForms中找到另一个类似的示例：https :
//code.msdn.microsoft.com/windowsdesktop/Using-SignalR-in-WinForms-f1ec847b