## Introduction FTP remains common in ERP integrations despite being 50 years old. Network issues, file locks, and concurrent access make reliable synchronization challenging. This article shows battle-tested patterns from production systems processing millions of files. ## Basic FTP Client ### FluentFTP Setup ```csharp public class FtpSyncService { private readonly ILogger _logger; private readonly FtpConfig _config; public async Task CreateClientAsync() { var client = new FtpClient { Host = _config.Host, Port = _config.Port, Credentials = new NetworkCredential( _config.Username, _config.Password), Config = new FtpConfig { EncryptionMode = FtpEncryptionMode.Auto, ValidateAnyCertificate = true, ConnectTimeout = 10000, DataConnectionType = FtpDataConnectionType.PASV } }; await client.AutoConnectAsync(); return client; } } ``` ## Retry with Exponential Backoff ### Polly Policy ```csharp private static readonly AsyncRetryPolicy _retryPolicy = Policy .Handle() .Or() .Or() .WaitAndRetryAsync( retryCount: 5, sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), onRetry: (exception, timeSpan, attempt, context) => { _logger.Warn($"Retry {attempt} after {timeSpan.TotalSeconds}s: {exception.Message}"); }); public async Task UploadWithRetryAsync(string localPath, string remotePath) { return await _retryPolicy.ExecuteAsync(async () => { using var client = await CreateClientAsync(); var result = await client.UploadFileAsync( localPath, remotePath, FtpRemoteExists.Overwrite); return result == FtpStatus.Success; }); } ``` ### Custom Retry Logic ```csharp public async Task ExecuteWithRetryAsync( Func> operation, int maxAttempts = 5) { var delays = new[] { 1, 2, 4, 8, 16 }; // seconds for (int attempt = 1; attempt <= maxAttempts; attempt++) { try { return await operation(); } catch (Exception ex) when (attempt < maxAttempts) { var delay = TimeSpan.FromSeconds(delays[attempt - 1]); _logger.Warn($"Attempt {attempt} failed: {ex.Message}. Retrying in {delay.TotalSeconds}s"); await Task.Delay(delay); } } throw new InvalidOperationException($"Operation failed after {maxAttempts} attempts"); } ``` ## File Lock Handling ### Check if File is Locked ```csharp private async Task IsFileLockedAsync(FtpClient client, string remotePath) { try { // Try to rename - if locked, will fail var tempName = $"{remotePath}.lock_check"; await client.RenameAsync(remotePath, tempName); await client.RenameAsync(tempName, remotePath); return false; } catch (FtpException) { return true; } } public async Task WaitForFileUnlockAsync( FtpClient client, string remotePath, TimeSpan maxWait) { var stopwatch = Stopwatch.StartNew(); while (stopwatch.Elapsed < maxWait) { if (!await IsFileLockedAsync(client, remotePath)) return; await Task.Delay(1000); } throw new TimeoutException($"File {remotePath} remained locked for {maxWait}"); } ``` ## Partial Download Resume ### Resume Download ```csharp public async Task DownloadWithResumeAsync( string remotePath, string localPath) { using var client = await CreateClientAsync(); var remoteSize = await client.GetFileSizeAsync(remotePath); var localSize = File.Exists(localPath) ? new FileInfo(localPath).Length : 0; if (localSize == remoteSize) { _logger.Info($"File {remotePath} already downloaded"); return true; } if (localSize > 0 && localSize < remoteSize) { _logger.Info($"Resuming download from byte {localSize}"); using var fileStream = new FileStream( localPath, FileMode.Append, FileAccess.Write); await client.DownloadStreamAsync( fileStream, remotePath, localSize); // start position } else { await client.DownloadFileAsync( localPath, remotePath, FtpLocalExists.Overwrite); } return true; } ``` ## Atomic Upload Pattern ### Upload to Temp, Then Rename ```csharp public async Task UploadAtomicAsync( string localPath, string remotePath) { using var client = await CreateClientAsync(); var tempPath = $"{remotePath}.tmp"; try { // Upload to temporary file await client.UploadFileAsync( localPath, tempPath, FtpRemoteExists.Overwrite); // Verify upload var localSize = new FileInfo(localPath).Length; var remoteSize = await client.GetFileSizeAsync(tempPath); if (localSize != remoteSize) { throw new InvalidOperationException( $"Size mismatch: local={localSize}, remote={remoteSize}"); } // Atomic rename if (await client.FileExistsAsync(remotePath)) { await client.DeleteFileAsync(remotePath); } await client.RenameAsync(tempPath, remotePath); return true; } catch { // Cleanup temp file on failure if (await client.FileExistsAsync(tempPath)) { await client.DeleteFileAsync(tempPath); } throw; } } ``` ## Directory Synchronization ### Sync Remote to Local ```csharp public async Task SyncDirectoryAsync( string remotePath, string localPath) { using var client = await CreateClientAsync(); var remoteFiles = await client.GetListingAsync(remotePath); var localFiles = Directory.GetFiles(localPath) .Select(f => Path.GetFileName(f)) .ToHashSet(); foreach (var remoteFile in remoteFiles.Where(f => f.Type == FtpObjectType.File)) { var remoteFilePath = remoteFile.FullName; var localFilePath = Path.Combine(localPath, remoteFile.Name); var shouldDownload = !File.Exists(localFilePath) || remoteFile.Modified > File.GetLastWriteTimeUtc(localFilePath); if (shouldDownload) { _logger.Info($"Downloading {remoteFile.Name}"); await DownloadWithResumeAsync(remoteFilePath, localFilePath); } localFiles.Remove(remoteFile.Name); } // Delete local files not on remote foreach (var orphanFile in localFiles) { var localFilePath = Path.Combine(localPath, orphanFile); _logger.Info($"Deleting orphan file {orphanFile}"); File.Delete(localFilePath); } } ``` ## Conflict Resolution ### Timestamp-Based ```csharp public async Task ResolveConflictAsync( FtpClient client, string remotePath, string localPath) { var remoteModified = await client.GetModifiedTimeAsync(remotePath); var localModified = File.GetLastWriteTimeUtc(localPath); if (remoteModified > localModified) { return ConflictResolution.UseRemote; } else if (localModified > remoteModified) { return ConflictResolution.UseLocal; } // Same timestamp - compare size var remoteSize = await client.GetFileSizeAsync(remotePath); var localSize = new FileInfo(localPath).Length; return remoteSize == localSize ? ConflictResolution.Identical : ConflictResolution.Manual; } ``` ## Monitoring and Logging ### Transfer Progress ```csharp public async Task UploadWithProgressAsync( string localPath, string remotePath, IProgress progress) { using var client = await CreateClientAsync(); var result = await client.UploadFileAsync( localPath, remotePath, FtpRemoteExists.Overwrite, progress: progress); if (result != FtpStatus.Success) { throw new InvalidOperationException($"Upload failed: {result}"); } } public async Task UploadBatchWithReportingAsync(List files) { var progress = new Progress(p => { _logger.Info($"Progress: {p.Progress:P} ({p.TransferredBytes}/{p.FileSize} bytes)"); }); foreach (var file in files) { await UploadWithProgressAsync(file, $"/upload/{Path.GetFileName(file)}", progress); } } ``` ## Connection Pooling ### Simple Pool ```csharp public class FtpConnectionPool : IDisposable { private readonly ConcurrentBag _pool = new(); private readonly SemaphoreSlim _semaphore; private readonly int _maxSize; public FtpConnectionPool(int maxSize = 5) { _maxSize = maxSize; _semaphore = new SemaphoreSlim(maxSize, maxSize); } public async Task RentAsync() { await _semaphore.WaitAsync(); if (_pool.TryTake(out var client) && client.IsConnected) { return client; } return await CreateClientAsync(); } public void Return(FtpClient client) { if (client.IsConnected && _pool.Count < _maxSize) { _pool.Add(client); } else { client.Dispose(); } _semaphore.Release(); } public void Dispose() { while (_pool.TryTake(out var client)) { client.Dispose(); } _semaphore.Dispose(); } } ``` ## Production Checklist - ✅ Retry logic with exponential backoff (1s, 2s, 4s, 8s, 16s) - ✅ File lock detection and waiting - ✅ Partial download resume for large files - ✅ Atomic uploads (temp + rename) - ✅ Conflict resolution strategy - ✅ Connection pooling for performance - ✅ Progress reporting and monitoring - ✅ Comprehensive error logging - ✅ Cleanup of temporary files - ✅ Timeout configuration