• C#实现对文件目录的实时监控


      本文主要描述如何通过C#实现实时监控文件目录下的变化,包括文件和目录的添加,删除,修改和重命名等操作。

      首先,我们需要对.net提供的FileSystemWatcher类有所了解。我有些懒,找了MSDN对该类的描述。

      FileSystemWatcher类侦听文件系统更改通知,并在目录或目录中的文件发生更改时引发事件。

      使用 FileSystemWatcher 监视指定目录中的更改。可监视指定目录中的文件或子目录的更改。可以创建一个组件来监视本地计算机、网络驱动器或远程计算机上的文件。

      若要监视所有文件中的更改,请将 Filter 属性设置为空字符串 ("") 或使用通配符(“*.*”)。若要监视特定的文件,请将 Filter 属性设置为该文件名。例如,若要监视文件 MyDoc.txt 中的更改,请将 Filter 属性设置为“MyDoc.txt”。也可以监视特定类型文件中的更改。例如,若要监视文本文件中的更改,请将 Filter 属性设置为“*.txt”。

      可监视目录或文件中的若干种更改。例如,可监视文件或目录的 AttributesLastWrite 日期和时间或 Size 方面的更改。通过将 NotifyFilter 属性设置为 NotifyFilters 值之一来达到此目的。有关可监视的更改类型的更多信息,请参见 NotifyFilters

      可监视文件或目录的重命名、删除或创建。例如,若要监视文本文件的重命名,请将 Filter 属性设置为“*.txt”,并使用为其参数指定的 Renamed 来调用 WaitForChanged 方法。

      Windows 操作系统在 FileSystemWatcher 创建的缓冲区中通知组件文件发生更改。如果短时间内有很多更改,则缓冲区可能会溢出。这将导致组件失去对目录更改的跟踪,并且它将只提供一般性通知。使用 InternalBufferSize 属性来增加缓冲区大小的开销较大,因为它来自无法换出到磁盘的非页面内存,所以应确保缓冲区大小适中(尽量小,但也要有足够大小以便不会丢失任何文件更改事件)。若要避免缓冲区溢出,请使用 NotifyFilterIncludeSubdirectories 属性,以便可以筛选掉不想要的更改通知。

      使用 FileSystemWatcher 类时,请注意以下事项。

      1) 对包括隐藏文件(夹)在内的所有文件(夹)进行监控。

      2) 您可以为 InternalBufferSize 属性(用于监视网络上的目录)设置的最大大小为 64 KB。

      FileSystemWatcher的实例监控到文件(夹)的变化后,会触发相应的事件,其中文件(夹)的添加,删除和修改会分别触发Created,Deleted,Changed事件,文件(夹)重命名时触发OnRenamed事件。

      

      然后,在熟悉了FileSystemWatcher类后,我们开始自己的程序编写。

      实例化FileSystemWatcher类,并传入需要监控的目录路径,以及是否制定监控的文件类型(文章前面有所介绍)。

    _watcher = new FileSystemWatcher(_path, _filter);

      注册监听事件,以及编写事件触发后相关的处理逻辑。

    _watcher.Created += new FileSystemEventHandler(OnChanged);
                _watcher.Changed += new FileSystemEventHandler(OnChanged);
                _watcher.Deleted += new FileSystemEventHandler(OnChanged);
                _watcher.Renamed += new RenamedEventHandler(OnRenamed);
                _watcher.IncludeSubdirectories = true;
                _watcher.EnableRaisingEvents = true;

      在本程序中,专门定义了一个FileChangeInformation类来记录文件变化信息,并定义了一个CustomQueue类,该类类似于Queue类,是一个数据先进先出的集合,用来存储所有的文件变化消息,并提供数据持久化功能。

      监控类 - FileWatcher,代码如下:

      1  /// <summary>
      2     /// 文件监控类,用于监控指定目录下文件以及文件夹的变化
      3     /// </summary>
      4     public class FileWatcher
      5     {
      6         private FileSystemWatcher _watcher = null;
      7         private string _path = string.Empty;
      8         private string _filter = string.Empty;
      9         private bool _isWatch = false;
     10         private CustomQueue<FileChangeInformation> _queue = null;
     11 
     12         /// <summary>
     13         /// 监控是否正在运行
     14         /// </summary>
     15         public bool IsWatch
     16         {
     17             get
     18             {
     19                 return _isWatch;
     20             }
     21         }
     22 
     23         /// <summary>
     24         /// 文件变更信息队列
     25         /// </summary>
     26         public CustomQueue<FileChangeInformation> FileChangeQueue
     27         {
     28             get
     29             {
     30                 return _queue;
     31             }
     32         }
     33 
     34         /// <summary>
     35         /// 初始化FileWatcher类
     36         /// </summary>
     37         /// <param name="path">监控路径</param>
     38         public FileWatcher(string path)
     39         {
     40             _path = path;
     41             _queue = new CustomQueue<FileChangeInformation>();
     42         }
     43         /// <summary>
     44         /// 初始化FileWatcher类,并指定是否持久化文件变更消息
     45         /// </summary>
     46         /// <param name="path">监控路径</param>
     47         /// <param name="isPersistence">是否持久化变更消息</param>
     48         /// <param name="persistenceFilePath">持久化保存路径</param>
     49         public FileWatcher(string path, bool isPersistence, string persistenceFilePath)
     50         {
     51             _path = path;
     52             _queue = new CustomQueue<FileChangeInformation>(isPersistence, persistenceFilePath);
     53         }
     54 
     55         /// <summary>
     56         /// 初始化FileWatcher类,并指定是否监控指定类型文件
     57         /// </summary>
     58         /// <param name="path">监控路径</param>
     59         /// <param name="filter">指定类型文件,格式如:*.txt,*.doc,*.rar</param>
     60         public FileWatcher(string path, string filter)
     61         {
     62             _path = path;
     63             _filter = filter;
     64             _queue = new CustomQueue<FileChangeInformation>();
     65         }
     66 
     67         /// <summary>
     68         /// 初始化FileWatcher类,并指定是否监控指定类型文件,是否持久化文件变更消息
     69         /// </summary>
     70         /// <param name="path">监控路径</param>
     71         /// <param name="filter">指定类型文件,格式如:*.txt,*.doc,*.rar</param>
     72         /// <param name="isPersistence">是否持久化变更消息</param>
     73         /// <param name="persistenceFilePath">持久化保存路径</param>
     74         public FileWatcher(string path, string filter, bool isPersistence, string persistenceFilePath)
     75         {
     76             _path = path;
     77             _filter = filter;
     78             _queue = new CustomQueue<FileChangeInformation>(isPersistence, persistenceFilePath);
     79         }
     80 
     81         /// <summary>
     82         /// 打开文件监听器
     83         /// </summary>
     84         public void Open()
     85         {
     86             if (!Directory.Exists(_path))
     87             {
     88                 Directory.CreateDirectory(_path);
     89             }
     90 
     91             if (string.IsNullOrEmpty(_filter))
     92             {
     93                 _watcher = new FileSystemWatcher(_path);
     94             }
     95             else
     96             {
     97                 _watcher = new FileSystemWatcher(_path, _filter);
     98             }
     99             //注册监听事件
    100             _watcher.Created += new FileSystemEventHandler(OnProcess);
    101             _watcher.Changed += new FileSystemEventHandler(OnProcess);
    102             _watcher.Deleted += new FileSystemEventHandler(OnProcess);
    103             _watcher.Renamed += new RenamedEventHandler(OnFileRenamed);
    104             _watcher.IncludeSubdirectories = true;
    105             _watcher.EnableRaisingEvents = true;
    106             _isWatch = true;
    107         }
    108 
    109         /// <summary>
    110         /// 关闭监听器
    111         /// </summary>
    112         public void Close()
    113         {
    114             _isWatch = false;
    115             _watcher.Created -= new FileSystemEventHandler(OnProcess);
    116             _watcher.Changed -= new FileSystemEventHandler(OnProcess);
    117             _watcher.Deleted -= new FileSystemEventHandler(OnProcess);
    118             _watcher.Renamed -= new RenamedEventHandler(OnFileRenamed);
    119             _watcher.EnableRaisingEvents = false;
    120             _watcher = null;
    121         }
    122 
    123         /// <summary>
    124         /// 获取一条文件变更消息
    125         /// </summary>
    126         /// <returns></returns>
    127         public FileChangeInformation Get()
    128         {
    129             FileChangeInformation info = null;
    130             if (_queue.Count > 0)
    131             {
    132                 lock (_queue)
    133                 {
    134                     info = _queue.Dequeue();
    135                 }
    136             }
    137             return info;
    138         }
    139 
    140         /// <summary>
    141         /// 监听事件触发的方法
    142         /// </summary>
    143         /// <param name="sender"></param>
    144         /// <param name="e"></param>
    145         private void OnProcess(object sender, FileSystemEventArgs e)
    146         {
    147             try
    148             {
    149                 FileChangeType changeType = FileChangeType.Unknow;
    150                 if (e.ChangeType == WatcherChangeTypes.Created)
    151                 {
    152                     if (File.GetAttributes(e.FullPath) == FileAttributes.Directory)
    153                     {
    154                         changeType = FileChangeType.NewFolder;
    155                     }
    156                     else
    157                     {
    158                         changeType = FileChangeType.NewFile;
    159                     }
    160                 }
    161                 else if (e.ChangeType == WatcherChangeTypes.Changed)
    162                 {
    163                     //部分文件创建时同样触发文件变化事件,此时记录变化操作没有意义
    164                     //如果
    165                     if (_queue.SelectAll(
    166                         delegate(FileChangeInformation fcm)
    167                         {
    168                             return fcm.NewPath == e.FullPath && fcm.ChangeType == FileChangeType.Change;
    169                         }).Count<FileChangeInformation>() > 0)
    170                     {
    171                         return;
    172                     }
    173 
    174                     //文件夹的变化,只针对创建,重命名和删除动作,修改不做任何操作。
    175                     //因为文件夹下任何变化同样会触发文件的修改操作,没有任何意义.
    176                     if (File.GetAttributes(e.FullPath) == FileAttributes.Directory)
    177                     {
    178                         return;
    179                     }
    180 
    181                     changeType = FileChangeType.Change;
    182                 }
    183                 else if (e.ChangeType == WatcherChangeTypes.Deleted)
    184                 {
    185                     changeType = FileChangeType.Delete;
    186                 }
    187 
    188                 //创建消息,并压入队列中
    189                 FileChangeInformation info = new FileChangeInformation(Guid.NewGuid().ToString(), changeType, e.FullPath, e.FullPath, e.Name, e.Name);
    190                 _queue.Enqueue(info);
    191             }
    192             catch
    193             {
    194                 Close();
    195             }
    196         }
    197 
    198         /// <summary>
    199         /// 文件或目录重命名时触发的事件
    200         /// </summary>
    201         /// <param name="sender"></param>
    202         /// <param name="e"></param>
    203         private void OnFileRenamed(object sender, RenamedEventArgs e)
    204         {
    205             try
    206             {
    207                 //创建消息,并压入队列中
    208                 FileChangeInformation info = new FileChangeInformation(Guid.NewGuid().ToString(), FileChangeType.Rename, e.OldFullPath, e.FullPath, e.OldName, e.Name);
    209                 _queue.Enqueue(info);
    210             }
    211             catch
    212             {
    213                 Close();
    214             }
    215         }
    216     }

      最后,功能调用如下:

     1 //初始化监控器
     2                 FileWatcher watcher = new FileWatcher(@"D:");
     3                 watcher.Open();
     4 
     5                 FileChangeInformation fci = null;
     6                 //获取消息
     7                 while (true)
     8                 {
     9                     //如果IsWatch为False,则可能监控内部发生异常终止了监控,需要重新开启监控
    10                     if (watcher.IsWatch)
    11                     {
    12                         //队列顶端的变更消息
    13                         fci = watcher.Get();
    14                         //处理消息的代码
    15                         //Print(fci);
    16                     }
    17                     else
    18                     {
    19                         watcher.Open();
    20                     }
    21                     Thread.Sleep(1000);
    22                 }

      该程序实现了对文件目录下所有子目录和子文件的变化进行监控,并可通过FileChangeQueue属性访问文件变更消息,同时也可以设置其是否需要将数据持久化到磁盘文件中。

      需要源码的M我:GavinLeeChang@126.com

  • 相关阅读:
    在Ubuntu下编译Qt错误及处理办法
    二、数字电路中常见器件应用分析-三极管
    2.NB-IoT及通信协议
    1.编写一个shell脚本
    7.STM32中GPIO理解
    (引用)!Unicode,GBK以及UTF8的联系和区别
    java垃圾回收
    java集合框架概述
    RSA实现(java)
    RSA算法(非对称加密)
  • 原文地址:https://www.cnblogs.com/oyzl5zl/p/3532370.html
Copyright © 2020-2023  润新知