Más rápido (inseguro) BinaryReader in.NET

Me encontré con una situación en la que tengo un archivo bastante grande del que necesito leer datos binarios.

En consecuencia, me di cuenta de que la implementación predeterminada de BinaryReader en.NET es bastante lenta. Al mirar con .NET Reflector me encontré con esto:

public virtual int ReadInt32()
{
    if (this.m_isMemoryStream)
    {
        MemoryStream stream = this.m_stream as MemoryStream;
        return stream.InternalReadInt32();
    }
    this.FillBuffer(4);
    return (((this.m_buffer[0] | (this.m_buffer[1] << 8)) | (this.m_buffer[2] << 0x10)) | (this.m_buffer[3] << 0x18));
}

Lo que me parece extremadamente ineficiente, pensando en cómo se diseñaron las computadoras para trabajar con valores de 32 bits desde que se inventó la CPU de 32 bits.

Así que hice mi propio (inseguro) FastBinaryReader clase con código como este en su lugar:

public unsafe class FastBinaryReader :IDisposable
{
    private static byte[] buffer = new byte[50];
    //private Stream baseStream;

    public Stream BaseStream { get; private set; }
    public FastBinaryReader(Stream input)
    {
        BaseStream = input;
    }


    public int ReadInt32()
    {
        BaseStream.Read(buffer, 0, 4);

        fixed (byte* numRef = &(buffer[0]))
        {
            return *(((int*)numRef));
        }
    }
...
}

Que es mucho más rápido - Me las arreglé para reducir 5-7 segundos del tiempo que tomó para leer un archivo de 500 MB, pero todavía es bastante lento en general (29 segundos inicialmente y ~22 segundos ahora con mi FastBinaryReader).

Todavía me desconcierta en cuanto a por qué todavía toma tanto tiempo leer un archivo tan relativamente pequeño. Si copio el archivo de un disco a otro, solo tarda un par de segundos, por lo que el rendimiento del disco no es un problema.

Además entre líneas el ReadInt32, etc. llamadas, y terminé con este código:

using (var br = new FastBinaryReader(new FileStream(cacheFilePath, FileMode.Open, FileAccess.Read, FileShare.Read, 0x10000, FileOptions.SequentialScan)))

  while (br.BaseStream.Position < br.BaseStream.Length)
  {
      var doc = DocumentData.Deserialize(br);
      docData[doc.InternalId] = doc;
  }
}

   public static DocumentData Deserialize(FastBinaryReader reader)
   {
       byte[] buffer = new byte[4 + 4 + 8 + 4 + 4 + 1 + 4];
       reader.BaseStream.Read(buffer, 0, buffer.Length);

       DocumentData data = new DocumentData();
       fixed (byte* numRef = &(buffer[0]))
       {
           data.InternalId = *((int*)&(numRef[0]));
           data.b = *((int*)&(numRef[4]));
           data.c = *((long*)&(numRef[8]));
           data.d = *((float*)&(numRef[16]));
           data.e = *((float*)&(numRef[20]));
           data.f = numRef[24];
           data.g = *((int*)&(numRef[25]));
       }
       return data;
   }

¿Alguna otra idea sobre cómo hacer esto aún más rápido? Estaba pensando que tal vez podría usar marshalling para mapear todo el archivo directamente en la memoria sobre una estructura personalizada, ya que los datos son lineales, de tamaño fijo y secuenciales.

RESUELTO: Llegué a la conclusión de que el buffering/BufferedStream de FileStream es defectuoso. Por favor vea la respuesta aceptada y mi propia respuesta (con el solución) a continuación.