using System;
using System.IO;
 
namespace TestConsole
{
    struct Point
    {
        public int X;
        public int Y;
 
        public Point(int x, int y)
        {
            X = x;
            Y = y;
        }
 
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Point cpos = new Point(Console.CursorLeft, Console.CursorTop);
 
            FileStream fs = File.OpenRead("c:\\in\\source.dat" );
            FileStream fd = File.Create("c:\\in\\destination.dat" );
            double totallength = (double)fs.Length;
            double filepos = (double)fs.Position;
 
            byte[] buffer = new byte[1024];
 
            int length;
            int percent = 0;
            int oldpercent = 0;
 
            Console.Write("  0 %" );
 
            while ((length = fs.Read(buffer, 0, buffer.Length)) > 0)
            {
                filepos = (double)fs.Position;
                fd.Write(buffer, 0, length);
                percent = (int)((filepos / totallength) * 100);
                if (percent != oldpercent)
                {
                    Console.SetCursorPosition(cpos.X, cpos.Y);
                    Console.Write(string.Format("{0} %", percent).PadLeft(5, ' '));
                    oldpercent = percent;
                }
            }
 
            Console.WriteLine();
            Console.WriteLine("Terminé" );
            Console.ReadKey(true);
        }
    }
}

1. FileStream fs = File.OpenRead(@"c:\in\source.dat" );
2. FileStream fd = File.Create(@"c:\in\destination.dat" );

using System;
using System.IO;
using AdvancedFileManager;
 
 
namespace TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            MainProgram mp = new MainProgram();
            mp.Run();
        }
    }
 
    class MainProgram
    {
        int lineSource = 0;
        int lineDestination = 0;
 
        public MainProgram()
        {
        }
 
        public void Run()
        {
            Console.WriteLine("Lancement des threads..." );
 
            Console.WriteLine();
 
            lineSource = Console.CursorTop;
            lineDestination = lineSource + 1;
 
            AdvancedFileManager.AdvancedFileManager afm = new AdvancedFileManager.AdvancedFileManager();
            afm.SourceFileCopyEvent += new FileCopyEventHandler(afm_SourceFileCopyEvent);
            afm.DestinationFileCopyEvent += new FileCopyEventHandler(afm_DestinationFileCopyEvent);
 
            try
            {
                afm.AsyncCopy(@"c:\in\source.dat", @"c:\in\destination.dat", true);
            }
            catch (Exception e)
            {
                Console.WriteLine("Une erreur s'est produite..." );
                Console.WriteLine(e.Message);
            }
 
            Console.SetCursorPosition(0, lineDestination + 2);
 
            Console.WriteLine("Terminé" );
            Console.ReadKey(true);
        }
 
        void afm_SourceFileCopyEvent(object sender, FileCopyEventArgs e)
        {
            DrawPercent(lineSource, e.Percent, "Source:" );
        }
 
        void afm_DestinationFileCopyEvent(object sender, FileCopyEventArgs e)
        {
            DrawPercent(lineDestination, e.Percent, "Destination:" );
        }
 
        public void DrawPercent(int line, int percent, string prefix)
        {
            lock (this)
            {
                Console.SetCursorPosition(0, line);
                Console.Write("{0} [{1}] {2}%", prefix.PadRight(13, ' '), new string('█', (percent / 5)).PadRight(20, '='), percent.ToString().PadLeft(3, ' '));
            }
        }
    }
}

using System;
using System.Collections;
using System.IO;
using System.Threading;
 
namespace AdvancedFileManager
{
    public delegate void FileCopyEventHandler(object sender, FileCopyEventArgs e);
 
    public class FileCopyEventArgs : EventArgs
    {
        public int Percent;
 
        public FileCopyEventArgs(int percent)
        {
            Percent = percent;
        }
    }
 
    public class AdvancedFileManager
    {
        public event FileCopyEventHandler SourceFileCopyEvent;
        public event FileCopyEventHandler DestinationFileCopyEvent;
 
        public const int BUFFER_SIZE = 1024;
        public const int QUEUE_SIZE = BUFFER_SIZE * 20;
 
        public void AsyncCopy(string source, string destination, bool overwrite)
        {
            // Usual verifications
            if (!File.Exists(source))
            {
                throw new FileNotFoundException("Source file does not exists!" );
            }
 
            if (File.Exists(destination) && !overwrite)
            {
                throw new Exception("Destination file already exists but overwrite is disabled!" );
            }
 
            Queue queue = new Queue();
 
            // Ajouter les messages d'erreur propre en cas de problème d'accès aux fichiers
            FileProducer Prod = new FileProducer(queue, source);
            FileConsumer Cons = new FileConsumer(queue, destination, Prod.Length);
 
            Prod.FileCopyEvent += new FileCopyEventHandler(Prod_FileCopyEvent);
            Cons.FileCopyEvent += new FileCopyEventHandler(Cons_FileCopyEvent);
 
            Thread Producer = new Thread(new ThreadStart(Prod.ThreadRun));
            Thread Consumer = new Thread(new ThreadStart(Cons.ThreadRun));
 
            try
            {
                Producer.Start();
                Consumer.Start();
 
                Producer.Join();
                Consumer.Join();
            }
            catch
            {
                throw new Exception("Unhandled exception while running threads" );
            }
        }
 
        private void Prod_FileCopyEvent(object sender, FileCopyEventArgs e)
        {
            OnSourceFileCopyNotification(new FileCopyEventArgs(e.Percent));
        }
 
        private void Cons_FileCopyEvent(object sender, FileCopyEventArgs e)
        {
            OnDestinationFileCopyNotification(new FileCopyEventArgs(e.Percent));
        }
 
        protected virtual void OnSourceFileCopyNotification(FileCopyEventArgs e)
        {
            SourceFileCopyEvent(this, e);
        }
 
        protected virtual void OnDestinationFileCopyNotification(FileCopyEventArgs e)
        {
            DestinationFileCopyEvent(this, e);
        }
 
        private class FileProducer
        {
            public double Length;
 
            FileStream fs;
            string filename;
            Queue q;
            int oldPercent = 0, percent = 0;
 
            public event FileCopyEventHandler FileCopyEvent;
 
            public FileProducer(Queue queue, string source)
            {
                q = queue;
                filename = source;
 
                FileInfo fi = new FileInfo(filename);
                Length = (double)fi.Length;
            }
 
            public void ThreadRun()
            {
                fs = File.OpenRead(filename);
 
                byte[] buffer = new byte[BUFFER_SIZE];
                int length;
 
                while ((length = fs.Read(buffer, 0, BUFFER_SIZE)) > 0)
                {
                    
                    Monitor.Enter(q);
 
                    while (q.Count > QUEUE_SIZE)
                    {
                        // Wait until the consummer consume some data in the buffer
                        Monitor.Wait(q);
                    }
 
                    percent = (int)((double)fs.Position / Length * 100);
                    if (percent != oldPercent)
                    {
                        OnFileCopyNotification(new FileCopyEventArgs(percent));
                        oldPercent = percent;
                    }
 
                    if (length < BUFFER_SIZE)
                    {
                        byte[] b = new byte[length];
                        for (int i = 0; i < length; i++)
                        {
                            b[i] = buffer[i];
                        }
                        q.Enqueue(b);
                    }
                    else
                    {
                        q.Enqueue(buffer.Clone());
                    }
 
                    Monitor.Pulse(q);
                    Monitor.Exit(q);
                }
 
                Monitor.Enter(q);
                // Don't care is Queue is full, as it's the last item and it's 0-length
                q.Enqueue(new byte[0]);
                Monitor.Pulse(q);
                Monitor.Exit(q);
 
                fs.Close();
                fs.Dispose();
            }
 
            protected virtual void OnFileCopyNotification(FileCopyEventArgs e)
            {
                FileCopyEvent(this, e);
            }
        }
 
        private class FileConsumer
        {
            FileStream fd;
            string filename;
            Queue q;
            double TotalLength;
            int oldPercent = 0, percent = 0;
 
            public event FileCopyEventHandler FileCopyEvent;
 
            public FileConsumer(Queue queue, string destination, double sourcelength)
            {
                q = queue;
                filename = destination;
                TotalLength = sourcelength;
            }
 
            public void ThreadRun()
            {
                fd = File.Create(filename);
                object o;
                byte[] buffer;
                bool Continue = true;
 
                while (Continue)
                {
                    Monitor.Enter(q);
 
                    if (q.Count == 0)
                    {
                        Monitor.Wait(q);
                    }
 
                    o = q.Dequeue();
                    buffer = (byte[])o;
 
                    if (buffer.Length == 0)
                    {
                        Continue = false;
                    }
                    
                    Monitor.Pulse(q);
                    Monitor.Exit(q);
 
                    if (Continue)
                    {
                        fd.Write(buffer, 0, buffer.Length);
 
                        percent = (int)((double)fd.Position / TotalLength * 100);
                        if (percent != oldPercent)
                        {
                            OnFileCopyNotification(new FileCopyEventArgs(percent));
                            oldPercent = percent;
                        }
                    }
                }
 
                fd.Close();
                fd.Dispose();
            }
 
            protected virtual void OnFileCopyNotification(FileCopyEventArgs e)
            {
                FileCopyEvent(this, e);
            }
        }
    }
}