C#实现方式高效异步Socket通信项目实用指南

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

class Program
{
    static void Main()
    {
        try
        {
            // 创建一个 TCP/IP socket.
            Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // 连接到远程设备.
            client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000));
            // 发送数据.
            string message = "Hello, Server!";
            byte[] data = Encoding.ASCII.GetBytes(message);
            int bytesSent = client.Send(data);
            Console.WriteLine("Sent " + bytesSent + " bytes to server.");

            // 接收数据.
            data = new byte[256];
            int bytesRec = client.Receive(data);
            string responseData = Encoding.ASCII.GetString(data, 0, bytesRec);
            Console.WriteLine("Received: " + responseData);
            // 关闭连接.
            client.Shutdown(SocketShutdown.Both);
            client.Close();
        }
        catch (ArgumentNullException ane)
        {
            Console.WriteLine("ArgumentNullException : {0}", ane.ToString());
        }
        catch (SocketException se)
        {
            Console.WriteLine("SocketException : {0}", se.ToString());
        }
    }
}

Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

SocketAsyncEventArgs connectArgs = new SocketAsyncEventArgs();
connectArgs.Completed += (s, e) =>
{
    if (e.SocketError == SocketError.Success)
    {
        // 连接成功，进行下一步操作
    }
    else
    {
        // 处理连接错误
    }
};

connectArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Parse("远程服务器IP"), 端口号);

clientSocket.ConnectAsync(connectArgs);

SocketAsyncEventArgs sendArgs = new SocketAsyncEventArgs();
sendArgs.Completed += (s, e) =>
{
    if (e.SocketError == SocketError.Success)
    {
        // 数据发送成功
    }
    else
    {
        // 处理发送错误
    }
};

byte[] dataToSend = 编码后的数据;
sendArgs.SetBuffer(dataToSend, 0, dataToSend.Length);

clientSocket.SendAsync(sendArgs);

class AsyncSocketServer
{
    private Socket listener;

    public AsyncSocketServer(int port)
    {
        listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        listener.Bind(new IPEndPoint(IPAddress.Any, port));
        listener.Listen(100); // 最大数量
    }

    public void Start()
    {
        BeginAccept();
    }

    private void BeginAccept()
    {
        SocketAsyncEventArgs acceptArgs = new SocketAsyncEventArgs();
        acceptArgs.Completed += (s, e) =>
        {
            if (e.SocketError == SocketError.Success)
            {
                Socket clientSocket = e.AcceptSocket;
                // 处理客户端连接，例如开始接收数据
                BeginReceive(clientSocket);
            }
            else
            {
                // 处理接受连接错误
            }
            // 继续接受下一个连接
            BeginAccept();
        };
        listener.AcceptAsync(acceptArgs);
    }

    private void BeginReceive(Socket clientSocket)
    {
        SocketAsyncEventArgs receiveArgs = new SocketAsyncEventArgs();
        receiveArgs.Completed += (s, e) =>
        {
            if (e.SocketError == SocketError.Success)
            {
                // 接收到数据，处理数据...
            }
            else
            {
                // 处理接收数据错误
            }
            // 继续接收下一批数据
            BeginReceive(clientSocket);
        };

        receiveArgs.SetBuffer(new byte[1024], 0, 1024); // 设置缓冲区大小

        clientSocket.ReceiveAsync(receiveArgs);
    }
}

// 创建并启动服务器实例
AsyncSocketServer server = new AsyncSocketServer(8888);
server.Start();

class AsyncSocketClient
{
    private Socket clientSocket;

    public AsyncSocketClient(string server, int port)
    {
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    }

    public async Task ConnectAsync()
    {
        await clientSocket.ConnectAsync(new IPEndPoint(IPAddress.Parse(server), port));
        // 连接成功后，可以开始发送和接收数据
    }

    public void BeginSend(byte[] data)
    {
        SocketAsyncEventArgs sendArgs = new SocketAsyncEventArgs();
        sendArgs.Completed += (s, e) =>
        {
            if (e.SocketError != SocketError.Success)
            {
                // 发送错误处理
            }
            // 继续发送下一批数据
        };
        sendArgs.SetBuffer(data, 0, data.Length);
        clientSocket.SendAsync(sendArgs);
    }

    public void BeginReceive()
    {
        SocketAsyncEventArgs receiveArgs = new SocketAsyncEventArgs();
        receiveArgs.Completed += (s, e) =>
        {
            if (e.SocketError == SocketError.Success)
            {
                // 接收到数据，处理数据...
            }
            else
            {
                // 接收错误处理
            }
            // 继续接收下一批数据
            BeginReceive();
        };
        receiveArgs.SetBuffer(new byte[1024], 0, 1024);
        clientSocket.ReceiveAsync(receiveArgs);
    }
}

// 创建并连接客户端实例
AsyncSocketClient client = new AsyncSocketClient("127.0.0.1", 8888);
client.ConnectAsync().Wait();
client.BeginSend(编码后的数据);
client.BeginReceive();

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

public class SocketServer
{
    public void StartListening(int port)
    {
        var listener = new TcpListener(IPAddress.Any, port);
        listener.Start();
        Console.WriteLine($"Server started and listening on port {port}...");

        while (true)
        {
            // Blocks until a client has connected to the server
            var client = listener.AcceptTcpClient();
            Console.WriteLine("Client connected.");

            // Handle client in a new thread or async
            HandleClientAsync(client);
        }
    }

    private void HandleClientAsync(TcpClient client)
    {
        // Implementation of handling client connection asynchronously
    }
}

private async Task HandleClientAsync(TcpClient client)
{
    NetworkStream stream = client.GetStream();

    byte[] buffer = new byte[1024];
    int bytesRead;

    try
    {
        while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) != 0)
        {
            // Process the received data here

            // Send data back to the client if necessary
            // await stream.WriteAsync(responseData, 0, responseData.Length);
        }
    }
    catch (Exception e)
    {
        // Handle exceptions for the network stream
    }
    finally
    {
        // Cleanup the client resources
        client.Close();
    }
}

using System;
using System.Net.Sockets;

public class AsyncClient
{
    private Socket clientSocket;

    public AsyncClient()
    {
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    }

    public void ConnectToServer(string ipAddress, int port)
    {
        IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(ipAddress), port);
        clientSocket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), clientSocket);
    }

    private 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 " + client.RemoteEndPoint.ToString());
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    // Additional methods...
}

// 代码示例（发送数据）
byte[] buffer = Encoding.UTF8.GetBytes("Hello, Server!");
clientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallback), clientSocket);

// 代码示例（接收数据）
private void ReceiveCallback(IAsyncResult ar)
{
    try
    {
        Socket client = (Socket)ar.AsyncState;
        int received = client.EndReceive(ar);
        if (received > 0)
        {
            // Handle the received data
            byte[] receivedData = new byte[received];
            Array.Copy(receivedBuffer, receivedData, received);
            string receivedText = Encoding.UTF8.GetString(receivedData);

            // Continue receiving data
            client.BeginReceive(receivedBuffer, 0, receivedBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), client);
        }
        else
        {
            // The remote end has closed the connection
            Console.WriteLine("The connection has been closed.");
        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e.ToString());
    }
}

public class AsyncClientExample
{
    private Socket clientSocket;
    private byte[] receiveBuffer = new byte[1024];

    public AsyncClientExample()
    {
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    }

    public void ConnectToServer(string ipAddress, int port)
    {
        try
        {
            IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(ipAddress), port);
            clientSocket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), this);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private void ConnectCallback(IAsyncResult ar)
    {
        AsyncClientExample clientInstance = (AsyncClientExample)ar.AsyncState;
        try
        {
            clientInstance.clientSocket.EndConnect(ar);
            Console.WriteLine("Connected to server");
            clientInstance.StartReceiving();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private void StartReceiving()
    {
        clientSocket.BeginReceive(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), this);
    }

    private void ReceiveCallback(IAsyncResult ar)
    {
        AsyncClientExample clientInstance = (AsyncClientExample)ar.AsyncState;
        try
        {
            int received = clientInstance.clientSocket.EndReceive(ar);
            if (received > 0)
            {
                // Process the received data
                string receivedData = Encoding.UTF8.GetString(clientInstance.receiveBuffer, 0, received);
                Console.WriteLine("Data received: " + receivedData);

                // Continue receiving data
                clientInstance.StartReceiving();
            }
            else
            {
                // The remote end has closed the connection
                Console.WriteLine("The connection has been closed.");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    public void SendMessage(string message)
    {
        byte[] data = Encoding.UTF8.GetBytes(message);
        clientSocket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), this);
    }

    private void SendCallback(IAsyncResult ar)
    {
        try
        {
            AsyncClientExample clientInstance = (AsyncClientExample)ar.AsyncState;
            clientInstance.clientSocket.EndSend(ar);
            Console.WriteLine("Message sent");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    // Methods to close the socket and clean resources...
}

try
{
    // 尝试执行的代码
}
catch (ExceptionType ex)
{
    // 处理特定类型的异常
}
finally
{
    // 无论是否捕获异常，都将执行的清理代码
}

Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

try
{
    // 连接服务器
    socket.Connect(ipAddress, port);
}
catch (SocketException ex)
{
    // 处理连接时的异常
    Console.WriteLine("SocketException: " + ex.Message);
}
catch (Exception ex)
{
    // 处理其他可能的异常
    Console.WriteLine("Exception: " + ex.Message);
}
finally
{
    // 清理资源
    socket.Close();
}

try
{
    // 尝试执行可能引发异常的代码
}
catch (SocketException ex)
{
    // 特定异常处理
    Console.WriteLine("Socket exception: " + ex.Message);
    // 关闭Socket以防止资源泄露
    socket.Close();
}
catch (Exception ex)
{
    // 其他异常处理
    Console.WriteLine("General exception: " + ex.Message);
}