FileCopier.cs

using System;
using System.IO;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;

namespace RoboCopyApp
{
    public class FileCopier
    {
        public static async Task CopyFileAsync(
            FileTransferTask task, 
            int bufferSize, 
            int maxRetries, 
            bool verifyChecksum,
            Action<long> onProgress,
            CancellationToken cancellationToken)
        {
            int currentTry = 0;
            while (currentTry <= maxRetries)
            {
                try
                {
                    task.State = TransferState.Transferring;
                    
                    Directory.CreateDirectory(Path.GetDirectoryName(task.DestinationPath)!);

                    using (var sourceStream = new FileStream(task.SourcePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan))
                    using (var destStream = new FileStream(task.DestinationPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize, FileOptions.Asynchronous))
                    {
                        byte[] buffer = new byte[bufferSize];
                        int bytesRead;
                        
                        while ((bytesRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) > 0)
                        {
                            await destStream.WriteAsync(buffer, 0, bytesRead, cancellationToken);
                            onProgress(bytesRead);
                        }
                    }

                    if (verifyChecksum)
                    {
                        task.State = TransferState.Verifying;
                        bool isValid = await VerifyChecksumsAsync(task.SourcePath, task.DestinationPath, bufferSize, cancellationToken);
                        if (!isValid)
                        {
                            throw new Exception("Checksum verification failed. Data corrupted during transfer.");
                        }
                    }

                    task.State = TransferState.Completed;
                    return; // Success
                }
                catch (OperationCanceledException)
                {
                    task.State = TransferState.Failed;
                    throw;
                }
                catch (Exception ex)
                {
                    currentTry++;
                    task.RetryCount = currentTry;
                    task.ErrorMessage = ex.Message;
                    
                    if (currentTry > maxRetries)
                    {
                        task.State = TransferState.Failed;
                        throw;
                    }
                    
                    // Wait before retrying (exponential backoff)
                    await Task.Delay(1000 * currentTry, cancellationToken);
                }
            }
        }

        private static async Task<bool> VerifyChecksumsAsync(string source, string dest, int bufferSize, CancellationToken ct)
        {
            using var sha256 = SHA256.Create();
            
            byte[] hashSource;
            byte[] hashDest;

            using (var fsSource = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan))
            {
                hashSource = await ComputeHashAsync(sha256, fsSource, bufferSize, ct);
            }

            using (var fsDest = new FileStream(dest, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan))
            {
                hashDest = await ComputeHashAsync(sha256, fsDest, bufferSize, ct);
            }

            return CryptographicOperations.FixedTimeEquals(hashSource, hashDest);
        }

        private static async Task<byte[]> ComputeHashAsync(HashAlgorithm algorithm, Stream stream, int bufferSize, CancellationToken ct)
        {
            byte[] buffer = new byte[bufferSize];
            int bytesRead;
            while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, ct)) > 0)
            {
                algorithm.TransformBlock(buffer, 0, bytesRead, buffer, 0);
            }
            algorithm.TransformFinalBlock(buffer, 0, 0);
            return algorithm.Hash!;
        }
    }
}