[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
public sealed class SafeFindHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    private SafeFindHandle() : base(true) { }

    protected override bool ReleaseHandle() {
        return FindClose(this.handle);
    }

    [DllImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    private static extern bool FindClose(IntPtr handle);
}

public class FileStreamSearcher
{
    private const int ERROR_HANDLE_EOF = 38;
    private enum StreamInfoLevels { FindStreamInfoStandard = 0 }

    [DllImport("kernel32.dll", ExactSpelling=true, 
        CharSet=CharSet.Auto, SetLastError=true)]
    private static extern SafeFindHandle FindFirstStreamW(
        string lpFileName, StreamInfoLevels InfoLevel,
        [In, Out, MarshalAs(UnmanagedType.LPStruct)] 
        WIN32_FIND_STREAM_DATA lpFindStreamData, uint dwFlags);

    [DllImport("kernel32.dll", ExactSpelling=true, 
        CharSet=CharSet.Auto, SetLastError=true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool FindNextStreamW(
        SafeFindHandle hndFindFile,
        [In, Out, MarshalAs(UnmanagedType.LPStruct)] 
        WIN32_FIND_STREAM_DATA lpFindStreamData);
    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
    private class WIN32_FIND_STREAM_DATA
    {
        public long StreamSize;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst=296)]
        public string cStreamName;
    }

    public static IEnumerable<string> GetStreams(FileInfo file)
    {
        if (file == null) throw new ArgumentNullException("file");
        WIN32_FIND_STREAM_DATA findStreamData = 
            new WIN32_FIND_STREAM_DATA();

        SafeFindHandle handle = FindFirstStreamW(
            file.FullName, StreamInfoLevels.FindStreamInfoStandard,
            findStreamData, 0);
        if (handle.IsInvalid) throw new Win32Exception();
        try
        {
            do { yield return findStreamData.cStreamName; }
            while (FindNextStreamW(handle, findStreamData));
            int lastError = Marshal.GetLastWin32Error();
            if (lastError != ERROR_HANDLE_EOF) 
                throw new Win32Exception(lastError);
        }
        finally { handle.Dispose(); }
    }
}

public enum StreamType
{
  Data = 1, ExternalData = 2, SecurityData = 3, 
  AlternateData = 4, Link = 5, PropertyData = 6, 
  ObjectID = 7, ReparseData = 8, SparseDock = 9
}

public struct StreamInfo
{
  public StreamInfo(string name, StreamType type, long size)
  {
    Name = name;
    Type = type;
    Size = size;
  }
  public readonly string Name;
  public readonly StreamType Type;
  public readonly long Size;
}

public class FileStreamSearcher
{
  [DllImport("kernel32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  private static extern bool BackupRead(
    SafeFileHandle hFile, IntPtr lpBuffer,
    uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead,
    [MarshalAs(UnmanagedType.Bool)] bool bAbort,
    [MarshalAs(UnmanagedType.Bool)] bool bProcessSecurity,
    ref IntPtr lpContext);

  [DllImport("kernel32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  private static extern bool BackupSeek(SafeFileHandle hFile,
    uint dwLowBytesToSeek, uint dwHighBytesToSeek,
    out uint lpdwLowByteSeeked, out uint lpdwHighByteSeeked,
    ref IntPtr lpContext);

  public static IEnumerable<StreamInfo> GetStreams(FileInfo file)
  {
    const int bufferSize = 4096;
    using (FileStream fs = file.OpenRead())
    {
      IntPtr context = IntPtr.Zero;
      IntPtr buffer = Marshal.AllocHGlobal(bufferSize);
      try
      {
        while (true)
        {
          uint numRead;
          if (!BackupRead(fs.SafeFileHandle, buffer, 
             (uint)Marshal.SizeOf(typeof(Win32StreamID)), out numRead, 
             false, true, ref context)) throw new Win32Exception();

          if (numRead > 0)
          {
            Win32StreamID streamID = (Win32StreamID)
              Marshal.PtrToStructure(buffer, typeof(Win32StreamID));
            string name = null;
            if (streamID.dwStreamNameSize > 0)
            {
              if (!BackupRead(fs.SafeFileHandle, buffer, 
                   (uint)Math.Min(bufferSize, streamID.dwStreamNameSize),
                   out numRead, false, true, ref context))         
                       throw new Win32Exception();
              name = Marshal.PtrToStringUni(buffer, (int)numRead / 2);
            }

            yield return new StreamInfo(name, 
              streamID.dwStreamId, streamID.Size);

            if (streamID.Size > 0)
            {
              uint lo, hi;
              BackupSeek(fs.SafeFileHandle, uint.MaxValue, 
                int.MaxValue, out lo, out hi, ref context);
            }
          }
          else break;
        }
      }
      finally
      {
        Marshal.FreeHGlobal(buffer);
        uint numRead;
        if (!BackupRead(fs.SafeFileHandle, IntPtr.Zero, 0, out numRead, 
             true, false, ref context)) throw new Win32Exception();
      }
    }
  }
}

private static FileStream CreateFileStream(string path, 
    FileAccess access, FileMode mode, FileShare share)
{
    if (mode == FileMode.Append) mode = FileMode.OpenOrCreate;
    	SafeFileHandle handle = CreateFile(path, access, share, 
        IntPtr.Zero, mode, 0, IntPtr.Zero);
    if (handle.IsInvalid) 
        throw new IOException("Could not open file stream.", new Win32Exception());
    return new FileStream(handle, access);
}

[DllImport("kernel32.dll", CharSet=CharSet.Auto, SetLastError=true)]
private static extern SafeFileHandle CreateFile(string lpFileName,
    FileAccess dwDesiredAccess, FileShare dwShareMode, 
    IntPtr lpSecurityAttributes, FileMode dwCreationDisposition, 
    int dwFlagsAndAttributes, IntPtr hTemplateFile);