🧐

Menu

Decade
Decade
Published on 2025-09-25 / 15 Visits
0
0

FTP相关

FTP协议详细指南 - .NET环境实战

什么是FTP协议？

FTP（File Transfer Protocol，文件传输协议）是一种用于在网络上传输文件的标准协议。就像你使用微信传文件给朋友一样，FTP让不同的计算机可以互相传送文件。

简单理解FTP

想象FTP就像一个网络文件管理器：

  • 你可以上传文件到服务器（就像把文件放到云盘）

  • 你可以从服务器下载文件（就像从云盘下载文件）

  • 你可以查看服务器上的文件列表

  • 你可以删除、重命名服务器上的文件

FTP的工作原理

基本概念

  • FTP客户端：你的程序或软件（发起文件传输请求的一方）

  • FTP服务器：存储文件的服务器（接收和响应请求的一方）

  • 端口：FTP默认使用21端口进行控制连接

连接模式

FTP有两种连接模式：

  1. 主动模式（Active Mode）

    • 客户端告诉服务器："我在某个端口等你连接"

    • 服务器主动连接到客户端

  2. 被动模式（Passive Mode）

    • 服务器告诉客户端："我在某个端口等你连接"

    • 客户端连接到服务器（更常用，防火墙友好）

.NET中的FTP实现

方法一：使用内置的FtpWebRequest（.NET Framework）

using System;
using System.IO;
using System.Net;

public class SimpleFtpClient
{
    private string ftpServer;
    private string username;
    private string password;

    public SimpleFtpClient(string server, string user, string pass)
    {
        ftpServer = server;
        username = user;
        password = pass;
    }

    // 上传文件
    public void UploadFile(string localFilePath, string remoteFilePath)
    {
        try
        {
            // 创建FTP请求
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create($"ftp://{ftpServer}/{remoteFilePath}");
            request.Method = WebRequestMethods.Ftp.UploadFile;
            request.Credentials = new NetworkCredential(username, password);
            request.UsePassive = true; // 使用被动模式

            // 读取本地文件
            byte[] fileContents = File.ReadAllBytes(localFilePath);
            request.ContentLength = fileContents.Length;

            // 上传文件
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(fileContents, 0, fileContents.Length);
            }

            // 获取响应
            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            {
                Console.WriteLine($"上传完成，状态: {response.StatusDescription}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"上传失败: {ex.Message}");
        }
    }

    // 下载文件
    public void DownloadFile(string remoteFilePath, string localFilePath)
    {
        try
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create($"ftp://{ftpServer}/{remoteFilePath}");
            request.Method = WebRequestMethods.Ftp.DownloadFile;
            request.Credentials = new NetworkCredential(username, password);
            request.UsePassive = true;

            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            using (Stream responseStream = response.GetResponseStream())
            using (FileStream localFileStream = File.Create(localFilePath))
            {
                responseStream.CopyTo(localFileStream);
                Console.WriteLine($"下载完成: {localFilePath}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"下载失败: {ex.Message}");
        }
    }

    // 获取文件列表
    public void ListFiles(string remotePath = "")
    {
        try
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create($"ftp://{ftpServer}/{remotePath}");
            request.Method = WebRequestMethods.Ftp.ListDirectory;
            request.Credentials = new NetworkCredential(username, password);
            request.UsePassive = true;

            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            using (StreamReader reader = new StreamReader(response.GetResponseStream()))
            {
                string line;
                Console.WriteLine("服务器文件列表:");
                while ((line = reader.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取文件列表失败: {ex.Message}");
        }
    }
}

方法二：使用第三方库FluentFTP（推荐）

首先安装NuGet包：

Install-Package FluentFTP

using FluentFTP;
using System;
using System.IO;
using System.Threading.Tasks;

public class ModernFtpClient
{
    private FtpClient client;

    public ModernFtpClient(string server, string username, string password)
    {
        client = new FtpClient(server, username, password);
    }

    // 连接到服务器
    public async Task ConnectAsync()
    {
        try
        {
            await client.ConnectAsync();
            Console.WriteLine("连接成功！");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"连接失败: {ex.Message}");
        }
    }

    // 上传文件（异步）
    public async Task UploadFileAsync(string localPath, string remotePath)
    {
        try
        {
            var result = await client.UploadFileAsync(localPath, remotePath);
            if (result == FtpStatus.Success)
            {
                Console.WriteLine($"文件上传成功: {remotePath}");
            }
            else
            {
                Console.WriteLine($"上传失败，状态: {result}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"上传异常: {ex.Message}");
        }
    }

    // 下载文件（异步）
    public async Task DownloadFileAsync(string remotePath, string localPath)
    {
        try
        {
            var result = await client.DownloadFileAsync(localPath, remotePath);
            if (result == FtpStatus.Success)
            {
                Console.WriteLine($"文件下载成功: {localPath}");
            }
            else
            {
                Console.WriteLine($"下载失败，状态: {result}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"下载异常: {ex.Message}");
        }
    }

    // 列出文件
    public async Task ListFilesAsync(string remotePath = "/")
    {
        try
        {
            var files = await client.GetListingAsync(remotePath);
            Console.WriteLine($"目录 {remotePath} 的内容:");
            foreach (var file in files)
            {
                var type = file.Type == FtpObjectType.File ? "文件" : "目录";
                Console.WriteLine($"{type}: {file.Name} ({file.Size} bytes)");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"列表获取失败: {ex.Message}");
        }
    }

    // 创建目录
    public async Task CreateDirectoryAsync(string remotePath)
    {
        try
        {
            await client.CreateDirectoryAsync(remotePath);
            Console.WriteLine($"目录创建成功: {remotePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"目录创建失败: {ex.Message}");
        }
    }

    // 删除文件
    public async Task DeleteFileAsync(string remotePath)
    {
        try
        {
            await client.DeleteFileAsync(remotePath);
            Console.WriteLine($"文件删除成功: {remotePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"文件删除失败: {ex.Message}");
        }
    }

    // 断开连接
    public void Disconnect()
    {
        client?.Disconnect();
        Console.WriteLine("连接已断开");
    }
}

实际使用案例

案例1：基础文件传输

class Program
{
    static async Task Main(string[] args)
    {
        // 使用FluentFTP的例子
        var ftpClient = new ModernFtpClient("ftp.example.com", "username", "password");
        
        try
        {
            // 连接
            await ftpClient.ConnectAsync();
            
            // 上传文件
            await ftpClient.UploadFileAsync(@"C:\local\document.txt", "/remote/document.txt");
            
            // 查看服务器文件
            await ftpClient.ListFilesAsync("/remote/");
            
            // 下载文件
            await ftpClient.DownloadFileAsync("/remote/document.txt", @"C:\downloads\document.txt");
            
            // 断开连接
            ftpClient.Disconnect();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"操作失败: {ex.Message}");
        }
    }
}

案例2：批量文件处理

public class BatchFtpProcessor
{
    private ModernFtpClient ftpClient;

    public BatchFtpProcessor(string server, string username, string password)
    {
        ftpClient = new ModernFtpClient(server, username, password);
    }

    // 批量上传文件夹
    public async Task UploadFolderAsync(string localFolderPath, string remoteFolderPath)
    {
        await ftpClient.ConnectAsync();

        try
        {
            // 创建远程目录
            await ftpClient.CreateDirectoryAsync(remoteFolderPath);

            // 获取本地所有文件
            string[] files = Directory.GetFiles(localFolderPath);

            foreach (string file in files)
            {
                string fileName = Path.GetFileName(file);
                string remotePath = $"{remoteFolderPath}/{fileName}";
                
                Console.WriteLine($"正在上传: {fileName}");
                await ftpClient.UploadFileAsync(file, remotePath);
            }

            Console.WriteLine("批量上传完成！");
        }
        finally
        {
            ftpClient.Disconnect();
        }
    }

    // 同步本地和远程文件夹
    public async Task SyncFoldersAsync(string localPath, string remotePath)
    {
        await ftpClient.ConnectAsync();

        try
        {
            // 获取远程文件列表
            await ftpClient.ListFilesAsync(remotePath);

            // 这里可以实现更复杂的同步逻辑
            // 比较本地和远程文件的修改时间、大小等
            
            Console.WriteLine("文件夹同步完成！");
        }
        finally
        {
            ftpClient.Disconnect();
        }
    }
}

常见问题和解决方案

1. 连接超时

// 设置超时时间
client.ConnectTimeout = 10000; // 10秒
client.ReadTimeout = 10000;
client.DataConnectionConnectTimeout = 10000;

2. 防火墙问题

// 使用被动模式
client.DataConnectionType = FtpDataConnectionType.PASV;

3. 安全连接（FTPS）

// 启用SSL/TLS
client.EncryptionMode = FtpEncryptionMode.Explicit; // 或 Implicit
client.ValidateAnyCertificate = true; // 仅用于测试

4. 错误处理最佳实践

public async Task<bool> SafeUploadAsync(string localPath, string remotePath)
{
    try
    {
        await client.ConnectAsync();
        var result = await client.UploadFileAsync(localPath, remotePath);
        return result == FtpStatus.Success;
    }
    catch (FtpException ftpEx)
    {
        Console.WriteLine($"FTP错误: {ftpEx.Message}");
        return false;
    }
    catch (IOException ioEx)
    {
        Console.WriteLine($"文件IO错误: {ioEx.Message}");
        return false;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"未知错误: {ex.Message}");
        return false;
    }
    finally
    {
        if (client.IsConnected)
            client.Disconnect();
    }
}

性能优化建议

1. 连接复用

// 保持连接开启，处理多个文件
await client.ConnectAsync();
// ... 多个文件操作
client.Disconnect(); // 最后再断开

2. 异步操作

// 使用异步方法避免阻塞UI
await client.UploadFileAsync(localPath, remotePath);

3. 进度监控

// 使用进度回调
var progress = new Progress<FtpProgress>(p => {
    Console.WriteLine($"进度: {p.Progress:P2}");
});

await client.UploadFileAsync(localPath, remotePath, 
    FtpRemoteExists.Overwrite, false, FtpVerify.None, progress);

总结

FTP协议虽然古老，但在文件传输场景中仍然非常实用。在.NET环境中：

  • 简单需求：使用内置的 FtpWebRequest

  • 复杂需求：推荐使用 FluentFTP 库

  • 安全需求：考虑使用 FTPS 或 SFTP

记住要始终处理异常情况，正确管理连接的建立和断开，这样就能构建出稳定可靠的FTP客户端应用程序了！

依赖注入
MyGo新MV 描绘未来！

Comment