C# 网络编程--基础核心内容

在现今软件开发中，网络编程是非常重要的一部分，本文简要介绍下网络编程的概念和实践。
C#网络编程的主要内容包括以下几个方面‌：
:
上图引用大佬的图，大家也关注一下，有技术有品质，有国有家，情怀满满的杨老师（不得不去仰慕一番哈哈）
https://blog.csdn.net/Eastmount/article/details/9321153

1. 底层网络协议类‌

如NetworkStream、TcpClient与TcpListener、UdpClient等，这些类提供了更底层的网络操作接口，适用于需要直接控制网络连接和数据处理的情况‌

1. TCP 通信

使用 TcpListener 和 TcpClient 进行 通讯

• TCP 服务器端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class TcpServerExample
{static async Task Main(string[] args){// 创建一个 TCP/IP 套接字TcpListener listener = new TcpListener(IPAddress.Any, 13000);listener.Start();Console.WriteLine("Server started. Waiting for connections...");while (true){// 接受传入连接TcpClient client = await listener.AcceptTcpClientAsync();Console.WriteLine("Client connected.");// 处理客户端请求_ = HandleClient(client);}}static async Task HandleClient(TcpClient client){try{NetworkStream stream = client.GetStream();// 接收数据byte[] buffer = new byte[256];int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);string request = Encoding.ASCII.GetString(buffer, 0, bytesRead);Console.WriteLine("Received: " + request);// 发送响应string response = "Hello, Client!";byte[] responseData = Encoding.ASCII.GetBytes(response);await stream.WriteAsync(responseData, 0, responseData.Length);Console.WriteLine("Sent: " + response);// 关闭连接client.Close();}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

• TCP 客户端示例

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class TcpClientExample
{static async Task Main(string[] args){try{// 创建一个 TCP/IP 套接字TcpClient client = new TcpClient();await client.ConnectAsync("127.0.0.1", 13000);Console.WriteLine("Connected to server.");NetworkStream stream = client.GetStream();// 发送数据string message = "Hello, Server!";byte[] data = Encoding.ASCII.GetBytes(message);await stream.WriteAsync(data, 0, data.Length);Console.WriteLine("Sent: " + message);// 接收响应byte[] buffer = new byte[256];int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);string response = Encoding.ASCII.GetString(buffer, 0, bytesRead);Console.WriteLine("Received: " + response);// 关闭连接client.Close();}catch (Exception e){Console.WriteLine("Error: " + e.Message);}}
}

2. UDP 通信

使用 UdpClient 进行通讯

• UDP 服务器端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class UdpServerExample
{static async Task Main(string[] args){// 创建一个 UDP/IP 套接字UdpClient listener = new UdpClient(11000);IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);Console.WriteLine("UDP Server started. Listening on port 11000...");while (true){// 接收数据byte[] buffer = await listener.ReceiveAsync();string request = Encoding.ASCII.GetString(buffer);Console.WriteLine("Received: " + request + " from " + remoteEndPoint.ToString());// 发送响应string response = "Hello, Client!";byte[] responseData = Encoding.ASCII.GetBytes(response);await listener.SendAsync(responseData, responseData.Length, remoteEndPoint);Console.WriteLine("Sent: " + response);}}
}

• UDP 客户端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class UdpClientExample
{static async Task Main(string[] args){try{// 创建一个 UDP/IP 套接字UdpClient client = new UdpClient();IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000);// 发送数据string message = "Hello, Server!";byte[] data = Encoding.ASCII.GetBytes(message);await client.SendAsync(data, data.Length, remoteEP);Console.WriteLine("Sent: " + message);// 接收响应UdpReceiveResult result = await client.ReceiveAsync();string response = Encoding.ASCII.GetString(result.Buffer);Console.WriteLine("Received: " + response + " from " + result.RemoteEndPoint.ToString());// 关闭连接client.Close();}catch (Exception e){Console.WriteLine("Error: " + e.Message);}}
}

3. 使用 NetworkStream 进行自定义协议通信

NetworkStream 提供了一个流式接口，可以用于读取和写入网络数据。以下是一个使用 NetworkStream 的示例，展示如何实现一个简单的自定义协议。

• 自定义协议服务器端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class CustomProtocolServerExample
{static async Task Main(string[] args){// 创建一个 TCP/IP 套接字TcpListener listener = new TcpListener(IPAddress.Any, 13000);listener.Start();Console.WriteLine("Server started. Waiting for connections...");while (true){// 接受传入连接TcpClient client = await listener.AcceptTcpClientAsync();Console.WriteLine("Client connected.");// 处理客户端请求_ = HandleClient(client);}}static async Task HandleClient(TcpClient client){try{NetworkStream stream = client.GetStream();// 接收数据byte[] buffer = new byte[256];int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);string request = Encoding.ASCII.GetString(buffer, 0, bytesRead);Console.WriteLine("Received: " + request);// 解析自定义协议string[] parts = request.Split(':');if (parts.Length == 2 && parts[0] == "COMMAND"){string command = parts[1];Console.WriteLine("Command: " + command);// 处理命令并生成响应string response = "ACK: Command received";byte[] responseData = Encoding.ASCII.GetBytes(response);await stream.WriteAsync(responseData, 0, responseData.Length);Console.WriteLine("Sent: " + response);}else{string response = "ERROR: Invalid command format";byte[] responseData = Encoding.ASCII.GetBytes(response);await stream.WriteAsync(responseData, 0, responseData.Length);Console.WriteLine("Sent: " + response);}// 关闭连接client.Close();}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

• 自定义协议客户端示例

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class CustomProtocolClientExample
{static async Task Main(string[] args){try{// 创建一个 TCP/IP 套接字TcpClient client = new TcpClient();await client.ConnectAsync("127.0.0.1", 13000);Console.WriteLine("Connected to server.");NetworkStream stream = client.GetStream();// 发送自定义协议命令string message = "COMMAND:Hello";byte[] data = Encoding.ASCII.GetBytes(message);await stream.WriteAsync(data, 0, data.Length);Console.WriteLine("Sent: " + message);// 接收响应byte[] buffer = new byte[256];int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);string response = Encoding.ASCII.GetString(buffer, 0, bytesRead);Console.WriteLine("Received: " + response);// 关闭连接client.Close();}catch (Exception e){Console.WriteLine("Error: " + e.Message);}}
}

2.Socket编程‌

也就是我们常说的“套接字”，Socket类在System.Net.Sockets命名空间下，是最基本的网络操作类，封装了网络连接的创建和关闭、数据的收发以及网络状态监控等功能。通过Socket类，可以实现基于TCP和UDP的网络通信‌。

1. 使用 Socket 类进行 TCP 通信

TCP 服务器端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class TcpServerExample
{static async Task Main(string[] args){// 创建一个 TCP/IP 套接字Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);// 绑定套接字到本地端口IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 13000);listener.Bind(localEndPoint);// 监听传入连接listener.Listen(10);Console.WriteLine("Server started. Waiting for connections...");while (true){// 接受传入连接Socket handler = await listener.AcceptAsync();Console.WriteLine("Client connected.");// 处理客户端请求_ = HandleClient(handler);}}static async Task HandleClient(Socket handler){try{// 接收数据byte[] buffer = new byte[256];int bytesReceived = await handler.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);string request = Encoding.ASCII.GetString(buffer, 0, bytesReceived);Console.WriteLine("Received: " + request);// 发送响应string response = "Hello, Client!";byte[] responseData = Encoding.ASCII.GetBytes(response);await handler.SendAsync(new ArraySegment<byte>(responseData), SocketFlags.None);Console.WriteLine("Sent: " + response);// 关闭连接handler.Shutdown(SocketShutdown.Both);handler.Close();}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

TCP 客户端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class TcpClientExample
{static async Task Main(string[] args){try{// 创建一个 TCP/IP 套接字Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);// 连接到服务器IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 13000);await client.ConnectAsync(remoteEP);Console.WriteLine("Connected to server.");// 发送数据string message = "Hello, Server!";byte[] data = Encoding.ASCII.GetBytes(message);await client.SendAsync(new ArraySegment<byte>(data), SocketFlags.None);Console.WriteLine("Sent: " + message);// 接收响应byte[] buffer = new byte[256];int bytesReceived = await client.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);string response = Encoding.ASCII.GetString(buffer, 0, bytesReceived);Console.WriteLine("Received: " + response);// 关闭连接client.Shutdown(SocketShutdown.Both);client.Close();}catch (Exception e){Console.WriteLine("Error: " + e.Message);}}
}

2. 使用 Socket 类进行 UDP 通信

UDP 服务器端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class UdpServerExample
{static async Task Main(string[] args){// 创建一个 UDP/IP 套接字Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);// 绑定套接字到本地端口IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 11000);listener.Bind(localEndPoint);Console.WriteLine("UDP Server started. Waiting for messages...");while (true){// 接收数据EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);byte[] buffer = new byte[256];int bytesReceived = await listener.ReceiveFromAsync(new ArraySegment<byte>(buffer), SocketFlags.None, remoteEndPoint);string request = Encoding.ASCII.GetString(buffer, 0, bytesReceived);Console.WriteLine("Received: " + request + " from " + remoteEndPoint.ToString());// 发送响应string response = "Hello, Client!";byte[] responseData = Encoding.ASCII.GetBytes(response);await listener.SendToAsync(new ArraySegment<byte>(responseData), SocketFlags.None, remoteEndPoint);Console.WriteLine("Sent: " + response);}}
}

UDP 客户端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;class UdpClientExample
{static async Task Main(string[] args){try{// 创建一个 UDP/IP 套接字Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);// 连接到服务器IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000);// 发送数据string message = "Hello, Server!";byte[] data = Encoding.ASCII.GetBytes(message);await client.SendToAsync(new ArraySegment<byte>(data), SocketFlags.None, remoteEP);Console.WriteLine("Sent: " + message);// 接收响应EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);byte[] buffer = new byte[256];int bytesReceived = await client.ReceiveFromAsync(new ArraySegment<byte>(buffer), SocketFlags.None, remoteEndPoint);string response = Encoding.ASCII.GetString(buffer, 0, bytesReceived);Console.WriteLine("Received: " + response + " from " + remoteEndPoint.ToString());// 关闭连接client.Close();}catch (Exception e){Console.WriteLine("Error: " + e.Message);}}
}

注意事项

1. 异常处理：使用 try-catch 块来捕获和处理异常。
2. 资源管理：确保在使用完 Socket 后调用 Close 方法来释放资源。
3. 并发处理：对于服务器端，通常需要处理多个客户端连接，可以使用多线程或异步编程来提高并发性能。
4. 超时设置：对于 TCP 连接，可以设置超时时间来避免长时间等待。

3.WebSocket通信‌

WebSocket是一种在单个TCP连接上进行全双工通讯的协议。可以使用 System.Net.WebSockets 命名空间中的类来创建 WebSocket 服务器和客户端。WebSocket通信常用于需要实时数据交换的应用场景‌，适用于需要实时数据交换的应用场景，如实时聊天、在线游戏、股票行情等。

1.WebSocket 服务器端示例

以下是一个简单的 WebSocket 服务器端示例，使用 HttpListener 来处理 HTTP 请求并升级为 WebSocket 连接。

using System;
using System.IO;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;class WebSocketServerExample
{static async Task Main(string[] args){HttpListener listener = new HttpListener();listener.Prefixes.Add("http://localhost:8080/");listener.Start();Console.WriteLine("WebSocket Server started. Listening on ws://localhost:8080/");while (true){HttpListenerContext context = await listener.GetContextAsync();if (context.Request.IsWebSocketRequest){HttpListenerWebSocketContext webSocketContext = await context.AcceptWebSocketAsync(null);_ = HandleWebSocketConnection(webSocketContext.WebSocket);}else{context.Response.StatusCode = (int)HttpStatusCode.BadRequest;context.Response.Close();}}}static async Task HandleWebSocketConnection(WebSocket webSocket){byte[] buffer = new byte[1024 * 4];WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);while (!result.CloseStatus.HasValue){string userMessage = Encoding.UTF8.GetString(new ArraySegment<byte>(buffer, 0, result.Count));Console.WriteLine("Received: " + userMessage);//来自客户端：将消息回传给客户端byte[] responseBuffer = Encoding.UTF8.GetBytes("Echo: " + userMessage);await webSocket.SendAsync(new ArraySegment<byte>(responseBuffer), result.MessageType, result.EndOfMessage, CancellationToken.None);result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);}await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);webSocket.Dispose();}
}

2.WebSocket 客户端示例

以下是一个简单的 WebSocket 客户端示例，使用 ClientWebSocket 类来连接 WebSocket 服务器并进行通信。

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;class WebSocketClientExample
{static async Task Main(string[] args){using (ClientWebSocket webSocket = new ClientWebSocket()){Uri serverUri = new Uri("ws://localhost:8080/");await webSocket.ConnectAsync(serverUri, CancellationToken.None);Console.WriteLine("Connected to server.");byte[] buffer = new byte[1024 * 4];// 在单独的任务中开始接收消息_ = ReceiveMessages(webSocket, buffer);// 向服务器发送消息while (webSocket.State == WebSocketState.Open){Console.Write("Enter message to send: ");string message = Console.ReadLine();byte[] messageBuffer = Encoding.UTF8.GetBytes(message);await webSocket.SendAsync(new ArraySegment<byte>(messageBuffer), WebSocketMessageType.Text, true, CancellationToken.None);}}}static async Task ReceiveMessages(ClientWebSocket webSocket, byte[] buffer){while (webSocket.State == WebSocketState.Open){WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);if (result.MessageType == WebSocketMessageType.Close){await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);break;}string receivedMessage = Encoding.UTF8.GetString(new ArraySegment<byte>(buffer, 0, result.Count));Console.WriteLine("Received: " + receivedMessage);}}
}

注意事项

1. 异常处理：使用 try-catch 块来捕获和处理异常，特别是网络相关的异常。
2. 资源管理：确保在使用完 WebSocket 后调用 CloseAsync 和 Dispose 方法来释放资源。
3. 并发处理：对于服务器端，通常需要处理多个客户端连接，可以使用多线程或异步编程来提高并发性能。
4. 安全性：在生产环境中，建议使用 wss://（WebSocket Secure）来加密通信，防止数据泄露。
5. 心跳机制：为了保持连接活跃，可以定期发送心跳消息，防止中间设备关闭空闲连接。

4. HTTP请求‌：

可以使用HttpClient、WebClient、HttpRequestMessage和HttpMessageHandler等类来发送HTTP请求。这些类提供了发送GET、POST等请求的方法，并支持异步操作和身份验证等功能‌。

1. HttpClient

HttpClient 是一个现代的、高效的 HTTP 客户端，支持异步操作，适用于 .NET Core 和 .NET Framework。
主要方法
• GetAsync：发送 GET 请求。
• PostAsync：发送 POST 请求。
• PutAsync：发送 PUT 请求。
• DeleteAsync：发送 DELETE 请求。
• SendAsync：发送任意类型的 HTTP 请求。
注意
• 单例模式：HttpClient 实例应该尽量复用，而不是每次请求都创建新的实例。频繁创建 HttpClient 实例会导致资源泄漏和性能问题。
• 异常处理：使用 EnsureSuccessStatusCode 方法来确保请求成功，否则会抛出 HttpRequestException。
• 超时设置：设置合理的超时时间，避免长时间等待。
• 取消请求：使用 CancellationToken 来取消长时间运行的请求。
示例代码

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;class HttpClientExample
{private static readonly HttpClient client = new HttpClient();static async Task Main(string[] args){try{// 设置超时时间client.Timeout = TimeSpan.FromSeconds(30);// 发送 GET 请求HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");response.EnsureSuccessStatusCode(); // 确保请求成功string responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine("GET Response: " + responseBody);// 发送 POST 请求var content = new StringContent("{\"key\":\"value\"}", System.Text.Encoding.UTF8, "application/json");response = await client.PostAsync("https://api.example.com/post", content);response.EnsureSuccessStatusCode();responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine("POST Response: " + responseBody);}catch (HttpRequestException ex){Console.WriteLine("HTTP Error: " + ex.Message);}catch (TaskCanceledException ex){Console.WriteLine("Request canceled: " + ex.Message);}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

2. WebClient

WebClient 是一个较老的类，提供了简单的同步和异步方法来下载和上传数据。虽然它仍然可用，但推荐使用 HttpClient。
主要方法
• DownloadString：下载字符串内容。
• UploadString：上传字符串内容。
• DownloadFile：下载文件。
• UploadFile：上传文件。

注意
• 同步方法：WebClient 的同步方法会阻塞当前线程，建议使用异步方法。
• 异常处理：使用 try-catch 块来捕获和处理异常。
• 资源管理：使用 using 语句来确保 WebClient 实例在使用后被正确释放。
示例代码

using System;
using System.Net;class WebClientExample
{static void Main(string[] args){try{using (WebClient client = new WebClient()){// 下载字符串内容string response = client.DownloadString("https://api.example.com/data");Console.WriteLine("GET Response: " + response);// 上传字符串内容string uploadData = "{\"key\":\"value\"}";response = client.UploadString("https://api.example.com/post", uploadData);Console.WriteLine("POST Response: " + response);}}catch (WebException ex){Console.WriteLine("Web Error: " + ex.Message);}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

3. HttpRequestMessage

HttpRequestMessage 用于构建 HTTP 请求，通常与 HttpClient 一起使用，提供更细粒度的控制。
注意
• 请求头设置：根据需要设置请求头，例如 Content-Type、Authorization 等。
• 请求体设置：对于 POST、PUT 等请求，需要设置请求体内容。
• 响应处理：处理响应内容时，注意检查响应状态码和内容类型。
示例代码

using System;
using System.Net.Http;
using System.Threading.Tasks;class HttpRequestMessageExample
{static async Task Main(string[] args){using (HttpClient client = new HttpClient()){try{// 构建 GET 请求HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "https://api.example.com/data");HttpResponseMessage response = await client.SendAsync(request);response.EnsureSuccessStatusCode();string responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine("GET Response: " + responseBody);// 构建 POST 请求request = new HttpRequestMessage(HttpMethod.Post, "https://api.example.com/post"){Content = new StringContent("{\"key\":\"value\"}", System.Text.Encoding.UTF8, "application/json")};response = await client.SendAsync(request);response.EnsureSuccessStatusCode();responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine("POST Response: " + responseBody);}catch (HttpRequestException ex){Console.WriteLine("HTTP Error: " + ex.Message);}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}}
}

4. HttpMessageHandler

HttpMessageHandler 是 HttpClient 的基础组件，用于处理 HTTP 请求和响应。通常情况下，开发者不需要直接使用 HttpMessageHandler，但在某些高级场景中，可以自定义消息处理器来实现特定的功能。

注意
• 自定义处理：在 SendAsync 方法中添加自定义逻辑，例如日志记录、请求拦截等。
• 资源管理：确保自定义的消息处理器在使用后被正确释放。
示例代码

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;class CustomMessageHandler : DelegatingHandler
{protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken){try{// 在发送请求之前添加自定义逻辑Console.WriteLine("Sending request to: " + request.RequestUri);// 调用基类的 SendAsync 方法HttpResponseMessage response = await base.SendAsync(request, cancellationToken);// 在接收响应之后添加自定义逻辑Console.WriteLine("Received response from: " + request.RequestUri);return response;}catch (Exception ex){Console.WriteLine("Error in message handler: " + ex.Message);throw;}}
}class HttpMessageHandlerExample
{static async Task Main(string[] args){try{// 创建自定义消息处理器CustomMessageHandler handler = new CustomMessageHandler();// 使用自定义消息处理器创建 HttpClientusing (HttpClient client = new HttpClient(handler)){// 发送 GET 请求HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");response.EnsureSuccessStatusCode();string responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine("GET Response: " + responseBody);}}catch (HttpRequestException ex){Console.WriteLine("HTTP Error: " + ex.Message);}catch (Exception ex){Console.WriteLine("Error: " + ex.Message);}}
}

总结
• HttpClient：现代、高效的 HTTP 客户端，支持异步操作，推荐使用；单例模式、异常处理、超时设置、取消请求。
• WebClient：较老的类，简单易用，但推荐使用 HttpClient；同步方法、异常处理、资源管理。
• HttpRequestMessage：用于构建 HTTP 请求，通常与 HttpClient 一起使用；请求头设置、请求体设置、响应处理。
• HttpMessageHandler：用于处理 HTTP 请求和响应，通常用于高级场景；：自定义处理、资源管理。

5.网络安全‌

C# 网络编程中有效地保护应用程序的安全。确保数据传输的安全性、正确处理用户输入、实施适当的身份验证和授权机制，以及遵循其他最佳实践，都是构建安全网络应用程序的关键步骤，包括SSL/TLS加密、密码安全存储、防止SQL注入、防止跨站脚本攻击(XSS)、防止跨站请求伪造(CSRF)、身份验证和授权等‌。

1. SSL/TLS 加密

使用 SSL/TLS 可以确保数据在传输过程中不被窃听或篡改。
示例：使用 HttpClient 进行 HTTPS 请求

using System;
using System.Net.Http;
using System.Threading.Tasks;class HttpsExample
{static async Task Main(string[] args){using (HttpClient client = new HttpClient()){try{HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");response.EnsureSuccessStatusCode();string responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine(responseBody);}catch (HttpRequestException e){Console.WriteLine("\nException Caught!");Console.WriteLine("Message :{0} ", e.Message);}}}
}

2. 密码安全存储

使用哈希算法和盐值来安全地存储密码。
示例：使用 PasswordHasher 进行密码哈希

using Microsoft.AspNetCore.Identity;
using System;class PasswordStorageExample
{static void Main(string[] args){var passwordHasher = new PasswordHasher<string>();string password = "securePassword123";string hashedPassword = passwordHasher.HashPassword(null, password);Console.WriteLine("Hashed Password: " + hashedPassword);PasswordVerificationResult result = passwordHasher.VerifyHashedPassword(null, hashedPassword, password);Console.WriteLine("Verification Result: " + result);}
}

3. 防止 SQL 注入

使用参数化查询来防止 SQL 注入。
示例：使用 SqlCommand 进行参数化查询

using System;
using System.Data.SqlClient;class SqlInjectionExample
{static void Main(string[] args){string connectionString = "your_connection_string_here";string query = "SELECT * FROM Users WHERE Username = @Username AND Password = @Password";using (SqlConnection connection = new SqlConnection(connectionString)){SqlCommand command = new SqlCommand(query, connection);command.Parameters.AddWithValue("@Username", "user1");command.Parameters.AddWithValue("@Password", "pass1");connection.Open();SqlDataReader reader = command.ExecuteReader();while (reader.Read()){Console.WriteLine(reader["Username"]);}}}
}

4. 防止跨站脚本攻击 (XSS)

对用户输入进行适当的转义和验证。
示例：使用 HttpUtility.HtmlEncode 转义 HTML 内容

using System;
using System.Web;class XssExample
{static void Main(string[] args){string userInput = "<script>alert('XSS')</script>";string safeOutput = HttpUtility.HtmlEncode(userInput);Console.WriteLine("Safe Output: " + safeOutput);}
}

5. 防止跨站请求伪造 (CSRF)

使用 CSRF 令牌来防止跨站请求伪造。
示例：ASP.NET Core 中的 CSRF 保护
在 ASP.NET Core 中，CSRF 保护是默认启用的。确保在表单中包含 CSRF 令牌。

@model YourModel<form method="post">@Html.AntiForgeryToken()<!-- Form fields here --><button type="submit">Submit</button>
</form>

6. 身份验证和授权

使用身份验证和授权机制来保护应用程序。
示例：ASP.NET Core 中的身份验证和授权
在 Startup.cs 中配置身份验证和授权。

public class Startup
{public void ConfigureServices(IServiceCollection services){services.AddAuthentication(options =>{options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;options.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme;}).AddCookie();services.AddAuthorization();services.AddControllersWithViews();}public void Configure(IApplicationBuilder app, IWebHostEnvironment env){if (env.IsDevelopment()){app.UseDeveloperExceptionPage();}else{app.UseExceptionHandler("/Home/Error");app.UseHsts();}app.UseHttpsRedirection();app.UseStaticFiles();app.UseRouting();app.UseAuthentication();app.UseAuthorization();app.UseEndpoints(endpoints =>{endpoints.MapControllerRoute(name: "default",pattern: "{controller=Home}/{action=Index}/{id?}");});}
}

7. 其他安全措施

• 输入验证：对所有用户输入进行验证，确保其符合预期格式。
• 输出编码：对输出进行适当的编码，防止 XSS 攻击。
• 最小权限原则：确保应用程序以最小权限运行，限制不必要的权限。
• 定期更新和补丁：定期更新所有依赖库和框架，应用最新的安全补丁。
• 日志记录和监控：实施详细的日志记录和监控，以便及时发现和响应安全事件。

6.多线程与并发(待续)

• Thread 类：System.Threading.Thread 用于创建和管理线程。
• ThreadPool 类：System.Threading.ThreadPool 用于管理线程池。
• Task 并发：使用 Task.Run 和 Parallel 类进行并行任务处理。

7.序列化与反序列化(待续)

• JSON 序列化：使用 System.Text.Json.JsonSerializer 进行 JSON 序列化和反序列化。
• XML 序列化：使用 System.Xml.Serialization.XmlSerializer 进行 XML 序列化和反序列化。

8.网络配置(待续)

• 配置文件：使用 appsettings.json 或 app.config 配置网络参数。
• 环境变量：从环境变量中读取网络配置信息。