Файлы, сеть, многопоточность: оптимизация кода

private void ArrayCopyFile()
        {
            //http://stackoverflow.com/questions/1246899/file-copy-vs-manual-filestream-write-for-copying-file
            //http://stackoverflow.com/questions/995320/file-writeallbytes-causes-error-insufficient-system-resources-exist-to-complete#995320
            const int bufferSize = 1024*1024;
            var headerBytes = new byte[_headerManager.HeaderSize()];
            FileStream src = new FileStream(SrcFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            FileStream dst = new FileStream(DstFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
            try
            {
                // выясним, увеличился ли исходный файл
                if (src.Length > _currPos)
                {
                    // чтение заголовка файла
                    src.Read(headerBytes, 0, headerBytes.Length);
                }
                else 
                {
                    Trace("Исходный файл '{0}' не изменился со времени последней синхронизации",
                        SrcFile);
                    return;
                }
                if (!CheckDstDirectory())
                {                    
                    return;
                }
                if (_currPos > 0)
                {
                    // записываем заголовок
                    dst.Write(headerBytes, 0, headerBytes.Length);
                    // резервируем место
                    dst.SetLength(src.Length);
                    // устанавливаем позицию на такую же, как у исходного файла ДО считывания очередной порции байт
                    dst.Seek(_currPos, SeekOrigin.Begin);
                }
                src.Position = _currPos;
                int bytesRead;
                byte[] bytes = new byte[bufferSize];
                while ((bytesRead = src.Read(bytes, 0, bufferSize)) > 0)
                {
                    dst.Write(bytes, 0, bytesRead);
                    _currPos += bytesRead;
                }
            }
            finally
            {
                src.Dispose();
                dst.Dispose();
            }
        }

public static bool CompareFiles(string filePath1, string filePath2)
        {
            long fileLength;
            if((fileLength = new FileInfo(filePath1).Length) != new FileInfo(filePath2).Length)
                return false;
            bool filesAreEquals = true;
            const int size = 1024*1024; //0x1000000;
            int countIteration = (int)Math.Ceiling(fileLength / (double)size);
            Parallel.For(0, countIteration, x =>
            {
                if(!filesAreEquals) return;
                var start = x * size;
                if (start >= fileLength) return;
                int realSize = (int) (x == countIteration - 1 ? fileLength - start : size);
                using (FileStream file = File.OpenRead(filePath1))
                using (FileStream file2 = File.OpenRead(filePath2))
                {
                    var buffer = new byte[realSize];
                    var buffer2 = new byte[realSize];
                    file.Position = start;
                    file2.Position = start;
                    int count = file.Read(buffer, 0, realSize);
                    file2.Read(buffer2, 0, realSize);
                    for (int i = 0; i < count; i++)
                        if (buffer[i] != buffer2[i])
                        {
                            filesAreEquals = false;
                            return;
                        }
                }
            });
            return filesAreEquals;
        }

class QueueTasks<T> : IDisposable
    {
        private readonly Queue<T> _tasks = new Queue<T>();
        readonly object _syncObj = new object();
        private readonly AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
        private readonly ManualResetEvent _exitEvent = new ManualResetEvent(false);
        private bool _isRunning;
 
        public bool IsRunning
        {
            get { return _isRunning; }
            private set
            {
                _isRunning = value;
                if(!_isRunning) OnQueueTasksStopped();
            }
        }
 
        public delegate void QueueTasksStoppedEventHandler(object sender);
        public event QueueTasksStoppedEventHandler QueueTasksStopped;
        protected virtual void OnQueueTasksStopped()
        {
            var handler = QueueTasksStopped;
            if (handler != null) handler(this);
        }
 
        public delegate void TaskReceivedEventHandler(object sender, T eventArgs);
        public event TaskReceivedEventHandler TaskReceived;
        protected virtual void OnTaskReceived(T eventArgs)
        {
            var handler = TaskReceived;
            if (handler != null) handler(this, eventArgs);
        }
        
        public void Stop()
        {
            _exitEvent.Set();
            _autoResetEvent.Set();
        }
 
        public void Start()
        {
            if(IsRunning) throw new InvalidOperationException("Очередь задач уже работает");
            IsRunning = true;
            _autoResetEvent.WaitOne();
            _exitEvent.WaitOne();
            new Thread(Work) { Name = "Очередь задач" }.Start();
        }
 
        public void Add(T data)
        {
            SafeAdd(data);
        }
 
        void SafeAdd(T data)
        {
            lock (_syncObj) _tasks.Enqueue(data);
            _autoResetEvent.Set();
        }
 
        T SafeRemove()
        {
            lock (_syncObj)
                if (_tasks.Count > 0)
                    return _tasks.Dequeue();
            return default(T);
        }
 
        void Work()
        {
            while (!_exitEvent.WaitOne(0, false))
            {
                _autoResetEvent.WaitOne();
                while (_tasks.Count != 0)
                    OnTaskReceived(SafeRemove());
            }
            IsRunning = true;
        }
 
        public void Dispose()
        {
            Stop();
        }
    }