C#

progressPanel1.Visible = true;

backgroundWorker1.RunWorkerAsync();

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.IO;
using System.Data.SqlClient;
using BackgroundFileMove.UtilityCode;
using System.Windows.Forms;
using Microsoft.WindowsAPICodePack.Taskbar;
using System.Reflection;

namespace BackgroundFileMove
    {
    /// <summary>
    /// Background process - move the files
    /// </summary>
    public partial class frmMoveFilesInBackground : Form
        {
        #region Constants
        /// <summary>
        /// Block transfers allow us to do file progress reporting, and use less memory
        /// </summary>
        private const int blockSize = 8 * 1024 * 1024;
        #endregion

        #region Fields
        #region Internal
        /// <summary>
        /// When true, stops processing
        /// </summary>
        private volatile bool cancel = false;
        /// <summary>
        /// Delegate to call to do the move
        /// </summary>
        private FileMove.MoveFile moveDelegate;
        /// <summary>
        /// Delegate to call to do the DB update.
        /// </summary>
        private FileMove.UpdateDB updateDelegate;
        /// <summary>
        /// The files to move
        /// </summary>
        private IEnumerable<FileMove> files;
        /// <summary>
        /// Prompt for moving file
        /// </summary>
        private string moveFileAction;
        /// <summary>
        /// Prompt for updating after file move
        /// </summary>
        private string updateDBAction;
        /// <summary>
        /// Prompt for skipping file
        /// </summary>
        private string skippingAction;
        /// <summary>
        /// If true, form will close on completion.
        /// </summary>
        private bool closeOnDone;
        /// <summary>
        /// Block transfers allow us to do file progress reporting, and use less memory
        /// </summary>
        private byte[] transfer = new byte[blockSize];
        /// <summary>
        /// If true, copies the data instead of moving it.
        /// </summary>
        private bool doCopyOnly = false;
        #endregion

        #region Property bases
        #endregion
        #endregion

        #region Properties
        /// <summary>
        /// Gets a true value if the processing is going on.
        /// </summary>
        public bool IsProcessing { get { return butStop.Enabled; } }
        #endregion

        #region Regular Expressions
        #endregion

        #region Enums
        #endregion

        #region Classes
        /// <summary>
        /// Used internally for reporting progress into the display.
        /// </summary>
        private class ProgressReport
            {
            /// <summary>
            /// Name of file involved
            /// </summary>
            public string Filename { get; set; }
            /// <summary>
            /// Description of action taken
            /// </summary>
            public string Action { get; set; }
            /// <summary>
            /// File number in process order
            /// </summary>
            public int FileNumber { get; set; }
            /// <summary>
            /// Total number of files to be processed
            /// </summary>
            public int FilesCount { get; set; }
            /// <summary>
            /// Percentage of the file that has been moved.
            /// </summary>
            public int FilePercentage { get; set; }
            }
        #endregion

        #region Constructors
        /// <summary>
        /// Construct a Background worker for all this stuff.
        /// </summary>
        /// <param name="files">The files to move</param>
        /// <param name="moveDelegate">
        /// If supplied, is called to do the move. If not, File.Move will be used.
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool MoveIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="updateDelegate">
        /// If supplied, is called to update any database
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool UpdateIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="moveFileAction">Text to show in progress window instead of the default.</param>
        /// <param name="updateDBAction">Text to show in progress window instead of the default.</param>
        /// <param name="skippingAction">Text to show in progress window instead of the default.</param>
        /// <param name="closeOnDone">If true, the form will close when run completed</param>
        public frmMoveFilesInBackground(IEnumerable<FileMove> files,
                                        FileMove.MoveFile moveDelegate = null,
                                        FileMove.UpdateDB updateDelegate = null,
                                        string moveFileAction = null,
                                        string updateDBAction = null,
                                        string skippingAction = null,
                                        bool closeOnDone = false)
            {
            InitializeComponent();
            if (moveFileAction == null) moveFileAction = "Moving title...";
            if (updateDBAction == null) updateDBAction = "Updating database...";
            if (skippingAction == null) skippingAction = "Skipping title...";
            this.moveDelegate = moveDelegate;
            this.updateDelegate = updateDelegate;
            this.files = files;
            this.moveFileAction = moveFileAction;
            this.updateDBAction = updateDBAction;
            this.skippingAction = skippingAction;
            this.closeOnDone = closeOnDone;
            string initData = "";
            tbInfo.Text = initData;
            tbInfo.Visible = cancel;
            }
        #endregion

        #region Events
        #region Event Constructors
        /// <summary>
        /// Event to indicate all files moved
        /// </summary>
        public event EventHandler MoveCompleted;
        /// <summary>
        /// Called to signal to subscribers that all files moved
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMoveCompleted(EventArgs e)
            {
            EventHandler eh = MoveCompleted;
            if (eh != null)
                {
                eh(this, e);
                }
            }
        #endregion

        #region Event Handlers
        #region Form
        /// <summary>
        /// Shown - start the move
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void frmMoveFilesInBackground_Shown(object sender, EventArgs e)
            {
            DoBackgroundMove();
            }
        /// <summary>
        /// Restore size and location (if the user doesn't
        /// override it)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void frmMoveFilesInBackground_Load(object sender, EventArgs e)
            {
            if ((ModifierKeys & Keys.Shift) == 0)
                {
                this.LoadLocation();
                }
            }
        /// <summary>
        /// Save the size and location (if the used doesn't
        /// override it)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void frmMoveFilesInBackground_FormClosing(object sender, FormClosingEventArgs e)
            {
            if ((ModifierKeys & Keys.Shift) == 0)
                {
                this.SaveLocation();
                }
            }
        #endregion

        #region Buttons
        /// <summary>
        /// Stop moving at end current operation.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void butStop_Click(object sender, EventArgs e)
            {
            cancel = true;
            }
        #endregion

        #region Worker
        /// <summary>
        /// Move the actual files.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tidyFiles_DoWork(object sender, DoWorkEventArgs e)
            {
            BackgroundWorker worker = sender as BackgroundWorker;
            if (worker != null)
                {
                int fileNumber = 1;
                worker.ReportProgress(0, new ProgressReport { Action = "Initializing", Filename = "", FileNumber = 0, FilesCount = 0 });

                foreach (FileMove file in files)
                    {
                    ProgressReport pr = new ProgressReport { FilesCount = files.Count() };
                    if (cancel)
                        {
                        pr.Action = "Cancelled by user";
                        pr.Filename = "";
                        worker.ReportProgress(pr.FilesCount, pr);
                        break;
                        }
                    string title = file.Title;
                    string fnOld = file.OldPath;
                    string fnNew = file.NewPath;
                    Guid id = file.FileID;
                    pr.FileNumber = fileNumber;
                    pr.Filename = Path.GetFileNameWithoutExtension(fnOld);
                    if (fnNew != fnOld)
                        {
                        try
                            {
                            pr.Action = moveFileAction;
                            worker.ReportProgress(fileNumber, pr);
                            if (moveDelegate != null)
                                {
                                if (!moveDelegate(file))
                                    {
                                    // Move failed - do not update.
                                    continue;
                                    }
                                }
                            else
                                {
                                if (File.Exists(fnOld))
                                    {
                                    string path = Path.GetDirectoryName(fnNew);
                                    if (!Directory.Exists(path))
                                        {
                                        Directory.CreateDirectory(path);
                                        }
                                    MoveFile(fnOld, fnNew, worker, pr);
                                    }
                                else if (!File.Exists(fnNew))
                                    {
                                    // File is completely missing - DB problem?
                                    throw new IOException("Neither the source nor the destination files could be found");
                                    }
                                }
                            if (updateDelegate != null)
                                {
                                pr.Action = updateDBAction;
                                worker.ReportProgress(fileNumber, pr);
                                if (!updateDelegate(file))
                                    {
                                    // Update failed - end run
                                    break;
                                    }
                                }
                            }
                        catch (Exception ex)
                            {
                            string problem = string.Format("Problem with:\n   \"{0}\"\n   \"{1}\"\n   \"{2}\"\n   {3}\n", title, fnOld, fnNew, ex);
                            worker.ReportProgress(fileNumber, new ProgressReport
                            {
                                Action = problem,
                                Filename = fnOld,
                                FileNumber = fileNumber,
                                FilesCount = files.Count()
                            });
                            }
                        }
                    else
                        {
                        // Skip file
                        pr.Action = skippingAction;
                        worker.ReportProgress(fileNumber, pr);
                        }
                    fileNumber++;
                    }
                }
            }
        /// <summary>
        /// Move operation progress report
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tidyFiles_ProgressChanged(object sender, ProgressChangedEventArgs e)
            {
            int progress = e.ProgressPercentage;
            ProgressReport report = e.UserState as ProgressReport;
            if (report == null)
                {
                tbInfo.Text = "Working...";
                pbShow.Visible = false;
                }
            else
                {
                tbInfo.Lines = string.Format("{0}\n{1}/{2}\n{3}", report.Action, report.FileNumber, report.FilesCount, report.Filename).Split('\n');
                pbShow.Maximum = report.FilesCount;
                pbShow.Visible = true;
                if (progress >= 0)
                    {
                    int newIndex = dgvHistory.Rows.Add(report.Action, report.Filename);
                    dgvHistory.CurrentCell = dgvHistory.Rows[newIndex].Cells[0];
                    Text = string.Format("Moving: {0}", report.Action);
                    TaskbarManager.Instance.SetProgressValue(report.FileNumber, report.FilesCount);
                    }
                else
                    {
                    progress = -progress;
                    }
                }
            tbInfo.Visible = true;
            if (report.FilePercentage > 0)
                {
                pbFileProgress.Visible = true;
                pbFileProgress.Value = report.FilePercentage;
                }
            else
                {
                pbFileProgress.Visible = false;
                }
            pbShow.Value = progress;
            }
        /// <summary>
        /// All done.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tidyFiles_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
            {
            pbShow.Visible = false;
            pbFileProgress.Visible = false;
            butStop.Enabled = false;
            tbInfo.Text = "Completed";
            Text = "Move operation completed";
            TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.NoProgress);
            OnMoveCompleted(new EventArgs());
            if (closeOnDone)
                {
                Close();
                }
            }
        #endregion

        #endregion
        #endregion

        #region Public Methods
        /// <summary>
        /// Starts to cancel any existing operation.
        /// </summary>
        public void Cancel()
            {
            if (IsProcessing)
                {
                cancel = true;
                }
            }
        /// <summary>
        /// Do the move without displaying the form
        /// </summary>
        public void SteathMove()
            {
            DoBackgroundMove();
            }
        #endregion

        #region Public Static Methods
        #region Do Copy
                /// <summary>
        /// Create a list of files and move them in the background.
        /// </summary>
        /// <param name="sourceFolder">
        /// Source folder for files
        /// </param>
        /// <param name="destinationFolder">
        /// Destination folder for files
        /// </param>
        /// <param name="wantedExtensions">
        /// List of wanted extensions.
        /// If not provided, all files are wanted.
        /// </param>
        /// <param name="unwantedExtensions">
        /// List of unwanted extensions
        /// If not provided, no files are excluded.
        /// </param>
        /// <param name="moveDelegate">
        /// If supplied, is called to do the move. If not, File.Move will be used.
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool MoveIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="updateDelegate">
        /// If supplied, is called to update any database
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool UpdateIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="moveFileAction">Text to show in progress window instead of the default.</param>
        /// <param name="updateDBAction">Text to show in progress window instead of the default.</param>
        /// <param name="skippingAction">Text to show in progress window instead of the default.</param>
        /// <param name="closeOnDone">If true, the form will close when run completed</param>
        public static frmMoveFilesInBackground DoCopy(string sourceFolder,
                                  string destinationFolder,
                                  IEnumerable<string> wantedExtensions = null,
                                  IEnumerable<string> unwantedExtensions = null,
                                  FileMove.MoveFile moveDelegate = null,
                                  FileMove.UpdateDB updateDelegate = null,
                                  string moveFileAction = null,
                                  string updateDBAction = null,
                                  string skippingAction = null,
                                  bool closeOnDone = false)
            {
            if (unwantedExtensions == null) unwantedExtensions = new List<string>();
            List<FileMove> files = new List<FileMove>();
            Cursor.Current = Cursors.WaitCursor;
            string[] rawData = Directory.GetFiles(sourceFolder, "*.*", SearchOption.AllDirectories);

            files.AddRange(rawData.Where(r => (wantedExtensions == null ? true : wantedExtensions.Contains(Path.GetExtension(r))) &&
                                             !unwantedExtensions.Contains(Path.GetExtension(r)))
                                  .Select(w => new FileMove(Path.GetFileNameWithoutExtension(w), w, w.Replace(sourceFolder, destinationFolder))));
            Cursor.Current = Cursors.Default;
            return DoCopy(files, moveDelegate, updateDelegate, moveFileAction, updateDBAction, skippingAction, closeOnDone);
            }
        /// <summary>
        /// Create a list of files and move them in the background.
        /// </summary>
        /// <param name="files">
        /// List of files to move
        /// </param>
        /// <param name="moveDelegate">
        /// If supplied, is called to do the move. If not, File.Move will be used.
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool MoveIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="updateDelegate">
        /// If supplied, is called to update any database
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool UpdateIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="moveFileAction">Text to show in progress window instead of the default.</param>
        /// <param name="updateDBAction">Text to show in progress window instead of the default.</param>
        /// <param name="skippingAction">Text to show in progress window instead of the default.</param>
        /// <param name="closeOnDone">If true, the form will close when run completed</param>
        public static frmMoveFilesInBackground DoCopy(IEnumerable<FileMove> files,
                                  FileMove.MoveFile moveDelegate = null,
                                  FileMove.UpdateDB updateDelegate = null,
                                  string moveFileAction = null,
                                  string updateDBAction = null,
                                  string skippingAction = null,
                                  bool closeOnDone = false)
            {
            frmMoveFilesInBackground move = new frmMoveFilesInBackground(files, moveDelegate, updateDelegate, moveFileAction, updateDBAction, skippingAction, closeOnDone);
            move.doCopyOnly = true;
            move.Show();
            Cursor.Current = Cursors.Default;
            return move;
            }
        #endregion

        #region Do Move
        /// <summary>
        /// Create a list of files and move them in the background.
        /// </summary>
        /// <param name="sourceFolder">
        /// Source folder for files
        /// </param>
        /// <param name="destinationFolder">
        /// Destination folder for files
        /// </param>
        /// <param name="wantedExtensions">
        /// List of wanted extensions.
        /// If not provided, all files are wanted.
        /// </param>
        /// <param name="unwantedExtensions">
        /// List of unwanted extensions
        /// If not provided, no files are excluded.
        /// </param>
        /// <param name="moveDelegate">
        /// If supplied, is called to do the move. If not, File.Move will be used.
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool MoveIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="updateDelegate">
        /// If supplied, is called to update any database
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool UpdateIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="moveFileAction">Text to show in progress window instead of the default.</param>
        /// <param name="updateDBAction">Text to show in progress window instead of the default.</param>
        /// <param name="skippingAction">Text to show in progress window instead of the default.</param>
        /// <param name="closeOnDone">If true, the form will close when run completed</param>
        public static frmMoveFilesInBackground DoMove(string sourceFolder,
                                  string destinationFolder,
                                  IEnumerable<string> wantedExtensions = null,
                                  IEnumerable<string> unwantedExtensions = null,
                                  FileMove.MoveFile moveDelegate = null,
                                  FileMove.UpdateDB updateDelegate = null,
                                  string moveFileAction = null,
                                  string updateDBAction = null,
                                  string skippingAction = null,
                                  bool closeOnDone = false)
            {
            if (unwantedExtensions == null) unwantedExtensions = new List<string>();
            List<FileMove> files = new List<FileMove>();
            Cursor.Current = Cursors.WaitCursor;
            string[] rawData = Directory.GetFiles(sourceFolder, "*.*", SearchOption.AllDirectories);

            files.AddRange(rawData.Where(r => (wantedExtensions == null ? true : wantedExtensions.Contains(Path.GetExtension(r))) &&
                                             !unwantedExtensions.Contains(Path.GetExtension(r)))
                                  .Select(w => new FileMove(Path.GetFileNameWithoutExtension(w), w, w.Replace(sourceFolder, destinationFolder))));
            Cursor.Current = Cursors.Default;
            return DoMove(files, moveDelegate, updateDelegate, moveFileAction, updateDBAction, skippingAction, closeOnDone);
            }
        /// <summary>
        /// Create a list of files and move them in the background.
        /// </summary>
        /// <param name="files">
        /// List of files to move
        /// </param>
        /// <param name="moveDelegate">
        /// If supplied, is called to do the move. If not, File.Move will be used.
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool MoveIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="updateDelegate">
        /// If supplied, is called to update any database
        /// Note that this delegate will be called on the background thread, so any
        /// control access in your method will need invoking:
        ///         private bool UpdateIt(FileMove file)
        ///             {
        ///             if (InvokeRequired)
        ///                 {
        ///                 Invoke(new MethodInvoker(() => { MoveIt(file); }));
        ///                 // Do long operations here!
        ///                 Thread.Sleep(1000);
        ///                 return true;
        ///                 }
        ///             else
        ///                 {
        ///                 // Do control updates here!
        ///                 dgvResults.Rows.Add("Move: " + file);
        ///                 return true;
        ///                 }
        ///             }
        /// </param>
        /// <param name="moveFileAction">Text to show in progress window instead of the default.</param>
        /// <param name="updateDBAction">Text to show in progress window instead of the default.</param>
        /// <param name="skippingAction">Text to show in progress window instead of the default.</param>
        /// <param name="closeOnDone">If true, the form will close when run completed</param>
        public static frmMoveFilesInBackground DoMove(IEnumerable<FileMove> files,
                                  FileMove.MoveFile moveDelegate = null,
                                  FileMove.UpdateDB updateDelegate = null,
                                  string moveFileAction = null,
                                  string updateDBAction = null,
                                  string skippingAction = null,
                                  bool closeOnDone = false)
            {
            frmMoveFilesInBackground move = new frmMoveFilesInBackground(files, moveDelegate, updateDelegate, moveFileAction, updateDBAction, skippingAction, closeOnDone);
            move.Show();
            Cursor.Current = Cursors.Default;
            return move;
            }
        
        #endregion        

        /// <summary>
        /// Returns the revision history for this module.
        /// </summary>
        /// <returns></returns>
        public static string GetRevisionHistory()
            {
            Assembly assembly = Assembly.GetExecutingAssembly();
            Stream stream = assembly.GetManifestResourceStream("BackgroundFileMove.Resources.Documents.RevisionHistory.txt");
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
            }
        /// <summary>
        /// Returns true if the drive is available.
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static bool IsDriveAvailable(string path)
            {
            DriveInfo[] drives = DriveInfo.GetDrives();
            DriveInfo drive = drives.FirstOrDefault(d => path.StartsWith(d.Name));
            return drive != null && drive.IsReady;
            }
        #endregion

        #region Overrides
        #endregion

        #region Private Methods
        /// <summary>
        /// Do the actual operation start
        /// </summary>
        private void DoBackgroundMove()
            {
            if (!cancel)
                {
                TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.Normal);
                BackgroundWorker tidyFiles = new BackgroundWorker();
                tidyFiles.WorkerReportsProgress = true;
                tidyFiles.DoWork += new DoWorkEventHandler(tidyFiles_DoWork);
                tidyFiles.ProgressChanged += new ProgressChangedEventHandler(tidyFiles_ProgressChanged);
                tidyFiles.RunWorkerCompleted += new RunWorkerCompletedEventHandler(tidyFiles_RunWorkerCompleted);
                tidyFiles.RunWorkerAsync();
                butStop.Enabled = true;
                }
            }
        /// <summary>
        /// Do the actual file move.
        /// </summary>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        /// <param name="worker"></param>
        /// <param name="prMain"></param>
        private void MoveFile(string src, string dst, BackgroundWorker worker = null, ProgressReport prMain = null)
            {
            if (src != dst)
                {
                // Copy the file itself.
                int iSrc = src.IndexOf(':');
                int iDst = dst.IndexOf(':');
                FileInfo fiSrc = new FileInfo(src);
                if (fiSrc.Length < blockSize || (iSrc > 0 && iDst > 0 && iSrc == iDst && src.Substring(0, iSrc) == dst.Substring(0, iDst)))
                    {
                    // On same drive or trivial size - move it via the file system
                    if (doCopyOnly)
                        {
                        File.Copy(src, dst);
                        }
                    else
                        {
                        File.Move(src, dst);
                        }
                    }
                else
                    {
                    // Needs to be moved "properly".
                    using (Stream sr = new FileStream(src, FileMode.Open))
                        {
                        using (Stream sw = new FileStream(dst, FileMode.Create))
                            {
                            long total = sr.Length;
                            long bytes = 0;
                            long cnt = total;
                            int progress = 0;
                            while (cnt > 0)
                                {
                                int n = sr.Read(transfer, 0, blockSize);
                                sw.Write(transfer, 0, n);
                                bytes += n;
                                cnt -= n;
                                int percent = (int)((bytes * 100) / total);
                                if (progress != percent)
                                    {
                                    // Report progress
                                    progress = percent;
                                    if (worker != null && prMain != null)
                                        {
                                        ProgressReport pr = new ProgressReport
                                        {
                                            FilesCount = prMain.FilesCount,
                                            FileNumber = prMain.FileNumber,
                                            Filename = prMain.Filename,
                                            Action = prMain.Action,
                                            FilePercentage = percent
                                        };
                                        worker.ReportProgress(-prMain.FileNumber, pr);
                                        }
                                    }
                                }
                            }
                        }
                    // Update the fileinfo.
                    FileInfo fiDst = new FileInfo(dst);
                    fiDst.Attributes = fiSrc.Attributes;
                    fiDst.CreationTime = fiSrc.CreationTime;
                    fiDst.CreationTimeUtc = fiSrc.CreationTimeUtc;
                    fiDst.IsReadOnly = fiSrc.IsReadOnly;
                    fiDst.LastAccessTime = fiSrc.LastAccessTime;
                    fiDst.LastAccessTimeUtc = fiSrc.LastAccessTimeUtc;
                    fiDst.LastWriteTime = fiSrc.LastWriteTime;
                    fiDst.LastWriteTimeUtc = fiSrc.LastWriteTimeUtc;
                    // And remove the source
                    if (!doCopyOnly)
                        {
                        File.Delete(src);
                        }
                    }
                }
            }
        #endregion
        }
    }

       private void barButtonItem5_ItemClick(object sender, ItemClickEventArgs e)
    {
        if (!backgroundWorker1.IsBusy)
        {
            backgroundWorker1.RunWorkerAsync();
        }
    }
    private void CreateSheet(string _sheetName)
    {
        IWorkbook workbook = spreadsheetControl.Document;

        if (workbook.Worksheets.Contains(_sheetName) == false)
        {
            workbook.Worksheets.Add().Name = _sheetName;
        }
            //or
            //workbook.Worksheets.Add("Summarize")
    }
    private void ClearSheet(string _sheetName)
    {
        IWorkbook workbook = spreadsheetControl.Document;
        var keys = new List<string>();
        var values = new List<int>();

        Worksheet ws_summarized = workbook.Worksheets[_sheetName];
        ws_summarized.Clear(workbook.Worksheets[_sheetName].GetUsedRange());
        keys.Clear();
        values.Clear();
    }
    private void FillCell(string _sheetName)
    {
        IWorkbook workbook = spreadsheetControl.Document;
        Worksheet worksheet = workbook.Worksheets["DataSet1"];
        CellRange range = worksheet.GetDataRange();
        int LastRow = range.BottomRowIndex;
        var keys = new List<string>();
        var values = new List<int>();

        for (int i = 0; i < LastRow + 1; i++)
        {
            if (worksheet.Cells[i, 10].DisplayText == "خاتمه یافته")
            {
                keys.Add(string.Join(",", worksheet.Cells[i, 28].DisplayText, worksheet.Cells[i, 0].DisplayText, worksheet.Cells[i, 9].DisplayText,
                worksheet.Cells[i, 15].DisplayText, worksheet.Cells[i, 31].DisplayText));
                values.Add((int)worksheet.Cells[i, 32].Value.NumericValue);
            }
        }
        var mydic = new Dictionary<string, int>();
        for (int i = 0; i < keys.Count; i++)
        {
            if (mydic.ContainsKey(keys[i]))
            {
                mydic[keys[i]] += values[i];
            }
            else
            {
                mydic.Add(keys[i], values[i]);
            }
        }
        foreach (var item in mydic.Keys)
        {
            keys.Add(item);
        }
        foreach (var item in mydic.Values)
        {
            values.Add(item);
        }

        for (int i = 0; i < mydic.Count; i++)
        {
            string text = keys[i];
            string[] rewrite = text.Split(',');

            workbook.Worksheets[_sheetName].Cells[i, 0].SetValue(rewrite[0]);
            workbook.Worksheets[_sheetName].Cells[i, 1].SetValue(rewrite[1]);
            workbook.Worksheets[_sheetName].Cells[i, 2].SetValue(rewrite[2]);
            workbook.Worksheets[_sheetName].Cells[i, 3].SetValue(rewrite[3]);
            workbook.Worksheets[_sheetName].Cells[i, 4].SetValue(rewrite[4]);
        }
        for (int i = 0; i < mydic.Count; i++)
        {
            int text = values[i];

            workbook.Worksheets[_sheetName].Cells[i, 5].SetValue(text);
        }
    }

    private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    {

        IWorkbook workbook = spreadsheetControl.Document;
        Worksheet worksheet = workbook.Worksheets["DataSet1"];

        if (worksheet.HasData)
        {
            if (spreadsheetBarController1.Control.InvokeRequired)
            {
                //***Instead of (Action), we can use (MethodInvoker)***
                spreadsheetBarController1.Control.Invoke((Action)delegate { CreateSheet("Summarized"); });
                spreadsheetBarController1.Control.Invoke((MethodInvoker)delegate { ClearSheet("Summarized"); });
                spreadsheetBarController1.Control.Invoke((Action)delegate { FillCell("Summarized"); });
            }
        }
        else
        {
            MessageBox.Show("خطای داده ورودی", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    private void backgroundWorker1_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    {
        progressPanel1.Visible = false;
    }

    private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progressPanel1.Visible = true;
    }
}

private void barButtonItem5_ItemClick(object sender, ItemClickEventArgs e)
       {
           if (!backgroundWorker1.IsBusy)
           {
               backgroundWorker1.RunWorkerAsync();
           }
       }
       private void CreateSheet(string _sheetName)
       {
           IWorkbook workbook = spreadsheetControl.Document;

           if (workbook.Worksheets.Contains(_sheetName) == false)
           {
               workbook.Worksheets.Add().Name = _sheetName;
           }
               //or
               //workbook.Worksheets.Add("Summarize")
       }
       private void ClearSheet(string _sheetName)
       {
           IWorkbook workbook = spreadsheetControl.Document;
           var keys = new List<string>();
           var values = new List<int>();

           Worksheet ws_summarized = workbook.Worksheets[_sheetName];
           ws_summarized.Clear(workbook.Worksheets[_sheetName].GetUsedRange());
           keys.Clear();
           values.Clear();
       }
       DataTable my_table = new DataTable();
       DataTable my_table2 = new DataTable();
       private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
       {
           IWorkbook workbook = spreadsheetControl.Document;
           Worksheet worksheet = workbook.Worksheets["DataSet1"];
           CellRange range = worksheet.GetDataRange();
           int LastRow = range.BottomRowIndex;
           var keys = new List<string>();
           var values = new List<int>();

           for (int i = 0; i < LastRow + 1; i++)
           {
               if (worksheet.Cells[i, 10].DisplayText == "خاتمه یافته")
               {
                   keys.Add(string.Join(",", worksheet.Cells[i, 28].DisplayText, worksheet.Cells[i, 0].DisplayText, worksheet.Cells[i, 9].DisplayText,
                   worksheet.Cells[i, 15].DisplayText, worksheet.Cells[i, 31].DisplayText));
                   values.Add((int)worksheet.Cells[i, 32].Value.NumericValue);
               }
           }
           if (worksheet.HasData)
           {
               if (spreadsheetBarController1.Control.InvokeRequired)
               {
                   //***Instead of (Action), we can use (MethodInvoker)***
                   spreadsheetBarController1.Control.Invoke((Action)delegate { CreateSheet("Summarized"); });
                   spreadsheetBarController1.Control.Invoke((MethodInvoker)delegate { ClearSheet("Summarized"); });
               }

               var mydic = new Dictionary<string, int>();
               for (int i = 0; i < keys.Count; i++)
               {
                   if (mydic.ContainsKey(keys[i]))
                   {
                       mydic[keys[i]] += values[i];
                   }
                   else
                   {
                       mydic.Add(keys[i], values[i]);
                   }
               }
               keys.Clear();
               values.Clear();
               foreach (var item in mydic.Keys)
               {
                   keys.Add(item);
               }
               foreach (var item in mydic.Values)
               {
                   values.Add(item);
               }

               my_table.Columns.Add("A");
               my_table.Columns.Add("B");
               my_table.Columns.Add("C");
               my_table.Columns.Add("D");
               my_table.Columns.Add("E");

               for (int i = 0; i < mydic.Count; i++)
               {
                   string text = keys[i];
                   string[] rewrite = text.Split(',');

                   my_table.Rows.Add(rewrite[0], rewrite[1], rewrite[2], rewrite[3], rewrite[4]);
               }

               my_table2.Columns.Add("F");
               for (int i = 0; i < mydic.Count; i++)
               {
                   int text = values[i];

                   my_table2.Rows.Add(text);
               }
               backgroundWorker1.ReportProgress(100);
           }
           else
           {
               MessageBox.Show("خطای داده ورودی", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
           }
       }

       private void backgroundWorker1_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
       {
           progressPanel1.Visible = false;
       }

       private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
       {
           IWorkbook workbook = spreadsheetControl.Document;
           Worksheet worksheet = workbook.Worksheets["DataSet1"];
           CellRange range = worksheet.GetDataRange();
           int LastRow = range.BottomRowIndex;

           for (int i = 0; i < my_table.Rows.Count; i++)
           {
               workbook.Worksheets["Summarized"].Cells[i, 0].SetValue(my_table.Rows[i]["A"].ToString());
               workbook.Worksheets["Summarized"].Cells[i, 1].SetValue(my_table.Rows[i]["B"].ToString());
               workbook.Worksheets["Summarized"].Cells[i, 2].SetValue(my_table.Rows[i]["C"].ToString());
               workbook.Worksheets["Summarized"].Cells[i, 3].SetValue(my_table.Rows[i]["D"].ToString());
               workbook.Worksheets["Summarized"].Cells[i, 4].SetValue(my_table.Rows[i]["E"].ToString());
           }
       }

if (!backgroundWorker1.IsBusy)
            {
                backgroundWorker1.RunWorkerAsync();
            }

workbook.Worksheets.Add().Name = "Summarized";