谈谈C#文件监控对象FileSystemWatcher使用感受

最新推荐文章于 2022-05-18 13:54:18 发布
最新推荐文章于 2022-05-18 13:54:18 发布
阅读量295 收藏
点赞数
分类专栏： 數據存儲項目.C#

最近在项目中有这么个需求，就是得去实时获取某个在无规律改变的文本文件中的内容。首先想到的是用程序定期去访问这个文件，因为对实时性要求很高，间隔不能超过1S，而且每次获取到文本内容都要去分发给WEB服务器做别的操作，而那个文本的写入有时候会频繁，1秒可能多次，但是也有可能在相当长一段时间内是没有任何写入的。

这样一来如果每秒都去访问文件的话，一个是IO问题，还有就是每次操作都会引起后端一系列程序的反应，文本在长时间内无写入的话，一秒一次的触发一系列徒劳的事情太不可取了。

最终发现了c#中的FileSystemWatcher对象，在应用FileSystemWatcher之前，首先了解一下这个对象的基本属性和事件，首先普及一下FileSystemWatcher基本知识。

FileSystemWatcher基础

属性：

    Path——这个属性告诉FileSystemWatcher它需要监控哪条路径。例如，如果我们将这个属性设为“C:\test”，对象就监控test目录下所有文件发生的所有改变（包括删除，修改，创建，重命名）。

    IncludeSubDirectories——这个属性说明FileSystemWatcher对象是否应该监控子目录中（所有文件）发生的改变。

    Filter——这个属性允许你过滤掉某些类型的文件发生的变化。例如，如果我们只希望在TXT文件被修改/新建/删除时提交通知，可以将这个属性设为“*txt”。在处理高流量或大型目录时，使用这个属性非常方便。

NotifyFilter——获取或设置要监视的更改类型。可以进一步的过滤要监控的更改类型，如watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite

           | NotifyFilters.FileName | NotifyFilters.DirectoryName;

事件：

    Changed——当被监控的目录中有一个文件被修改时，就提交这个事件。值得注意的是，这个事件可能会被提交多次，即使文件的内容仅仅发生一项改变。这是由于在保存文件时，文件的其它属性也发生了改变。

    Created——当被监控的目录新建一个文件时，就提交这个事件。如果你计划用这个事件移动新建的事件，你必须在事件处理器中写入一些错误处理代码，它能处理当前文件被其它进程使用的情况。之所以要这样做，是因为Created事件可能在建立文件的进程释放文件之前就被提交。如果你没有准备正确处理这种情况的代码，就可能出现异常。

    Deleted——当被监控的目录中有一个文件被删除，就提交这个事件。

    Renamed——当被监控的目录中有一个文件被重命名，就提交这个事件。 

 

注：如果你没有将EnableRaisingEvents设为真，系统不会提交任何一个事件。如果有时FileSystemWatcher对象似乎无法工作，请首先检查EnableRaisingEvents，确保它被设为真。

 

事件处理

 

当FileSystemWatcher调用一个事件处理器时，它包含两个自变量——一个叫做“sender”的对象和一个叫做“e”的 FileSystemEventArgs对象。我们感兴趣的自变量为FileSystemEventArgs自变量。这个对象中包含有提交事件的原因。以下是FileSystemEventArgs对象的一些属性：

 

属性：

 

  Name——这个属性中使事件被提交的文件的名称。其中并不包含文件的路径——只包含使用事件被提交的文件或目录名称。

  ChangeType——这是一个WatcherChangeTypes，它指出要提交哪个类型的事件。其有效值包括：

  Changed

  Created

  Deleted

  Renamed

  FullPath——这个属性中包含使事件被提交的文件的完整路径，包括文件名和目录名。

 

注意：FileSystemEventArgs对象是监控文件夹下有文件创建、删除、修改时的自变量，如果是重命名的话为RenamedEventArgs对象此时除了FileSystemEventArgs对象的属性值，多了一个OldFullPath，为重命名之前的文件名。

 

以上为FileSystemEventArgs的基本知识，大部分是从网上搜找的然后自己稍微整理了一下。

 

下面为简单用法：

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
using System;
using System.IO;
 
namespace test
{
     class Program
     {
         static void Main( string [] args)
         {
 
 
             WatcherStrat( @"C:\test" , "*.txt" );
             //由于是控制台程序，加个输入避免主线程执行完毕，看不到监控效果
             Console.ReadKey();
 
         }
 
       
 
         private static void WatcherStrat( string path, string filter)
         {
             FileSystemWatcher watcher = new FileSystemWatcher();
             watcher.Path = path;
 
             watcher.Filter = filter;
 
             watcher.Changed += new FileSystemEventHandler(OnProcess);
             watcher.Created += new FileSystemEventHandler(OnProcess);
             watcher.Deleted += new FileSystemEventHandler(OnProcess);
             watcher.Renamed += new RenamedEventHandler(OnRenamed);
 
             watcher.EnableRaisingEvents = true ;
         }
 
 
 
 
         private static void OnProcess( object source, FileSystemEventArgs e)
         {
             if (e.ChangeType == WatcherChangeTypes.Created)
             {
                 OnCreated(source, e);
 
             }
             else if (e.ChangeType == WatcherChangeTypes.Changed)
             {
                 OnChanged(source, e);
 
             }
             else if (e.ChangeType == WatcherChangeTypes.Deleted)
             {
                 OnDeleted(source, e);
 
             }
         }
 
         private static void OnCreated( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件新建事件处理逻辑" );
             
         }
 
         private static void OnChanged( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件改变事件处理逻辑" );
         }
 
         private static void OnDeleted( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件删除事件处理逻辑" );
         }
 
         private static void OnRenamed( object source, RenamedEventArgs e)
         {
 
             Console.WriteLine( "文件重命名事件处理逻辑" );
         }
 
     }
}

 

 

 

 

 

 

用上面的方法会发现，在一次文本文件变化的时候OnChanged事件会触发两次，这是因为除了文本内容变化之外还有文件其他的属性也变化了例如修改时间。

     

     为了解决这问题，也便于项目当中实际使用，写了下面几个类来实际使用：

 主方法：
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
using System;
using System.IO;
 
namespace test
{
     class Program
     {
         static void Main( string [] args)
         {
 
 
 
             MyFileSystemWather myWather = new MyFileSystemWather( @"C:\test" , "*.txt" );
             myWather.OnChanged += new FileSystemEventHandler(OnChanged);
             myWather.OnCreated += new FileSystemEventHandler(OnCreated);
             myWather.OnRenamed += new RenamedEventHandler(OnRenamed);
             myWather.OnDeleted += new FileSystemEventHandler(OnDeleted);
             myWather.Start();
             //由于是控制台程序，加个输入避免主线程执行完毕，看不到监控效果
             Console.ReadKey();
 
         }
 
         private static void OnCreated( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件新建事件处理逻辑" );
             
         }
 
         private static void OnChanged( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件改变事件处理逻辑" );
         }
 
         private static void OnDeleted( object source, FileSystemEventArgs e)
         {
 
             Console.WriteLine( "文件删除事件处理逻辑" );
         }
 
         private static void OnRenamed( object source, RenamedEventArgs e)
         {
 
             Console.WriteLine( "文件重命名事件处理逻辑" );
         }
 
     }
}

 

 

  WatcherProcess类：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
using System.IO;
 
namespace test
{
     public class WatcherProcess
     {
         private object sender;
         private object eParam;
 
         public event RenamedEventHandler OnRenamed;
         public event FileSystemEventHandler OnChanged;
         public event FileSystemEventHandler OnCreated;
         public event FileSystemEventHandler OnDeleted;
         public event Completed OnCompleted;
 
         public WatcherProcess( object sender, object eParam)
         {
             this .sender = sender;
             this .eParam = eParam;
         }
 
         public void Process()
         {
             if (eParam.GetType() == typeof (RenamedEventArgs))
             {
                 OnRenamed(sender, (RenamedEventArgs)eParam);
                 OnCompleted(((RenamedEventArgs)eParam).FullPath);
             }
             else
             {
                 FileSystemEventArgs e = (FileSystemEventArgs)eParam;
                 if (e.ChangeType == WatcherChangeTypes.Created)
                 {
                     OnCreated(sender, e);
                     OnCompleted(e.FullPath);
                 }
                 else if (e.ChangeType == WatcherChangeTypes.Changed)
                 {
                     OnChanged(sender, e);
                     OnCompleted(e.FullPath);
                 }
                 else if (e.ChangeType == WatcherChangeTypes.Deleted)
                 {
                     OnDeleted(sender, e);
                     OnCompleted(e.FullPath);
                 }
                 else
                 {
                     OnCompleted(e.FullPath);
                 }
             }
         }
     }
}

 

  

MyFileSystemWather类：

   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
using System;
using System.Collections;
using System.IO;
using System.Threading;
 
namespace test
{
 
     public delegate void Completed( string key);
 
     public class MyFileSystemWather
     {
         private FileSystemWatcher fsWather;
 
         private Hashtable hstbWather;
 
         public event RenamedEventHandler OnRenamed;
         public event FileSystemEventHandler OnChanged;
         public event FileSystemEventHandler OnCreated;
         public event FileSystemEventHandler OnDeleted;
 
         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="path">要监控的路径</param>
         public MyFileSystemWather( string path, string filter)
         {
             if (!Directory.Exists(path))
             {
                 throw new Exception( "找不到路径：" + path);
             }
 
             hstbWather = new Hashtable();
 
             fsWather = new FileSystemWatcher(path);
             // 是否监控子目录
             fsWather.IncludeSubdirectories = false ;
             fsWather.Filter = filter;
             fsWather.Renamed += new RenamedEventHandler(fsWather_Renamed);
             fsWather.Changed += new FileSystemEventHandler(fsWather_Changed);
             fsWather.Created += new FileSystemEventHandler(fsWather_Created);
             fsWather.Deleted += new FileSystemEventHandler(fsWather_Deleted);
         }
 
         /// <summary>
         /// 开始监控
         /// </summary>
         public void Start()
         {
             fsWather.EnableRaisingEvents = true ;
         }
 
         /// <summary>
         /// 停止监控
         /// </summary>
         public void Stop()
         {
             fsWather.EnableRaisingEvents = false ;
         }
 
         /// <summary>
         /// filesystemWatcher 本身的事件通知处理过程
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void fsWather_Renamed( object sender, RenamedEventArgs e)
         {
             lock (hstbWather)
             {
                 hstbWather.Add(e.FullPath, e);
             }
 
             WatcherProcess watcherProcess = new WatcherProcess(sender, e);
             watcherProcess.OnCompleted += new Completed(WatcherProcess_OnCompleted);
             watcherProcess.OnRenamed += new RenamedEventHandler(WatcherProcess_OnRenamed);
             Thread thread = new Thread(watcherProcess.Process);
             thread.Start();
         }
 
         private void WatcherProcess_OnRenamed( object sender, RenamedEventArgs e)
         {
             OnRenamed(sender, e);
         }
 
         private void fsWather_Created( object sender, FileSystemEventArgs e)
         {
             lock (hstbWather)
             {
                 hstbWather.Add(e.FullPath, e);
             }
             WatcherProcess watcherProcess = new WatcherProcess(sender, e);
             watcherProcess.OnCompleted += new Completed(WatcherProcess_OnCompleted);
             watcherProcess.OnCreated += new FileSystemEventHandler(WatcherProcess_OnCreated);
             Thread threadDeal = new Thread(watcherProcess.Process);
             threadDeal.Start();
         }
 
         private void WatcherProcess_OnCreated( object sender, FileSystemEventArgs e)
         {
             OnCreated(sender, e);
         }
 
         private void fsWather_Deleted( object sender, FileSystemEventArgs e)
         {
             lock (hstbWather)
             {
                 hstbWather.Add(e.FullPath, e);
             }
             WatcherProcess watcherProcess = new WatcherProcess(sender, e);
             watcherProcess.OnCompleted += new Completed(WatcherProcess_OnCompleted);
             watcherProcess.OnDeleted += new FileSystemEventHandler(WatcherProcess_OnDeleted);
             Thread tdDeal = new Thread(watcherProcess.Process);
             tdDeal.Start();
         }
 
         private void WatcherProcess_OnDeleted( object sender, FileSystemEventArgs e)
         {
             OnDeleted(sender, e);
         }
 
         private void fsWather_Changed( object sender, FileSystemEventArgs e)
         {
             if (e.ChangeType == WatcherChangeTypes.Changed)
             {
                 if (hstbWather.ContainsKey(e.FullPath))
                 {
                     WatcherChangeTypes oldType = ((FileSystemEventArgs)hstbWather[e.FullPath]).ChangeType;
                     if (oldType == WatcherChangeTypes.Created || oldType == WatcherChangeTypes.Changed)
                     {
                         return ;
                     }
                 }
             }
 
             lock (hstbWather)
             {
                 hstbWather.Add(e.FullPath, e);
             }
             WatcherProcess watcherProcess = new WatcherProcess(sender, e);
             watcherProcess.OnCompleted += new Completed(WatcherProcess_OnCompleted);
             watcherProcess.OnChanged += new FileSystemEventHandler(WatcherProcess_OnChanged);
             Thread thread = new Thread(watcherProcess.Process);
             thread.Start();
         }
 
         private void WatcherProcess_OnChanged( object sender, FileSystemEventArgs e)
         {
             OnChanged(sender, e);
         }
 
         public void WatcherProcess_OnCompleted( string key)
         {
             lock (hstbWather)
             {
                 hstbWather.Remove(key);
             }
         }
     }
}

 使用了线程安全的Hashtable来处理一次改变触发两次事件的问题，要注意的是在实际项目使用中，在通过监控文件事情触发时开一个线程WatcherProcess去处理自己业务逻辑的时候，不管业务逻辑成功或者失败（例如有异常抛出一定要try一下）一定要让WatcherProcess的 Completed也就是MyFileSystemWather的WatcherProcess_OnCompleted执行去移除对应变化文件的Hashtable的key，不然下次此文件改变时是无法触发你的业务逻辑的。

    

     还有就是在进行文件监控的时候， 被监控文件在写入的时候，是会有I/O冲突的，即使写入文件是FileShare.Read的也会出现，要真正解决貌似只有FileMaping方法，但是我的项目中文本的写入软件不是我们能控制的，所以只有用处理异常的方法来解决。


轉自：http://www.cnblogs.com/zhaojingjing/archive/2011/01/21/1941586.html

savagelin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
System.IO.FileSystemWatcher 类
yszwn的专栏
11-26 3179
 侦听文件系统更改通知，并在目录或目录中的文件发生更改时引发事件。以下摘自MSDN 使用 FileSystemWatcher 监视指定目录中的更改。可监视指定目录中的文件或子目录的更改。可以创建一个组件来监视本地计算机、网络驱动器或远程计算机上的文件。若要监视所有文件中的更改，请将 <a id="ctl00_MTCS_main_ctl85_ctl00_ctl00" onclick="f
c#实现数据同步的方法(使用文件监控对象filesystemwatcher)
09-04
主要介绍了C#使用文件监控对象FileSystemWatcher实现数据同步,大家参考使用吧
FileSystemWatcher类的使用----- vb2010实例 磁盘与文件夹监视器-ListBox背景透明.rar
11-05
此实例包含FileSystemWatcher类，clListBox背景透明，类的重写，设置控件可以用透明背景Transparent，从不是创建控件“richTextBox1”的线程访问它，利用线程的解决方案，还有无边窗体移动方法，任务栏右侧通知显示图标方法等，值得新手研究。
在C#使用文件监控对象FileSystemWatcher的几种方案
weixin_33693070的博客
11-08 168
最近在项目中有这么个需求，就是得去实时获取某个在无规律改变的文本文件中的内容。首先想到的是用程序定期去访问这个文件，因为对实时性要求很高，间隔不能超过1S，而且每次获取到文本内容都要去分发给web服务器做别的操作，而那个文本的写入有时候会频繁，1秒可能多次，但是也有可能在相当长一段时间内是没有任何写入的。这样一来如果每秒都去访问文件的话，一个是IO问题，还有就是每次操作都会引起后端一系列程序的反应...
关于FileSystemWatcher类
凯神做开发
02-18 1456
类：System.IO.FileSystemWatcher 首次接触到这个类是在这样的一个用户需求中： 当时需要用一个路径导入资料进DB，导入成功后清除文件；本来新建了一个测试的文件夹，但是文件进来的时机等等不能跟实际相符；又不能直接上线至正式环境； 所以考虑到：将正式环境的文档实时的拷贝至测试环境，也就是文件同步。这才在网上找到这个类，用起来还是挺好的；可以监控文件、文件夹、新建、
C#使用FileSystemWatcher控件实现的文件监控功能示例
08-29
主要介绍了C#使用FileSystemWatcher控件实现的文件监控功能,结合实例形式分析了C# FileSystemWatcher组件的功能及监控文件更改情况的具体使用技巧,需要的朋友可以参考下
C# FileSystemWatcher 在监控文件夹和文件时的使用方法
08-19
主要介绍了C# FileSystemWatcher 在监控文件夹和文件时的使用方法，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以参考下
FileSystemWatcher 类
ainivip的专栏
03-16 348
命名空间: System.IO 程序集: System.IO.FileSystem.Watcher.dll, System.dll, netstandard.dll 侦听文件系统更改通知，并在目录或目录中的文件发生更改时引发事件。Listens to the file system change notifications and raises events when a director...
FileSystemWatcher
MATLABliantongyu的博客
05-18 3496
FileSystemWatcher
文件监视器( FileSystemWatcher) 类的使用
changyuming的专栏
04-25 1436
正如你所想象的,文件监视器类的作用正如其字面含义,它监视一个系统文件,你只需给一个路径,它将触发一个事件当这个路径下文件变化时.它可以监视文件的"重命名","删除","改变"和"创建".让我们来看一下代码:FileSystemWatcher watcher = new FileSystemWatcher();watcher.Path = @"C:/MyDirectory";watche
FileSystemWatcher用法详解
ainyko的专栏
10-17 535
FileSystemWatcher控件主要功能： 监控指定文件或目录的文件的创建、删除、改动、重命名等活动。可以动态地定义需要监控的文件类型及文件属性改动的类型。 1.常用的几个基本属性： (1) Path ：设置要监视的目录的路径。 (2) IncludeSubdirectories ：设置是否级联监视指定路径中的子目录。 (3) Filter ：设置筛选字符串，用
8_Android app作业-源码.zip
06-01
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
低值易耗品管理制度.docx
06-01
低值易耗品管理制度.docx
2024年韭菜主要病虫害绿色防控技术方案.docx
06-01
2024年韭菜主要病虫害绿色防控技术方案.docx
基于ssm的公司人力资源管理系统设计与实现源码.zip
06-01
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
1.2.py
最新发布
06-01
1.2.py
filesystemwatcher如何使用c#实现多文件夹监控
08-15
FileSystemWatcher是一个用于监视文件系统更改的类。在C#中，可以通过以下步骤来使用FileSystemWatcher...这是使用C#中FileSystemWatcher类来监视文件系统更改的基本过程。根据具体的需求，可以进一步定制和扩展功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值