So outside of using interop, there is no way to control buffering when using
the standard .net classes for file i/o?

Try creating the FileStream this way so that you can modify the
parameters to the CreateFile method:

(pasted from MSDN help)

using System;
using Microsoft.Win32.SafeHandles;
using System.Runtime.InteropServices;
using System.ComponentModel;

class SafeHandlesExample
{

   static void Main()
   {
       try
       {

           UnmanagedFileLoader loader = new
UnmanagedFileLoader("example.xml");

FileStream fs = new FileStream(loader.SafeFileHandle,
FileAccess.Write);

       }
       catch (Exception e)
       {
           Console.WriteLine(e);
       }
       Console.ReadLine();

   }
}

class UnmanagedFileLoader
{

   public const short FILE_ATTRIBUTE_NORMAL = 0x80;
   public const short INVALID_HANDLE_VALUE = -1;
   public const uint GENERIC_READ = 0x80000000;
   public const uint GENERIC_WRITE = 0x40000000;
   public const uint CREATE_NEW = 1;
   public const uint CREATE_ALWAYS = 2;
   public const uint OPEN_EXISTING = 3;

   // Use interop to call the CreateFile function.
   // For more information about CreateFile,
   // see the unmanaged MSDN reference library.
   [DllImport("kernel32.dll", SetLastError = true)]
   static extern SafeFileHandle CreateFile(string lpFileName, uint
dwDesiredAccess,
     uint dwShareMode, IntPtr lpSecurityAttributes, uint
dwCreationDisposition,
     uint dwFlagsAndAttributes, IntPtr hTemplateFile);

   private SafeFileHandle handleValue = null;

   public UnmanagedFileLoader(string Path)
   {
       Load(Path);
   }

   public void Load(string Path)
   {
       if (Path == null && Path.Length == 0)
       {
           throw new ArgumentNullException("Path");
       }

       // Try to open the file.
       handleValue = CreateFile(Path, GENERIC_WRITE, 0, IntPtr.Zero,
OPEN_EXISTING, 0, IntPtr.Zero);

       // If the handle is invalid,
       // get the last Win32 error
       // and throw a Win32Exception.
       if (handleValue.IsInvalid)
       {
           Marshal.ThrowExceptionForHR(Marshal.GetLastWin32Error());
       }
   }

   public SafeFileHandle Handle
   {
       get
       {
           // If the handle is valid,
           // return it.
           if (!handleValue.IsInvalid)
           {
               return handleValue;
           }
           else
           {
               return null;
           }
       }

   }

}

Bryan Phillips
MCSD, MCDBA, MCSE
Blog:  http://bphillips76.spaces.live.com

"Ken Varn" <nospam> wrote in message
news:#FWYe9S#GHA.4800@TK2MSFTNGP05.phx.gbl:

I think that this would  only work for fixed length data.

Not sure this helps, but you can set the buf size (min of 8 bytes) in the
FileStream ctor and use Flush when you need it.

           using (FileStream fs = new FileStream(@"c:\junk.txt",
FileMode.Create, FileAccess.Write, FileShare.None, 10))
           {
               byte[] buf = new byte[10];
               fs.Write(buf, 0, buf.Length);
               fs.Flush(); // Not sure this would be needed?
           }

The

of