C#中Socket编程，异步实现Server端定时发送消息
在最近项目需求中，要求服务端定时向客服端发送消息。由于客户端从机的特性，只能接收Server发送的消息后回复，不能主动向服务端发送消息。
起初，并未使用异步的方法进行编程，使用了Accept()、Revice()等方法。由于从机不能主动发送消息的特性，并未考虑到从机断电不能接收到Server消息的情况，Server会因为没有消息返回导致线程阻塞，不能继续轮询发送。
之后，对程序进行改进，用异步的方式解决了问题。
Server端代码Demo：
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class NonBlockingServer
{
private const int bufferSize = 1024;
private byte[] sendBuffer = Encoding.UTF8.GetBytes("Hello, client!"); // Data to send to clients
private byte[] receiveBuffer = new byte[bufferSize]; // Data buffer to receive from clients
private Socket serverSocket;
private Timer timer;
private int sendCounter = 0;
private List<Socket> connectedClients = new List<Socket>(); // List to store connected client sockets
public void StartServer()
{
// Create a TCP/IP socket.
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint and start listening for incoming connections.
IPAddress ipAddress = IPAddress.Any; // Listen on all available interfaces
int port = 12345; // Choose any available port
IPEndPoint localEP = new IPEndPoint(ipAddress, port);
serverSocket.Bind(localEP);
serverSocket.Listen(10);
Console.WriteLine("Server started. Waiting for clients...");
// Start the timer to periodically send data to connected clients.
int intervalMilliseconds = 2000; // 2 seconds
timer = new Timer(TimerCallback, null, 0, intervalMilliseconds);
// Accept incoming connections asynchronously.
serverSocket.BeginAccept(AcceptCallback, null);
}
private void AcceptCallback(IAsyncResult ar)
{
try
{
// Get the socket that represents the new connection.
Socket clientSocket = serverSocket.EndAccept(ar);
// Continue accepting new connections.
serverSocket.BeginAccept(AcceptCallback, null);
// Add the new client socket to the list of connected clients.
connectedClients.Add(clientSocket);
// Start receiving data from the client asynchronously.
clientSocket.BeginReceive(receiveBuffer, 0, bufferSize, SocketFlags.None, ReceiveCallback, clientSocket);
}
catch (Exception ex)
{
Console.WriteLine($"Error accepting connection: {ex.Message}");
}
}
private void TimerCallback(object state)
{
try
{
// Send data to all connected clients asynchronously.
foreach (var clientSocket in connectedClients)
{
clientSocket.BeginSend(sendBuffer, 0, sendBuffer.Length, SocketFlags.None, SendCallback, clientSocket);
}
// Increment the send counter for tracking purposes.
sendCounter++;
// On the 5th transmission, send a special message to the client.
if (sendCounter == 5)
{
foreach (var clientSocket in connectedClients)
{
byte[] specialBuffer = Encoding.UTF8.GetBytes("Special message from server!");
clientSocket.BeginSend(specialBuffer, 0, specialBuffer.Length, SocketFlags.None, SendCallback, clientSocket);
}
sendCounter = 0; // Reset the counter for the next round.
}
}
catch (Exception ex)
{
Console.WriteLine($"Error sending data: {ex.Message}");
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
// Get the socket that represents the client.
Socket clientSocket = (Socket)ar.AsyncState;
// End the receive operation and get the number of bytes received.
int bytesRead = clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
// Process the received data (assuming it's text).
string receivedData = Encoding.UTF8.GetString(receiveBuffer, 0, bytesRead);
Console.WriteLine($"Received data from client: {receivedData}");
// Continue receiving more data.
clientSocket.BeginReceive(receiveBuffer, 0, bufferSize, SocketFlags.None, ReceiveCallback, clientSocket);
}
else
{
// If no data is received, the client closed the connection.
Console.WriteLine("Connection closed by the client.");
connectedClients.Remove(clientSocket);
clientSocket.Close();
}
}
catch (Exception ex)
{
Console.WriteLine($"Error receiving data: {ex.Message}");
}
}
private void SendCallback(IAsyncResult ar)
{
try
{
// End the send operation.
Socket clientSocket = (Socket)ar.AsyncState;
int bytesSent = clientSocket.EndSend(ar);
Console.WriteLine($"Sent {bytesSent} bytes to a client.");
}
catch (Exception ex)
{
Console.WriteLine($"Error sending data: {ex.Message}");
}
}
public static void Main(string[] args)
{
NonBlockingServer server = new NonBlockingServer();
server.StartServer();
// Keep the console application running until the user decides to exit.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
Client端代码Demo：
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class NonBlockingClient
{
private const int bufferSize = 1024;
private byte[] receiveBuffer = new byte[bufferSize]; // Data buffer to receive from the server
private Socket clientSocket;
public void StartClient()
{
// Create a TCP/IP socket.
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Set up the endpoint and connect to the server.
IPAddress ipAddress = IPAddress.Parse("127.0.0.1"); // Replace with the server IP address.
int port = 12345; // Replace with the server port number.
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
try
{
clientSocket.Connect(remoteEP);
Console.WriteLine("Connected to the server.");
// Start receiving data from the server asynchronously.
clientSocket.BeginReceive(receiveBuffer, 0, bufferSize, SocketFlags.None, ReceiveCallback, null);
// Prevent the client from exiting immediately.
// You can remove this line if you want the client to exit immediately after connecting.
Thread.Sleep(Timeout.Infinite);
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
clientSocket.Close();
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
// End the receive operation and get the number of bytes received.
int bytesRead = clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
// Process the received data (assuming it's text).
string receivedData = Encoding.UTF8.GetString(receiveBuffer, 0, bytesRead);
Console.WriteLine($"Received data from server: {receivedData}");
// Continue receiving more data.
clientSocket.BeginReceive(receiveBuffer, 0, bufferSize, SocketFlags.None, ReceiveCallback, null);
}
else
{
// If no data is received, the server closed the connection.
Console.WriteLine("Connection closed by the server.");
clientSocket.Close();
}
}
catch (Exception ex)
{
Console.WriteLine($"Error receiving data: {ex.Message}");
clientSocket.Close();
}
}
public static void Main(string[] args)
{
NonBlockingClient client = new NonBlockingClient();
client.StartClient();
}
}
