基于C#实现的多线程文件上传下载工具

<!-- FluentFTP 用于FTP操作 -->
<PackageReference Include="FluentFTP" Version="39.0.0" />
<!-- Newtonsoft.Json 用于配置管理 -->
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

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

public class FtpService : IDisposable
{
    private readonly FtpClient _client;
    private readonly SemaphoreSlim _semaphore;

    public FtpService(string host, string user, string pass, int maxConcurrent = 5)
    {
        _client = new FtpClient(host, user, pass);
        _semaphore = new SemaphoreSlim(maxConcurrent);
    }

    public async Task<bool> UploadFile(string localPath, string remotePath, bool resume = false)
    {
        await _semaphore.WaitAsync();
        try
        {
            using var fileStream = File.OpenRead(localPath);
            var remoteSize = await _client.GetFileSizeAsync(remotePath);
            
            if (resume && remoteSize > 0)
            {
                fileStream.Seek(remoteSize, SeekOrigin.Begin);
                await _client.UploadFileAsync(fileStream, remotePath, FtpRemoteExists.Append, true);
            }
            else
            {
                await _client.UploadFileAsync(fileStream, remotePath, FtpRemoteExists.Overwrite, true);
            }
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"上传失败: {ex.Message}");
            return false;
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public async Task<bool> DownloadFile(string remotePath, string localPath, bool resume = false)
    {
        await _semaphore.WaitAsync();
        try
        {
            using var fileStream = File.OpenWrite(localPath);
            long remoteSize = await _client.GetFileSizeAsync(remotePath);
            long localSize = File.Exists(localPath) ? new FileInfo(localPath).Length : 0;

            if (resume && localSize < remoteSize)
            {
                await _client.DownloadFileAsync(fileStream, remotePath, FtpLocalExists.Append, FtpVerify.Retry);
            }
            else
            {
                await _client.DownloadFileAsync(fileStream, remotePath, FtpLocalExists.Create, FtpVerify.Retry);
            }
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"下载失败: {ex.Message}");
            return false;
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public void Dispose()
    {
        _client?.Dispose();
        _semaphore?.Dispose();
    }
}

using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

public class TransferManager : IDisposable
{
    private readonly ConcurrentQueue<TransferTask> _uploadQueue = new();
    private readonly ConcurrentQueue<TransferTask> _downloadQueue = new();
    private readonly CancellationTokenSource _cts = new();
    private readonly FtpService _ftpService;

    public TransferManager(FtpService ftpService)
    {
        _ftpService = ftpService;
        StartProcessing();
    }

    public void EnqueueUpload(string localPath, string remotePath)
    {
        _uploadQueue.Enqueue(new TransferTask(localPath, remotePath, TransferType.Upload));
    }

    public void EnqueueDownload(string remotePath, string localPath)
    {
        _downloadQueue.Enqueue(new TransferTask(remotePath, localPath, TransferType.Download));
    }

    private async void StartProcessing()
    {
        while (!_cts.Token.IsCancellationRequested)
        {
            if (_uploadQueue.TryDequeue(out var task))
            {
                await ProcessTask(task);
            }
            else if (_downloadQueue.TryDequeue(out task))
            {
                await ProcessTask(task);
            }
            await Task.Delay(100);
        }
    }

    private async Task ProcessTask(TransferTask task)
    {
        try
        {
            bool success = task.Type == TransferType.Upload
                ? await _ftpService.UploadFile(task.Source, task.Destination)
                : await _ftpService.DownloadFile(task.Source, task.Destination);

            OnTaskCompleted?.Invoke(task, success);
        }
        catch
        {
            OnTaskFailed?.Invoke(task);
        }
    }

    public event Action<TransferTask, bool> OnTaskCompleted;
    public event Action<TransferTask> OnTaskFailed;

    public void Dispose()
    {
        _cts.Cancel();
        _ftpService?.Dispose();
    }
}

public enum TransferType { Upload, Download }
public class TransferTask
{
    public string Source { get; }
    public string Destination { get; }
    public TransferType Type { get; }

    public TransferTask(string source, string destination, TransferType type)
    {
        Source = source;
        Destination = destination;
        Type = type;
    }
}

<Window x:Class="FileTransferTool.MainWindow"
        Title="多线程文件传输工具" Height="450" Width="800">
    <DockPanel>
        <StatusBar DockPanel.Dock="Bottom">
            <TextBlock Text="{Binding StatusText}"/>
            <ProgressBar Value="{Binding Progress}" Width="200"/>
        </StatusBar>
        
        <TabControl>
            <TabItem Header="上传队列">
                <DataGrid ItemsSource="{Binding UploadTasks}" AutoGenerateColumns="False">
                    <DataGrid.Columns>
                        <DataGridTextColumn Header="文件名" Binding="{Binding Source}"/>
                        <DataGridTextColumn Header="进度" Binding="{Binding Progress}"/>
                    </DataGrid.Columns>
                </DataGrid>
            </TabItem>
            <TabItem Header="下载队列">
                <!-- 下载队列界面 -->
            </TabItem>
        </TabControl>
    </DockPanel>
</Window>

public class TransferViewModel : INotifyPropertyChanged
{
    private int _progress;
    public int Progress
    {
        get => _progress;
        set
        {
            _progress = value;
            OnPropertyChanged(nameof(Progress));
        }
    }

    private string _statusText = "就绪";
    public string StatusText
    {
        get => _statusText;
        set
        {
            _statusText = value;
            OnPropertyChanged(nameof(StatusText));
        }
    }

    public ObservableCollection<TransferTask> UploadTasks { get; } = new();
    public ObservableCollection<TransferTask> DownloadTasks { get; } = new();

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

{
  "FtpSettings": {
    "Host": "ftp.example.com",
    "Username": "user",
    "Password": "pass",
    "MaxConcurrent": 8,
    "BufferSize": 8388608
  },
  "TransferPaths": {
    "UploadDir": "D:\\Uploads",
    "DownloadDir": "D:\\Downloads"
  }
}

FileTransferTool.exe --mode server --port 2121 --root C:\Shared
FileTransferTool.exe --mode client --host ftp.example.com --user user --pass pass