网络编程 - 《C#编程指南》 - 严富坤的知识库专栏(yanfukun.com)

网络编程的基本概念
- 网络通信的基本原理
- C#中的网络编程库
基于TCP的网络编程
- TCP协议的基本概念
- 基于TCP的客户端-服务器模型
  - TCP服务器示例
  - TCP客户端示例
基于UDP的网络编程
- UDP协议的基本概念
- 基于UDP的客户端-服务器模型
  - UDP服务器示例
  - UDP客户端示例
基于HTTP的网络编程
- HTTP协议的基本概念
- 使用HttpClient发送HTTP请求
  - 发送GET请求
  - 发送POST请求
WebSockets编程
- WebSocket协议的基本概念
- 使用WebSocket进行实时通信
  - WebSocket服务器示例
  - WebSocket客户端示例
异步网络编程
RESTful API开发
- RESTful API的基本概念
- 使用ASP.NET Core创建RESTful API
  - 创建控制器
  - 配置启动类
SignalR实时通信
- SignalR的基本概念
- 使用SignalR创建实时通信应用
Web服务与WCF
- WCF的基本概念
- 使用WCF创建和消费Web服务
网络编程中的安全性
- 安全通信的基本概念
- 使用SSL/TLS实现安全通信
  - 配置SSL/TLS证书
  - 使用SSL/TLS客户端
小结

网络编程是指通过编程实现计算机之间的数据通信。在现代应用程序开发中，网络编程起着至关重要的作用。C#作为一种功能强大的编程语言，提供了丰富的网络编程库和工具，支持开发各种网络应用程序，如客户端-服务器应用、Web服务、异步网络通信等。本文将深入探讨C#中的网络编程，从基本概念到高级用法，全面解析网络编程的原理和机制，并结合实际案例，帮助读者掌握网络编程的精髓。

网络编程的基本概念

网络通信的基本原理

网络通信是指通过网络将数据从一个设备传输到另一个设备的过程。网络通信的基本原理包括以下几个方面：

数据封装与解封装：数据在传输过程中需要经过多层协议的封装和解封装，如应用层、传输层、网络层和数据链路层。
IP地址与端口：IP地址用于标识网络中的设备，端口用于标识设备上的应用程序。
协议：网络通信遵循一系列协议，如TCP/IP、UDP、HTTP、FTP等。

C#中的网络编程库

C#提供了丰富的网络编程库，主要包括以下几种：

System.Net：提供基础的网络通信功能，如TCP、UDP、DNS解析等。
System.Net.Sockets：提供底层的Socket编程接口，用于开发自定义的网络协议和通信机制。
System.Net.Http：提供HTTP/HTTPS协议的支持，用于开发Web客户端和Web服务。
System.Net.Mail：提供邮件发送功能，用于开发邮件客户端。

基于TCP的网络编程

TCP协议的基本概念

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的传输层协议。TCP通过三次握手建立连接，保证数据的有序传输和完整性，并提供流量控制和拥塞控制机制。

基于TCP的客户端-服务器模型

TCP网络编程通常采用客户端-服务器模型，即客户端主动发起连接请求，服务器被动等待连接请求。连接建立后，客户端和服务器之间可以进行双向通信。

TCP服务器示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class TcpServer
{
    public static async Task Main(string[] args)
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 12345);
        listener.Start();
        Console.WriteLine("服务器已启动，等待客户端连接...");
        while (true)
        {
            TcpClient client = await listener.AcceptTcpClientAsync();
            Console.WriteLine("客户端已连接");
            HandleClient(client);
        }
    }
    private static async void HandleClient(TcpClient client)
    {
        NetworkStream stream = client.GetStream();
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) != 0)
        {
            string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine($"收到消息：{message}");
            byte[] response = Encoding.UTF8.GetBytes($"服务器已收到消息：{message}");
            await stream.WriteAsync(response, 0, response.Length);
        }
        client.Close();
        Console.WriteLine("客户端已断开连接");
    }
}

在这个例子中，我们创建了一个简单的TCP服务器，监听端口12345，等待客户端连接并处理客户端发送的消息。

TCP客户端示例

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class TcpClientProgram
{
    public static async Task Main(string[] args)
    {
        TcpClient client = new TcpClient();
        await client.ConnectAsync("127.0.0.1", 12345);
        Console.WriteLine("已连接到服务器");
        NetworkStream stream = client.GetStream();
        byte[] message = Encoding.UTF8.GetBytes("你好，服务器！");
        await stream.WriteAsync(message, 0, message.Length);
        byte[] buffer = new byte[1024];
        int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
        string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"收到服务器响应：{response}");
        client.Close();
        Console.WriteLine("已断开连接");
    }
}

在这个例子中，我们创建了一个简单的TCP客户端，连接到服务器并发送消息，接收服务器的响应。

基于UDP的网络编程

UDP协议的基本概念

UDP（User Datagram Protocol，用户数据报协议）是一种无连接的、非可靠的传输层协议。UDP不保证数据的有序传输和完整性，但其传输速度快，适用于实时通信和广播应用。

基于UDP的客户端-服务器模型

UDP网络编程通常采用客户端-服务器模型，但与TCP不同的是，UDP没有连接的概念，客户端和服务器之间的通信是无状态的。

UDP服务器示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class UdpServer
{
    public static async Task Main(string[] args)
    {
        UdpClient server = new UdpClient(12345);
        Console.WriteLine("服务器已启动，等待客户端消息...");
        while (true)
        {
            UdpReceiveResult result = await server.ReceiveAsync();
            string message = Encoding.UTF8.GetString(result.Buffer);
            Console.WriteLine($"收到消息：{message}");
            byte[] response = Encoding.UTF8.GetBytes($"服务器已收到消息：{message}");
            await server.SendAsync(response, response.Length, result.RemoteEndPoint);
        }
    }
}

在这个例子中，我们创建了一个简单的UDP服务器，监听端口12345，等待客户端消息并发送响应。

UDP客户端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class UdpClientProgram
{
    public static async Task Main(string[] args)
    {
        UdpClient client = new UdpClient();
        IPEndPoint serverEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
        byte[] message = Encoding.UTF8.GetBytes("你好，服务器！");
        await client.SendAsync(message, message.Length, serverEndpoint);
        UdpReceiveResult result = await client.ReceiveAsync();
        string response = Encoding.UTF8.GetString(result.Buffer);
        Console.WriteLine($"收到服务器响应：{response}");
        client.Close();
        Console.WriteLine("已断开连接");
    }
}

在这个例子中，我们创建了一个简单的UDP客户端，发送消息到服务器并接收服务器的响应。

基于HTTP的网络编程

HTTP协议的基本概念

HTTP（HyperText Transfer Protocol，超文本传输协议）是一种无状态的应用层协议，广泛用于Web应用和服务。HTTP基于请求-响应模型，客户端发送请求到服务器，服务器处理请求并返回响应。

使用HttpClient发送HTTP请求

HttpClient类是C#中用于发送HTTP请求和接收HTTP响应的类。HttpClient支持GET、POST、PUT、DELETE等HTTP方法，并支持异步操作。

发送GET请求

using System;
using System.Net.Http;
using System.Threading.Tasks;
public class HttpClientExample
{
    public static async Task Main(string[] args)
    {
        HttpClient client = new HttpClient();
        HttpResponseMessage response = await client.GetAsync("https://api.github.com/repos/dotnet/roslyn");
        response.EnsureSuccessStatusCode();
        string responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseBody);
    }
}

在这个例子中，我们使用HttpClient发送GET请求到GitHub API，并打印响应内容。

发送POST请求

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
public class HttpClientExample
{
    public static async Task Main(string[] args)
    {
        HttpClient client = new HttpClient();
        string json = "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}";
        StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
        HttpResponseMessage response = await client.PostAsync("https://jsonplaceholder.typicode.com/posts", content);
        response.EnsureSuccessStatusCode();
        string responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseBody);
    }
}

在这个例子中，我们使用HttpClient发送POST请求到一个示例API，并打印响应内容。

WebSockets编程

WebSocket协议的基本概念

WebSocket是一种全双工通信协议，允许客户端和服务器之间建立长连接，并在连接期间进行实时双向通信。WebSocket适用于聊天应用、实时数据更新等场景。

使用WebSocket进行实时通信

通过System.Net.WebSockets命名空间，

C#提供了对WebSocket的支持，包括客户端和服务器实现。

WebSocket服务器示例

using System;
using System.Net;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
using System.Text;
public class WebSocketServer
{
    public static async Task Main(string[] args)
    {
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add("http://localhost:5000/");
        listener.Start();
        Console.WriteLine("WebSocket服务器已启动，等待客户端连接...");
        while (true)
        {
            HttpListenerContext context = await listener.GetContextAsync();
            if (context.Request.IsWebSocketRequest)
            {
                HttpListenerWebSocketContext wsContext = await context.AcceptWebSocketAsync(null);
                HandleWebSocket(wsContext.WebSocket);
            }
            else
            {
                context.Response.StatusCode = 400;
                context.Response.Close();
            }
        }
    }
    private static async void HandleWebSocket(WebSocket webSocket)
    {
        byte[] buffer = new byte[1024];
        WebSocketReceiveResult result;
        while (webSocket.State == WebSocketState.Open)
        {
            result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            Console.WriteLine($"收到消息：{message}");
            string responseMessage = $"服务器已收到消息：{message}";
            byte[] responseBuffer = Encoding.UTF8.GetBytes(responseMessage);
            await webSocket.SendAsync(new ArraySegment<byte>(responseBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
        }
        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "关闭连接", CancellationToken.None);
    }
}

在这个例子中，我们创建了一个WebSocket服务器，监听端口5000，等待客户端连接并处理客户端发送的消息。

WebSocket客户端示例

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
public class WebSocketClient
{
    public static async Task Main(string[] args)
    {
        ClientWebSocket client = new ClientWebSocket();
        Uri serverUri = new Uri("ws://localhost:5000/");
        await client.ConnectAsync(serverUri, CancellationToken.None);
        Console.WriteLine("已连接到服务器");
        string message = "你好，服务器！";
        byte[] buffer = Encoding.UTF8.GetBytes(message);
        await client.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
        buffer = new byte[1024];
        WebSocketReceiveResult result = await client.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        string response = Encoding.UTF8.GetString(buffer, 0, result.Count);
        Console.WriteLine($"收到服务器响应：{response}");
        await client.CloseAsync(WebSocketCloseStatus.NormalClosure, "关闭连接", CancellationToken.None);
        Console.WriteLine("已断开连接");
    }
}

在这个例子中，我们创建了一个WebSocket客户端，连接到服务器并发送消息，接收服务器的响应。

异步网络编程

异步编程模型（async/await）的基本概念

异步编程模型（async/await）是C#中用于简化异步编程的语言特性。通过async关键字和await关键字，可以将异步操作表示为同步代码，提高代码的可读性和维护性。

异步TCP网络编程

通过异步方法，可以在不阻塞主线程的情况下进行TCP网络编程。

异步TCP服务器示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class AsyncTcpServer
{
    public static async Task Main(string[] args)
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 12345);
        listener.Start();
        Console.WriteLine("异步TCP服务器已启动，等待客户端连接...");
        while (true)
        {
            TcpClient client = await listener.AcceptTcpClientAsync();
            Console.WriteLine("客户端已连接");
            _ = HandleClientAsync(client);
        }
    }
    private static async Task HandleClientAsync(TcpClient client)
    {
        NetworkStream stream = client.GetStream();
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) != 0)
        {
            string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine($"收到消息：{message}");
            byte[] response = Encoding.UTF8.GetBytes($"服务器已收到消息：{message}");
            await stream.WriteAsync(response, 0, response.Length);
        }
        client.Close();
        Console.WriteLine("客户端已断开连接");
    }
}

在这个例子中，我们创建了一个异步TCP服务器，监听端口12345，等待客户端连接并处理客户端发送的消息。

异步TCP客户端示例

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class AsyncTcpClient
{
    public static async Task Main(string[] args)
    {
        TcpClient client = new TcpClient();
        await client.ConnectAsync("127.0.0.1", 12345);
        Console.WriteLine("已连接到异步TCP服务器");
        NetworkStream stream = client.GetStream();
        byte[] message = Encoding.UTF8.GetBytes("你好，服务器！");
        await stream.WriteAsync(message, 0, message.Length);
        byte[] buffer = new byte[1024];
        int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
        string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"收到服务器响应：{response}");
        client.Close();
        Console.WriteLine("已断开连接");
    }
}

在这个例子中，我们创建了一个异步TCP客户端，连接到服务器并发送消息，接收服务器的响应。

异步UDP网络编程

通过异步方法，可以在不阻塞主线程的情况下进行UDP网络编程。

异步UDP服务器示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class AsyncUdpServer
{
    public static async Task Main(string[] args)
    {
        UdpClient server = new UdpClient(12345);
        Console.WriteLine("异步UDP服务器已启动，等待客户端消息...");
        while (true)
        {
            UdpReceiveResult result = await server.ReceiveAsync();
            string message = Encoding.UTF8.GetString(result.Buffer);
            Console.WriteLine($"收到消息：{message}");
            byte[] response = Encoding.UTF8.GetBytes($"服务器已收到消息：{message}");
            await server.SendAsync(response, response.Length, result.RemoteEndPoint);
        }
    }
}

在这个例子中，我们创建了一个异步UDP服务器，监听端口12345，等待客户端消息并发送响应。

异步UDP客户端示例

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class AsyncUdpClient
{
    public static async Task Main(string[] args)
    {
        UdpClient client = new UdpClient();
        IPEndPoint serverEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
        byte[] message = Encoding.UTF8.GetBytes("你好，服务器！");
        await client.SendAsync(message, message.Length, serverEndpoint);
        UdpReceiveResult result = await client.ReceiveAsync();
        string response = Encoding.UTF8.GetString(result.Buffer);
        Console.WriteLine($"收到服务器响应：{response}");
        client.Close();
        Console.WriteLine("已断开连接");
    }
}

在这个例子中，我们创建了一个异步UDP客户端，发送消息到服务器并接收服务器的响应。

RESTful API开发

RESTful API的基本概念

REST（Representational State Transfer，表述性状态转移）是一种基于HTTP的架构风格，用于设计网络服务。RESTful API通过HTTP方法（如GET、POST、PUT、DELETE）进行资源的操作，具有简单、灵活和可扩展的特点。

使用ASP.NET Core创建RESTful API

ASP.NET Core是一个跨平台的、高性能的Web框架，用于构建现代Web应用和服务。通过ASP.NET Core，可以轻松创建RESTful API。

创建控制器

首先，创建一个控制器类，定义API的路由和操作方法。

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private static readonly List<Product> Products = new List<Product>
    {
        new Product { Id = 1, Name = "Product1", Price = 100 },
        new Product { Id = 2, Name = "Product2", Price = 200 }
    };
    [HttpGet]
    public ActionResult<IEnumerable<Product>> GetProducts()
    {
        return Products;
    }
    [HttpGet("{id}")]
    public ActionResult<Product> GetProduct(int id)
    {
        var product = Products.Find(p => p.Id == id);
        if (product == null)
        {
            return Not
Found();
        }
        return product;
    }
    [HttpPost]
    public ActionResult<Product> CreateProduct(Product product)
    {
        product.Id = Products.Count + 1;
        Products.Add(product);
        return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
    }
    [HttpPut("{id}")]
    public IActionResult UpdateProduct(int id, Product updatedProduct)
    {
        var product = Products.Find(p => p.Id == id);
        if (product == null)
        {
            return NotFound();
        }
        product.Name = updatedProduct.Name;
        product.Price = updatedProduct.Price;
        return NoContent();
    }
    [HttpDelete("{id}")]
    public IActionResult DeleteProduct(int id)
    {
        var product = Products.Find(p => p.Id == id);
        if (product == null)
        {
            return NotFound();
        }
        Products.Remove(product);
        return NoContent();
    }
}
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

在这个例子中，我们定义了一个ProductsController类，提供对产品的CRUD（创建、读取、更新、删除）操作。

配置启动类

接下来，配置ASP.NET Core应用的启动类。

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }
    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

在这个例子中，我们配置了服务和中间件，以支持控制器和路由。

SignalR实时通信

SignalR的基本概念

SignalR是一个用于实现实时Web功能的库，支持双向通信和高频率的消息传递。SignalR通过WebSocket、Server-Sent Events和Long Polling等传输机制，实现了实时通信的高效性和可靠性。

使用SignalR创建实时通信应用

通过SignalR，可以轻松创建实时通信应用，如聊天应用、实时通知等。

创建SignalR集线器

首先，创建一个SignalR集线器类，定义客户端和服务器之间的通信方法。

using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;
public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

在这个例子中，我们定义了一个ChatHub类，提供发送消息的方法。

配置启动类

接下来，配置ASP.NET Core应用的启动类。

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddSignalR();
    }
    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
            endpoints.MapHub<ChatHub>("/chatHub");
        });
    }
}

在这个例子中，我们配置了SignalR服务和集线器的路由。

创建SignalR客户端

最后，创建一个SignalR客户端，连接到服务器并发送消息。

<!DOCTYPE html>
<html>
<head>
    <title>SignalR Chat</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/5.0.0/signalr.min.js"></script>
</head>
<body>
    <input type="text" id="userInput" placeholder="User" />
    <input type="text" id="messageInput" placeholder="Message" />
    <button onclick="sendMessage()">Send</button>
    <ul id="messagesList"></ul>
    <script>
        const connection = new signalR.HubConnectionBuilder()
            .withUrl("/chatHub")
            .build();
        connection.on("ReceiveMessage", (user, message) => {
            const li = document.createElement("li");
            li.textContent = `${user}: ${message}`;
            document.getElementById("messagesList").appendChild(li);
        });
        connection.start().catch(err => console.error(err.toString()));
        function sendMessage() {
            const user = document.getElementById("userInput").value;
            const message = document.getElementById("messageInput").value;
            connection.invoke("SendMessage", user, message).catch(err => console.error(err.toString()));
        }
    </script>
</body>
</html>

在这个例子中，我们创建了一个简单的HTML页面，使用SignalR客户端库连接到服务器并发送消息。

Web服务与WCF

WCF的基本概念

WCF（Windows Communication Foundation）是一个用于构建和部署分布式应用程序的框架，支持多种通信协议（如HTTP、TCP、Named Pipes）和消息编码格式（如SOAP、JSON）。

使用WCF创建和消费Web服务

通过WCF，可以轻松创建和消费Web服务，实现跨平台的分布式计算。

创建WCF服务

首先，创建一个WCF服务契约和服务实现。

using System.ServiceModel;
[ServiceContract]
public interface ICalculatorService
{
    [OperationContract]
    int Add(int a, int b);
}
public class CalculatorService : ICalculatorService
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

在这个例子中，我们定义了一个ICalculatorService契约和其实现CalculatorService。

配置和启动WCF服务

接下来，配置和启动WCF服务主机。

using System;
using System.ServiceModel;
public class Program
{
    public static void Main(string[] args)
    {
        using (ServiceHost host = new ServiceHost(typeof(CalculatorService), new Uri("http://localhost:8000/CalculatorService")))
        {
            host.AddServiceEndpoint(typeof(ICalculatorService), new BasicHttpBinding(), "");
            host.Open();
            Console.WriteLine("WCF服务已启动...");
            Console.ReadLine();
        }
    }
}

在这个例子中，我们配置了WCF服务主机并启动服务。

创建WCF客户端

最后，创建一个WCF客户端，调用服务方法。

using System;
using System.ServiceModel;
public class Program
{
    public static void Main(string[] args)
    {
        ChannelFactory<ICalculatorService> factory = new ChannelFactory<ICalculatorService>(new BasicHttpBinding(), new EndpointAddress("http://localhost:8000/CalculatorService"));
        ICalculatorService proxy = factory.CreateChannel();
        int result = proxy.Add(10, 20);
        Console.WriteLine($"结果：{result}");
    }
}

在这个例子中，我们创建了一个WCF客户端，并调用服务方法。

网络编程中的安全性

安全通信的基本概念

安全通信是指在网络传输过程中保护数据的机密性、完整性和可用性。常见的安全通信机制包括加密、认证和授权。

使用SSL/TLS实现安全通信

SSL/TLS（Secure Sockets Layer/Transport Layer Security）是用于保护网络通信安全的协议，通过加密传输数据，防止数据被窃听和篡改。

配置SSL/TLS证书

首先，配置SSL/TLS证书，确保服务器支持安全通信。

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
public class SslTcpServer
{
    public static async Task Main(string[] args)
    {
        X509Certificate2 certificate = new X509Certificate2("server.pfx", "password");
        TcpListener listener = new TcpListener(IPAddress.Any, 12345);
        listener.Start();
        Console.WriteLine("SSL/TLS服务器已启动，等待客户端连接...");
        while (true)
        {
            TcpClient client = await listener.AcceptTcpClientAsync();
            Console.WriteLine("客户端已连接");
            _ = HandleClientAsync(client, certificate);
        }
    }
    private static async Task HandleClientAsync(TcpClient client, X509Certificate2 certificate)
    {
        SslStream sslStream = new SslStream(client.GetStream(), false);
        await sslStream.AuthenticateAsServerAsync(certificate, false, System.Security.Authentication.SslProtocols.Tls12, true);
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = await sslStream.ReadAsync(buffer, 0, buffer.Length)) != 0)
        {
            string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine($"收到消息：{message}");
            byte[] response = Encoding.UTF8.GetBytes($"服务器已收到消息：{message}");
            await sslStream.WriteAsync(response, 0, response.Length);
        }
        client.Close();
        Console.WriteLine("客户端已断开连接");
    }
}

在这个例子中，我们创建了一个SSL/TLS服务器，使用证书进行安全通信。

使用SSL/TLS客户端

接下来，创建一个SSL/TLS客户端，连接到服务器并发送消息。

using System;
using System.Net
.Security;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
public class SslTcpClient
{
    public static async Task Main(string[] args)
    {
        TcpClient client = new TcpClient();
        await client.ConnectAsync("127.0.0.1", 12345);
        Console.WriteLine("已连接到SSL/TLS服务器");
        SslStream sslStream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
        await sslStream.AuthenticateAsClientAsync("server");
        string message = "你好，服务器！";
        byte[] buffer = Encoding.UTF8.GetBytes(message);
        await sslStream.WriteAsync(buffer, 0, buffer.Length);
        buffer = new byte[1024];
        int bytesRead = await sslStream.ReadAsync(buffer, 0, buffer.Length);
        string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"收到服务器响应：{response}");
        client.Close();
        Console.WriteLine("已断开连接");
    }
    private static bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
    {
        return sslPolicyErrors == SslPolicyErrors.None;
    }
}

在这个例子中，我们创建了一个SSL/TLS客户端，连接到服务器并发送消息。

小结

网络编程是C#中用于实现计算机之间数据通信的重要技术。通过C#提供的丰富的网络编程库和工具，开发者可以轻松实现各种网络应用，如基于TCP/UDP的客户端-服务器应用、基于HTTP的Web客户端和服务、基于WebSocket的实时通信、异步网络编程、RESTful API开发、SignalR实时通信、WCF服务等。本文深入探讨了C#中的网络编程，从基本概念到高级用法，全面解析了网络编程的原理和机制，并结合实际案例展示了网络编程在各种场景中的应用。

掌握网络编程不仅能够提高应用程序的功能和性能，还能够在复杂的分布式系统中发挥重要作用。希望本文能帮助读者更好地理解和掌握C#中的网络编程，在实际开发中充分利用这一强大的编程工具。通过对网络编程技术的深入理解和合理应用，可以编写出更加高效、可靠和安全的网络应用程序。