正文

C#网络编程：从入门到实战，10个经典案例教你轻松实现网络应用开发

/0 浏览量
0705

在数字化时代，网络编程已经成为软件开发中不可或缺的一部分。C#作为微软开发的语言，拥有强大的网络编程功能。本文将带你从入门到实战，通过10个经典案例，让你轻松掌握C#网络编程，实现网络应用开发。

一、C#网络编程基础

1.1 网络编程概述

网络编程是指利用计算机网络的通信协议，实现计算机之间的数据交换。C#网络编程主要基于.NET Framework，提供了丰富的类库支持。

1.2 常用网络协议

  • TCP/IP：面向连接的、可靠的、基于字节流的传输层协议。
  • UDP：无连接的、不可靠的、基于数据报的传输层协议。
  • HTTP：超文本传输协议，用于在Web浏览器和服务器之间传输数据。

1.3 C#网络编程类库

  • System.Net：提供基本的网络编程功能，如Socket编程。
  • System.Net.Sockets：提供Socket编程接口。
  • System.Net.Http：提供HTTP客户端和服务器功能。

二、经典案例解析

2.1 案例一：Socket编程实现TCP客户端

using System;
using System.Net.Sockets;

public class TcpClientExample
{
    public static void Main()
    {
        string serverIp = "127.0.0.1";
        int serverPort = 8080;

        using (Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
        {
            IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(serverIp), serverPort);
            clientSocket.Connect(serverEndPoint);

            // 发送数据
            byte[] buffer = System.Text.Encoding.ASCII.GetBytes("Hello, Server!");
            clientSocket.Send(buffer);

            // 接收数据
            int bytesRead = 0;
            buffer = new byte[1024];
            while ((bytesRead = clientSocket.Receive(buffer)) > 0)
            {
                Console.WriteLine(System.Text.Encoding.ASCII.GetString(buffer, 0, bytesRead));
            }
        }
    }
}

2.2 案例二：Socket编程实现TCP服务器

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

public class TcpServerExample
{
    public static void Main()
    {
        int port = 8080;

        using (Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
        {
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, port);
            serverSocket.Bind(localEndPoint);
            serverSocket.Listen(10);

            Console.WriteLine("Waiting for a connection...");

            using (Socket clientSocket = serverSocket.Accept())
            {
                Console.WriteLine("Connection accepted.");

                int bytesRead = 0;
                byte[] buffer = new byte[1024];
                while ((bytesRead = clientSocket.Receive(buffer)) > 0)
                {
                    Console.WriteLine(Encoding.ASCII.GetString(buffer, 0, bytesRead));
                }
            }
        }
    }
}

2.3 案例三：使用HttpClient实现HTTP客户端

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class HttpClientExample
{
    public static async Task Main()
    {
        string url = "http://www.example.com";

        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url);
            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(content);
            }
        }
    }
}

2.4 案例四：使用WebClient实现HTTP客户端

using System;
using System.Net;

public class WebClientExample
{
    public static void Main()
    {
        string url = "http://www.example.com";

        using (WebClient client = new WebClient())
        {
            try
            {
                string content = client.DownloadString(url);
                Console.WriteLine(content);
            }
            catch (WebException ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }
    }
}

2.5 案例五：使用HttpListener实现HTTP服务器

using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

public class HttpListenerExample
{
    public static void Main()
    {
        string url = "http://localhost:8080";

        HttpListener listener = new HttpListener();
        listener.Prefixes.Add(url);
        listener.Start();

        Console.WriteLine("Listening for requests on " + url);

        while (true)
        {
            var context = listener.GetContext();
            Task.Run(() => HandleRequest(context));
        }
    }

    private static void HandleRequest(HttpListenerContext context)
    {
        string responseString = "Hello, World!";

        byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
        context.Response.ContentLength64 = buffer.Length;

        context.Response.ContentType = "text/plain";
        context.Response.OutputStream.Write(buffer, 0, buffer.Length);
        context.Response.Close();
    }
}

2.6 案例六：使用WebClient实现FTP客户端

using System;
using System.Net;

public class FtpClientExample
{
    public static void Main()
    {
        string server = "ftp://example.com";
        string username = "user";
        string password = "password";

        FtpWebRequest request = (FtpWebRequest)WebRequest.Create(server);
        request.Method = WebRequestMethods.Ftp.ListDirectory;
        request.Credentials = new NetworkCredential(username, password);

        FtpWebResponse response = (FtpWebResponse)request.GetResponse();
        Console.WriteLine(response.StatusDescription);

        response.Close();
    }
}

2.7 案例七：使用HttpClient实现WebSocket客户端

using System;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketClientExample
{
    public static async Task Main()
    {
        string url = "ws://example.com";

        using (ClientWebSocket clientWebSocket = new ClientWebSocket())
        {
            await clientWebSocket.ConnectAsync(new Uri(url), CancellationToken.None);

            string message = "Hello, Server!";
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(message);
            await clientWebSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);

            buffer = new byte[1024];
            using (MemoryStream memoryStream = new MemoryStream())
            {
                int bytesRead = 0;
                while ((bytesRead = await clientWebSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None)) > 0)
                {
                    memoryStream.Write(buffer, 0, bytesRead);
                }

                string response = System.Text.Encoding.UTF8.GetString(memoryStream.ToArray());
                Console.WriteLine(response);
            }
        }
    }
}

2.8 案例九：使用HttpListener实现WebSocket服务器

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketServerExample
{
    public static void Main()
    {
        string url = "ws://localhost:8080";

        HttpListener listener = new HttpListener();
        listener.Prefixes.Add(url);
        listener.Start();

        Console.WriteLine("Listening for WebSocket connections on " + url);

        while (true)
        {
            var context = listener.GetContext();
            Task.Run(() => HandleWebSocketRequest(context));
        }
    }

    private static void HandleWebSocketRequest(HttpListenerContext context)
    {
        if (context.Request.Url.Segments[1] == "ws")
        {
            WebSocket webSocket = context.Request.WebSockets.Accept();
            Console.WriteLine("WebSocket connection accepted.");

            var buffer = new byte[1024];
            while (true)
            {
                var result = webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
                string message = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Result.Count);
                Console.WriteLine("Received message: " + message);

                string response = "Hello, Client!";
                byte[] responseBytes = System.Text.Encoding.UTF8.GetBytes(response);
                webSocket.SendAsync(new ArraySegment<byte>(responseBytes), WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }
    }
}

2.10 案例十：使用HttpClient实现HTTP长轮询

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class HttpLongPollingClientExample
{
    public static async Task Main()
    {
        string url = "http://example.com/poll";

        using (HttpClient client = new HttpClient())
        {
            while (true)
            {
                HttpResponseMessage response = await client.GetAsync(url);
                if (response.IsSuccessStatusCode)
                {
                    string content = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(content);
                }

                await Task.Delay(5000); // 5秒后再次轮询
            }
        }
    }
}

三、总结

通过以上10个经典案例，相信你已经对C#网络编程有了更深入的了解。在实际开发中，可以根据需求选择合适的网络编程技术，实现各种网络应用。希望本文能帮助你轻松实现网络应用开发。

-- 展开阅读全文 --