I have a web service that recursively traverses a folder, collecting
information about the subdirectories and files in it.  One of the things I
do is store information in the hidden streams in the files.  To get at the
hidden streams I have to define CreateFile from kernel32.dll, and open the
stream up.  But when 2 processes access this web service at the same time,
one instance's calls to CreateFile are disrupting the other instance's calls
to DirectoryInfo.GetDirectories() and GetFiles(), which randomly throw an
exception of "System.IO.IOException" with an message of "The handle is
invalid".

I am hoping that I just have some of the parameters wrong in my call to
CreateFile.  But my fear is that the static CreateFile function is returning
the same file handle number to two different processes, and one is closing
the handle of the other.

Any help would be greatly appreciated.

Here is my CreateFile() definition and calling function:

public class VersionInformation
{
[DllImport("kernel32.dll")]
static extern IntPtr CreateFile(
   string lpFileName,
   uint dwDesiredAccess,
   uint dwShareMode,
   IntPtr lpSecurityAttributes,
   uint dwCreationDisposition,
   uint dwFlagsAndAttributes,
   IntPtr hTemplateFile);

private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint CREATE_ALWAYS = 2;
private const uint OPEN_EXISTING = 3;
private const uint FILE_SHARE_READ = 0x00000001;
private const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
private static IntPtr INVALID_HANDLE = new IntPtr(-1);
private const uint ERROR_SHARING_VIOLATION = 32;
private const uint ERROR_ACCESS_DENIED = 5;
[DllImport("kernel32.dll")]
static extern IntPtr CloseHandle(IntPtr hHandle);
[DllImport("kernel32.dll")]
static extern uint GetLastError();

public SPVersion GetVersionInformation(string i_fileName)
{
   SPVersion a_returnVersion = null;
   IntPtr a_fileHandle = CreateFile(i_fileName + ":XEDMS.VERSION",
       GENERIC_READ,
       FILE_SHARE_READ,
       IntPtr.Zero,
       OPEN_EXISTING,
       0,
       IntPtr.Zero);
   uint a_error = GetLastError();
   if (a_fileHandle != INVALID_HANDLE)
   {
       FileStream a_reader = new FileStream(a_fileHandle, FileAccess.Read);
       try
       {
           XmlSerializer a_serializer = new
XmlSerializer(typeof(SPVersion));
           a_returnVersion = (SPVersion)a_serializer.Deserialize(a_reader);
       }
       catch {}
       a_reader.Close();
       CloseHandle(a_fileHandle);
   }
   return a_returnVersion;
}