XML and threads

My suggestion: do nothing special!

Lets think about the possible cases:

1. The worker thread read the file while no one else is using it -> no problem
2. The worker thread reads the file and get an error because e.g. someone is using the file exclusive -> you have always to handle this case (e.g. Sleep and try again after a while)

Just handle this as you are implementing to independent programs for reading and writing. The only difference is that it is easy to signal the worker thread that someone (main thread) changed the content of the file. The critical section is implemented by the file system ;-)

For your particular case the best is Multiple Read Exclusive Write Synchronizer

Note that both critical section and Multiple Read Exclusive Write Synchronizer can be used only within a single process - you can't use them to synchronize an access to a shared resource from two or more processes (applications).

You can create a mutex object when writing, and other threads can read if only the mutex object doesn't exist.

I suggest using windows file locking. Initially I would start by making each thread use the correct flags when trying to access the file - flags that only read use that flag, and the writing flag uses write-deny-read. Since reading the file should be fast that should work fine - the writing thread will need to retry on access denied, but that should be fairly rare. That depends a lot on how often reading happens. From your description it should not be a problem.

If the writing thread does block too much because of the reading threads you could try write-allow-read locking and see whether that works. It might. If it doesn't, try truncating the file as the first step when you write. So, open the file, set length to zero and flush, then build the new file in memory before writing it in one go (MemoryStream.SaveToFile then Flush or Close).