Would watching a file for changes or redundantly querying that file be more efficient?

Question

I am wondering whether watching a file/directory for changes using the FileSystemWatcher class is extremely memory intensive. I am developing a desktop application in C# that will be running behind the scenes continuously on low-performance computers, and I need some way of checking to see if various files have changed. I can think of a few solutions:

1. Watch the directories using FileSystemWatcher.
2. Run a timed thread on an interval that goes through and manually checks this.
3. Check manually every time the actionhandler thread runs (the program will occasionally do something, on an action).

Any suggestions?

Thanks!

badPanda

Answer 1

Event-based are always more efficient than polling using the same or spawning a new thread, so it's the right idea to use FileSystemWatcher. The programming model, which uses delegates is also more elegant in my opinion.

Answer 2

I used FileSystemWatcher class to watch *.txt file changes within hundreds of directories with no perfomance issues. So I guess it's the best solution.

Answer 3

You want to go with FileSystemWatcher. It is what this object is designed to do. It has been developed, and tested for widespread use. Anything that you write will not go under the scrutiny of testing and optimization that it has. There's no reason to re-invent the wheel when you don't have to.

Answer 4

In a large scale file transfer project I am working on currently (nation wide), FileSystemWatcher was a one way option (with some management on file locks, events queueing, etc). You have so many advantages, on using the underlying OS constructs (providing all this event based interaction), that I don't think that you will achieve such efficient behaviour otherwise.

Answer 5

I've seen a few programs which check the file/directory manually for changes every time the program regains focus. This may be appropriate if your program meets a few requirements:

1. It is common for your program to be inactive (i.e. in a state where knowing about changes to files is unnecessary) for long periods of time.
2. It is unlikely for file/directory to change while the program is active (except by the program itself, which does not require notification).
3. You are only concerned with a small number of files.

Even so, FileSystemWatcher is fine even in that case.