Question

i have two programs working on the same file
i want the first program to check regularly on the file, and if any changes are made operate on the file and empty it.
the other program writes to the file.
the problem occurs when the second program tries to write on the file because it’s used from the first one
is there an (if there’s any implemented C# program would be even better) algorithm to handle this?

Answer 1

To check if file has changed you might first of all check its timestamp. In pseudo code, you might try something like this in the monitoring program:

try {
  if(FileTimeStampHasChanged(FileName)) {
    //Attempt to do something with the file
  }
}
catch {
  // Handle or ignore the exception if you can't open the file (maybe the other application hasn't finished writing). You can always retry later.
}

However, I would strongly recommend a different approach altogether. Here are the options I’d suggest.

1. If you can alter the writing program, let it write to a temporary file (e.g. output.$$$) and let it rename it as soon as it’s done writing. Renaming is instantaneous and doesn’t cause any locking. This is, in my experience, one of the best simple solutions for concurrent access.
2. If you cannot alter the writing program, then modify the reading one. Using the logic I described in point 1, let it try to rename the file to read and work on the renamed copy. If the rename fails, then it means that the writer isn’t done, and an attempt can be done later.
3. If you cannot alter any of the programs, then you can make your own “traffic warden” application to implement point 1. It requires more work, but it’s still doable. Here’s how:
   • Configure the Writer to write into a folder, e.g. “Output”.
   • Configure the Reader to read from another folder, e.g. “Input”.
   • Write your Traffic Warden so that it monitors Output folder and, when the file changes, it moves it to Input folder. Moving is instantaneous as well (it’s practically the same operation as renaming).