本地文件同步——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>

---

效果：

希望本篇文章对你有所用处。