Hello ABCL ,
The following words are copied from "c# Cook Book, 2nd edition"-"Recipe
12.22. Locking Subsections of a File",I think its useful:
/****************copied*************************/
Problem
You need to read or write data from or to a section of a file, and you
want to make sure that no other processes or threads can access,
modify, or delete the file until you have finished with it.
Solution
Locking out other processes from accessing your file while you are
using it is accomplished through the Lock method of the FileStream
class. The following code creates a file from the fileName parameter
and writes two lines to it. The entire file is then locked using the
Lock method. While the file is locked, the code goes off and does some
other processing; when this code returns, the file is closed, thereby
unlocking it:
public static void CreateLockedFile(string fileName)
{
using (FileStream fileStream = new FileStream(fileName,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.ReadWrite))
{
using (StreamWriter streamWriter = new
StreamWriter(fileStream))
{
streamWriter.WriteLine("The First Line");
streamWriter.WriteLine("The Second Line");
streamWriter.Flush( );
// Lock all of the file.
fileStream.Lock(0, fileStream.Length);
// Do some lengthy processing here...
Thread.Sleep(1000);
// Make sure we unlock the file.
// If a process terminates with part of a file locked or
closes a file
// that has outstanding locks, the behavior is undefined
which is MS
// speak for bad things....
fileStream.Unlock(0, fileStream.Length);
streamWriter.WriteLine("The Third Line");
}
}
}
Discussion
If a file is opened within your application and the FileShare parameter
of the FileStream.Open call is set to FileShare.ReadWrite or
FileShare.Write, other code in your application can view or alter the
contents of the file while you are using it. To handle file access with
more granularity, use the Lock method of the FileStream object to
prevent other code from overwriting all or a portion of your file. Once
you are done with the locked portion of your file, you can call the
Unlock method on the FileStream object to allow other code in your
application to write data to that portion of the file.
To lock an entire file, use the following syntax:
fileStream.Lock(0, fileStream.Length);
To lock a portion of a file, use the following syntax:
fileStream.Lock(4, fileStream.Length - 4);
This line of code locks the entire file except for the first four
characters. Note that you can lock an entire file and still open it
multiple times, as well as write to it.
If another thread is accessing this file, it is possible to see an
IOException thrown during the call to either the Write, Flush, or Close
methods. For example, the following code is prone to such an exception:
public static void CreateLockedFile(string fileName)
{
using (FileStream fileStream = new FileStream(fileName,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.ReadWrite))
{
using (StreamWriter streamWriter = new
StreamWriter(fileStream))
{
streamWriter.WriteLine("The First Line");
streamWriter.WriteLine("The Second Line");
streamWriter.Flush( );
// Lock all of the file.
fileStream.Lock(0, fileStream.Length);
using (StreamWriter streamWriter2 = new StreamWriter(
new FileStream(fileName,
FileMode.Open,
FileAccess.Write,
FileShare.ReadWrite)))
{
streamWriter2.Write("foo ");
try
{
streamWriter2.Close( ); // --> Exception occurs
here!
}
catch
{
Console.WriteLine(
"The streamWriter2.Close call generated an
exception.");
}
streamWriter.WriteLine("The Third Line");
}
}
}
}
This code produces the following output:
The streamWriter2.Close call generated an exception.
Even though streamWriter2, the second StreamWriter object, writes to a
locked file, it is when the streamWriter2.Close method is executed that
the IOException is thrown.
If the code for this recipe were rewritten as follows:
public static void CreateLockedFile(string fileName)
{
using (FileStream fileStream = new FileStream(fileName,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.ReadWrite))
{
using (StreamWriter streamWriter = new
StreamWriter(fileStream))
{
streamWriter.WriteLine("The First Line");
streamWriter.WriteLine("The Second Line");
streamWriter.Flush( );
// Lock all of the file.
fileStream.Lock(0, fileStream.Length);
// Try to access the locked file...
using (StreamWriter streamWriter2 = new StreamWriter(
new FileStream(fileName,
FileMode.Open,
FileAccess.Write,
FileShare.ReadWrite)))
{
streamWriter2.Write("foo");
fileStream.Unlock(0, fileStream.Length);
streamWriter2.Flush( );
}
}
}
}
no exception is thrown. This is due to the fact that the code closed
the FileStream object that initially locked the entire file. This
action also freed all of the locks on the file that this FileStream
object was holding onto. Since the streamWriter2. Write("Foo") method
had written Foo to the stream's buffer (but had not flushed it), the
string Foo was still waiting to be flushed and written to the actual
file. Keep this situation in mind when interleaving the opening,
locking, and closing of streams. Mistakes in code sometimes manifest
themselves a while after they are written. This leads to some bugs that
are more difficult to track down, so tread carefully when using file
locking.
