观看文件的最佳方法

Question

OK I have an application that produces some contracts based on a file that is created by another app.

I have implemented a filewatcher to watch for the file being created and it then kicks off a backgroundworker process to create the contracts based on the filename.

The problem I am having is that during the background worker process I set EnableRaisingEvents to false so that the app does not start to process a different set of contracts whilst the first is running (It's also to stop calling the background worker whilst it is running as it cant run 2 things at once!).

All works fine, the other app creates a file, filewatcher picks it up and starts processing, the problem is that when processing is finished the filewatcher is re-enabled but I assume it wont pick up any files that were created when EnableRaisingEvents was false - and so if the application that creates the initial file to produce the contracts happens to create another file whilst my app is processing it will just be left. Does that make sense? And what is the best way round this?

I had thought of having another process that when the initial contract creation is finished would then look in the directory for other files created between the time when the filewatcher was disabled and if there were none it would then re-enable the filewatcher but I am wondering if there is a simpler way to do this?

Answer 1

You could split your process in tasks. One task is the FileRegistrator , which picks up new files, registers them in database. It runs all the time, no need to EnableRaisingEvents to false.

The next task is the ProcessorTask (or whatever name) which will query the database, find the first one and processes it. It will query the database at regular times to see if a new file is registered.

You could implement this little processor using Quartz.NET scheduler in a windows service.

(I did about the same a while ago, but I didn't use FileSystemWatcher)

Answer 2

A BlockingCollection would do this.
Keep FileWatcher hot and let it add to the blocking collection.
The consumer just processes the collection one at a time.

BlockingCollection Class

class AddTakeDemo
{
    // Demonstrates: 
    //      BlockingCollection<T>.Add() 
    //      BlockingCollection<T>.Take() 
    //      BlockingCollection<T>.CompleteAdding() 
    public static void BC_AddTakeCompleteAdding()
    {
        // here you need to synch as it would have missed any 
        // new files while the application was down 
        // yes L-Three and any files that were not yet processed 
        // clearly the existing program is an end to end synch 
        // or no synch at all as it could be nothing else 
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {

            // Spin up a Task to populate the BlockingCollection  
            using (Task t1 = Task.Factory.StartNew(() =>
            {
                //  FielSystem watcher                    
                bc.Add(fille);

            }))
            {

                // Spin up a Task to consume the BlockingCollection 
                using (Task t2 = Task.Factory.StartNew(() =>
                {
                    try
                    {
                        // Consume consume the BlockingCollection 
                        while (true) Console.WriteLine(bc.Take());
                        // process the file
                    }
                    catch (InvalidOperationException)
                    {
                        // An InvalidOperationException means that Take() was called on a completed collection
                        Console.WriteLine("That's All!");
                    }
                }))

                    Task.WaitAll(t1, t2);
            }
        }
    }
}