本地文件同步——C#源代碼

入職之后接到的第一個代碼任務是一個小測試。做一個文件單向同步軟件。

---

需求描述：

將文件夾A內的文件夾和文件同步到文件夾B。

其實需求也就那么一句話，沒啥還需要解釋的了吧。詳細點說，需要同步文件/文件夾的“新增，刪除，重命名，修改”。

一開始我的想法是先Google，然后在博客園找到這篇文章《C#文件同步工具教程》。這篇文章的核心來自msdn里面FileSystemWatcher 的解釋。就是用對象FileSystemWatcher 去監聽文件是否被創建，重命名，刪除，修改。如果發生了就調用相對應的事件，將被修改，創建，重命名的文件復制到目標目錄B當中。這個例子比較簡單，很多事情都沒考慮到。而且我認為用FileSystemWatcher 去監聽所有的文件，太浪費CPU和內存。

 

---

我的想法

是采用遞歸，遍歷整個源目錄，對比目標目錄。

1. 1. 如果目標目錄下沒有相對應的文件，將文件復制到目標目錄；
   2. 如果文件在兩個路徑下都存在，但是文件大小和最后寫入時間不一致時，將原目錄下的文件復制到目標目錄下；
   3. 如果文件存在於目標目錄下而不存在源目錄下，則將目標路徑下的文件刪除。

---

實現 

知道如何比較之后就可以進行遞歸遍歷文件夾了。這個是這個軟件實現的難點之一，其實也沒多難，也就是說這個軟件根本就沒多難。以下是遞歸函數：

/// <summary>
/// 遞歸核心 同步目錄 
/// </summary>
/// <param name="src">原路徑</param>
/// <param name="obj">目標路徑</param>
static void loop(string src, string obj)    // 遞歸核心 同步目錄 
{
    CopyFistly(src, obj);   //先同步文件

    //遍歷文件夾，遞歸調用
    DirectoryInfo dirSrc = new DirectoryInfo(src);
    DirectoryInfo[] dirs = dirSrc.GetDirectories();
    foreach (DirectoryInfo dir in dirs)
    {
        string str = dir.Name;
        if (Directory.Exists(obj + "\\" + dir.Name) == false)
        {
            str = Directory.CreateDirectory(obj + "\\" + dir.Name).ToString();
        }
        //注意這里，這里是遞歸，而且是下面要注意的地方
        loop(src + "\\" + dir.ToString(), obj + "\\" + str);    
    }
}

 

測試了一下結果，在9000+個文件，40+個文件夾下，在我這部破機器上面單純遞歸遍歷（不復制文件）的時候需要的時間是截枝的十倍以上。簡直是只烏龜。。。

---

優化

所以要想辦法縮短時間提高效率。既然復制文件上面我們無法操作，那我們只好在遞歸上面進行優化。上個星期我發了一篇文章叫做《算法——回溯法》。這個時候剛好可以用上這種方法了。因為本身用的就是遞歸，而且文件夾的結構本身就是一個樹的結構，在恰好滿足了回溯法的要求。在遍歷上面，並不需要在所有的文件夾都遍歷一遍。因為有些文件夾並沒有發生改變，所有就沒有必要遍歷下去了。所以就需要在遞歸調用自己之前先加一個條件，也就是加上約束函數。修改之后，代碼如下：

/// <summary>
/// 遞歸核心 同步目錄 
/// </summary>
/// <param name="src">原路徑</param>
/// <param name="obj">目標路徑</param>
static void loop(string src, string obj)    // 遞歸核心 同步目錄 
{
    CopyFistly(src, obj);   //先同步文件

    //遍歷文件夾，遞歸調用
    DirectoryInfo dirSrc = new DirectoryInfo(src);
    DirectoryInfo[] dirs = dirSrc.GetDirectories();
    foreach (DirectoryInfo dir in dirs)
    {
        string str = dir.Name;
        if (Directory.Exists(obj + "\\" + dir.Name) == false)
        {
            str = Directory.CreateDirectory(obj + "\\" + dir.Name).ToString();
        }
        DirectoryInfo dirObj = new DirectoryInfo(str);
        //約束函數 在大小不一致的時候進行同步，其他狀態不同步
        if (GetDirectoryLength(src + "\\" + dir.ToString()) != GetDirectoryLength(obj + "\\" + str))    
            loop(src + "\\" + dir.ToString(), obj + "\\" + str);
    }
}

函數GetDirectoryLength(string path)的作用是檢查文件夾path的大小。這里只是簡單地對比兩個文件夾的大小，如果大小一致，則截枝不遞歸，否則遞歸。這種方式的效率非常高，因為很多時候並不是都在有文件的復制，所以不需要經常去遍歷目錄。所以截枝就好了。下面給出GetDirectoryLength(string path)函數的代碼。其實該函數也是一個遞歸，雖然會增加負荷，但是文件多，文件夾深的時候，是很有必要的。

/// <summary>
/// 獲取路徑下文件夾的大小
/// </summary>
/// <param name="dirPath">目標路徑</param>
/// <returns>文件夾大小</returns>
public static long GetDirectoryLength(string dirPath)
{
    //判斷給定的路徑是否存在,如果不存在則退出
    if (!Directory.Exists(dirPath))
        return 0;
    long len = 0;

    //定義一個DirectoryInfo對象
    DirectoryInfo di = new DirectoryInfo(dirPath);

    //通過GetFiles方法,獲取di目錄中的所有文件的大小
    foreach (FileInfo fi in di.GetFiles())
    {
        len += fi.Length;
    }

    //獲取di中所有的文件夾,並存到一個新的對象數組中,以進行遞歸
    DirectoryInfo[] dis = di.GetDirectories();
    if (dis.Length > 0)
    {
        for (int i = 0; i < dis.Length; i++)
        {
            len += GetDirectoryLength(dis[i].FullName);
        }
    }
    return len;
}

 

 

難點主要在遞歸和截枝的思想上面。其他方面的解釋可以直接查看代碼。注釋已經很清楚了。下面是整個文件的源代碼：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading;
using System.Configuration;

namespace FileSynLoop
{
    class Program
    {
        static private string strSource = GetAppConfig("src");   //原路徑
        static private string strObjective = GetAppConfig("obj");    //目標路徑
        static private int synTime = 0;  //同步時間
        static private string flag = ""; //多線程控制標志 同步控制
        static private Thread threadShow;   //顯示效果線程
        static private bool bound;  //是否使用截枝函數

        static void Main(string[] args)
        {
            //基本設置
            Console.WriteLine("原路徑:" + strSource);
            Console.WriteLine("目標路徑:" + strObjective);
            try { synTime = Convert.ToInt32(GetAppConfig("synTime")); }
            catch (Exception e) { Console.WriteLine("配置的同步時間格式不正確：" + e.Message); return; }
            Console.WriteLine("同步間隔時間:" + synTime + "毫秒");

            if (Directory.Exists(strSource) == false){Console.WriteLine("配置的原路徑不存在");return;}
            if (Directory.Exists(strObjective) == false){Console.WriteLine("配置的目標路徑不存在"); return;}

            Console.WriteLine("是否使用截枝函數？使用截止函數無法同步空文件夾/空文件。默認使用截枝！y/n");
            if (Console.ReadLine() == "n")
                bound = false;
            else
                bound = true;

            do{Console.WriteLine("輸入ok開始!");}
            while (Console.ReadLine() != "ok");

            //線程
            Thread thread = new Thread(new ThreadStart(ThreadProc));
            threadShow = new Thread(new ThreadStart(ThreadShow));
            thread.Start();
            threadShow.Start(); //開始線程
            threadShow.Suspend();   //掛起線程
            //退出
            while ((flag = Console.ReadLine()) != "exit") ;
        }

        //線程控制
        public static void ThreadProc()
        {
            int i = 0;
            DateTime dt;
            TimeSpan ts;

            while (flag != "exit")
            {
                dt = DateTime.Now;
                Console.WriteLine();
                Console.Write("第" + ++i + "次同步開始：");
                threadShow.Resume();    //恢復線程
                try
                {
                    loop(strSource, strObjective);
                }
                catch (Exception e)
                {
                    Console.WriteLine("文件夾“" + strSource + "“被占用，暫時無法同步！8:" + e.Message);
                }
                threadShow.Suspend();   //掛起線程

                ts = DateTime.Now - dt;
                Console.WriteLine("|");
                if (GetDirectoryLength(strSource) == GetDirectoryLength(strObjective))
                    Console.WriteLine("所有同步完畢！");
                Console.WriteLine("第" + i + "次同步結束,耗時"+ts.ToString()+",正在等待下次開始！");
                Thread.Sleep(synTime);//同步時間
            }
        }

        //顯示效果的線程
        public static void ThreadShow()
        {
            while (flag != "exit")
            {
                Console.Write(">");
                Thread.Sleep(500);
            }
        }

        /// <summary>
        /// 遞歸核心 同步目錄 
        /// </summary>
        /// <param name="src">原路徑</param>
        /// <param name="obj">目標路徑</param>
        static void loop(string src, string obj)    // 遞歸核心 同步目錄 
        {
            CopyFistly(src, obj);   //先同步文件

            //遍歷文件夾，遞歸調用
            DirectoryInfo dirSrc = new DirectoryInfo(src);
            DirectoryInfo[] dirs = dirSrc.GetDirectories();
            foreach (DirectoryInfo dir in dirs)
            {
                string str = dir.Name;
                if (Directory.Exists(obj + "\\" + dir.Name) == false)
                {
                    str = Directory.CreateDirectory(obj + "\\" + dir.Name).ToString();
                }
                DirectoryInfo dirObj = new DirectoryInfo(str);
                if (bound)
                {
                    //約束函數 在大小不一致的時候進行同步，其他狀態不同步
                    if (GetDirectoryLength(src + "\\" + dir.ToString()) != GetDirectoryLength(obj + "\\" + str))    
                        loop(src + "\\" + dir.ToString(), obj + "\\" + str);
                }
                else
                {
                    loop(src + "\\" + dir.ToString(), obj + "\\" + str);
                }
            }
        }

        /// <summary>
        /// 同步文件
        /// </summary>
        /// <param name="strSource">源目錄</param>
        /// <param name="strObjective">目標目錄</param>
        static private void CopyFistly(string strSource, string strObjective)   //同步文件
        {
            string[] srcFileNames = Directory.GetFiles(strSource).Select(s => System.IO.Path.GetFileName(s)).ToArray(); //原路徑下的所有文件
            string[] objFileNames = Directory.GetFiles(strObjective).Select(s => System.IO.Path.GetFileName(s)).ToArray();  //目標路徑下的所有文件

            #region 同步新建 修改
            foreach (string strSrc in srcFileNames) //遍歷源文件夾
            {
                FileInfo aFile = new FileInfo(strSource + "\\" + strSrc);
                string aAccessTime = aFile.LastWriteTime.ToString();
                string aCreateTime = aFile.CreationTime.ToString();


                string bCreateTime = "";    //目標路徑文件的信息
                string bAccessTime = "";

                bool flag = false;
                foreach (string strObj in objFileNames) //遍歷目標文件夾
                {
                    FileInfo bFile = new FileInfo(strObjective + "\\" + strObj);
                    bAccessTime = bFile.LastWriteTime.ToString();
                    bCreateTime = bFile.CreationTime.ToString();

                    if (strSrc == strObj)   //文件存在目標路徑當中
                    {
                        if (aCreateTime != bCreateTime || aAccessTime != bAccessTime)   //文件存在但是不一致
                        {
                            try
                            {
                                File.Copy(strSource + "\\" + strSrc, strObjective + "\\" + strSrc, true);
                                FileInfo file = new FileInfo(strObjective + "\\" + strSrc);
                                file.CreationTime = Convert.ToDateTime(aCreateTime);
                                file.LastAccessTime = Convert.ToDateTime(aAccessTime);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine("文件“" + strSrc + "“被占用，暫時無法同步！4:" + e.Message);
                            }
                        }
                        flag = true;
                        break;
                    }
                }

                if (flag == false)  //文件不存在目標路徑當中
                {
                    try
                    {
                        File.Copy(strSource + "\\" + strSrc, strObjective + "\\" + strSrc, true);
                        FileInfo file = new FileInfo(strObjective + "\\" + strSrc);
                        file.CreationTime = Convert.ToDateTime(aCreateTime);
                        file.LastAccessTime = Convert.ToDateTime(aAccessTime);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("文件“" + strSrc + "“被占用，暫時無法同步！5" + e.Message);
                    }
                }
            }
            #endregion

            #region 同步刪除 重命名
            //刪除文件
            foreach (string strObj in objFileNames) //遍歷目標文件夾
            {
                string allObj = strObjective + "\\" + strObj;
                bool flag = false;
                foreach (string strSrc in srcFileNames) //遍歷源文件夾
                {
                    if (strObj == strSrc)
                        flag = true;
                }
                if (flag == false)
                {
                    try
                    {
                        File.Delete(allObj);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("文件“" + strObj + "“被占用，暫時無法同步！6" + e.Message);
                    }
                }
            }

            //刪除文件夾
            DirectoryInfo dirSrc = new DirectoryInfo(strSource);
            DirectoryInfo[] dirsSrc = dirSrc.GetDirectories();
            DirectoryInfo dirObj = new DirectoryInfo(strObjective);
            DirectoryInfo[] dirsObj = dirObj.GetDirectories();
            foreach (DirectoryInfo bdirObj in dirsObj)
            {
                bool flag = false;
                foreach (DirectoryInfo adirSrc in dirsSrc)
                {
                    if (bdirObj.Name == adirSrc.Name)
                    {
                        flag = true;
                    }
                }
                if (flag == false)  //如果文件夾只出現在目的路徑下而不再源目錄下，刪除該文件夾
                {
                    try
                    {
                        Directory.Delete(dirObj + "\\" + bdirObj, true);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("文件夾“" + bdirObj + "“被占用，暫時無法同步！8" + e.Message);
                    }
                }
            }
            #endregion

        }

        /// <summary>
        /// 獲取自定義配置的值
        /// </summary>
        /// <param name="strKey">鍵值</param>
        /// <returns>鍵值對應的值</returns>
        private static string GetAppConfig(string strKey)
        {
            foreach (string key in ConfigurationManager.AppSettings)
            {
                if (key == strKey)
                {
                    return ConfigurationManager.AppSettings[strKey];
                }
            }
            return null;
        }

        /// <summary>
        /// 獲取路徑下文件夾的大小
        /// </summary>
        /// <param name="dirPath">目標路徑</param>
        /// <returns>文件夾大小</returns>
        public static long GetDirectoryLength(string dirPath)
        {
            //判斷給定的路徑是否存在,如果不存在則退出
            if (!Directory.Exists(dirPath))
                return 0;
            long len = 0;

            //定義一個DirectoryInfo對象
            DirectoryInfo di = new DirectoryInfo(dirPath);

            //通過GetFiles方法,獲取di目錄中的所有文件的大小
            foreach (FileInfo fi in di.GetFiles())
            {
                len += fi.Length;
            }

            //獲取di中所有的文件夾,並存到一個新的對象數組中,以進行遞歸
            DirectoryInfo[] dis = di.GetDirectories();
            if (dis.Length > 0)
            {
                for (int i = 0; i < dis.Length; i++)
                {
                    len += GetDirectoryLength(dis[i].FullName);
                }
            }
            return len;
        }
    }
}

 

---

配置文件的代碼

因為要求用配置文件，配置原路徑，目的路徑等信息，有必要說明一下這個問題。另外需要讀配置文件，所以需要引用System.Configuration;命名空間。一下是配置文件app.config代碼：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <!--原路徑-->
    <add key="src" value="e:\test\a"/>
    <!--目標路徑-->
    <add key="obj" value="e:\test\b"/>
    <!--日記文件路徑-->
    <add key="logs" value="e:\test\logs.txt"/>
    <!--自動同步時間,單位為毫秒-->
    <add key="synTime" value="5000"/>
  </appSettings>
</configuration>

 

---

效果：

 

希望本篇文章對你有所用處。