DataGridView тормозит при перемещении

DoubleBuffered =true;

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
 
namespace WindowsFormsApplication327
{
    public partial class Form1 : Form
    {
        private CachedFile<MyRecord256> cache;
 
        public Form1()
        {
            InitializeComponent();
 
            var file = "c:\\temp345.bin";
 
            //create test file if needed
            CreateFileIfNeed(file);
 
            //create file cache
            cache = new CachedFile<MyRecord256>(file, 256 * 4);
 
            //create dgv in virtual mode
            var dgv = new DataGridView {Parent = this, Dock = DockStyle.Fill, VirtualMode = true, AllowUserToAddRows = false, ReadOnly = true, BackgroundColor = Color.White};
            dgv.RowCount = cache.RecordsCount;
            dgv.ColumnCount = 256;
            dgv.CellValueNeeded += (o, e) => e.Value = cache[e.RowIndex].Items[e.ColumnIndex];
        }
 
        private void CreateFileIfNeed(string filePath)
        {
            if(!File.Exists(filePath))
            {
                var rnd = new Random();
 
                using(var fs = new FileStream(filePath, FileMode.Create))
                using (var bw = new BinaryWriter(fs))
                    for (int i = 0; i < 500000; i++)
                    {
                        bw.Write((float)i);
                        for (int j = 0; j < 256 - 1; j++)
                            bw.Write((float) rnd.NextDouble());
                    }
            }
        }
    }
 
    /// <summary>
    /// Record of 256 float values
    /// </summary>
    public class MyRecord256:IRecord
    {
        public float[] Items = new float[256];
 
        public void Parse(BinaryReader br)
        {
            for (int i = 0; i < 256; i++)
                Items[i] = br.ReadSingle();
        }
    }
 
    /// <summary>
    /// Cached access to binary file
    /// </summary>
    public class CachedFile<T> where T : IRecord, new()
    {
        public int RecordsCount { get; private set; }
 
        private List<T> loadedRecords = new List<T>();
        private int firstLoadedRecordIndex;
        const int preLoadRecordsCount = 100;
        private string filePath;
        private int recordSize;
 
        public CachedFile(string filePath, int recordSize)
        {
            this.filePath = filePath;
            this.recordSize = recordSize;
            using (var fs = new FileStream(filePath, FileMode.Open))
                RecordsCount = (int)fs.Length/recordSize;
 
            //load first records
            Load(0);
        }
 
        /// <summary>
        /// Loads records to the cache
        /// </summary>
        void Load(int iRecord)
        {
            //Console.WriteLine(iRecord);
 
            //calc record index bounds
            var from = Math.Max(0, iRecord - preLoadRecordsCount);
            var to = Math.Min(from + preLoadRecordsCount * 2, RecordsCount - 1);
            var count = to - from + 1;
 
            //load records to cache from the file
            loadedRecords.Clear();
            using (var fs = new FileStream(filePath, FileMode.Open))
            using (var br = new BinaryReader(fs))
            {
                br.BaseStream.Seek(from * recordSize, SeekOrigin.Begin);
                for (int i = 0; i < count; i++)
                {
                    var rec = new T();
                    rec.Parse(br);
                    loadedRecords.Add(rec);
                }
            }
 
            firstLoadedRecordIndex = from;
        }
 
        /// <summary>
        /// Return record by index
        /// </summary>
        public T this[int iRecord]
        {
            get
            {
                if (iRecord < 0 || iRecord >= RecordsCount) throw new IndexOutOfRangeException();
                if (iRecord < firstLoadedRecordIndex || iRecord >= firstLoadedRecordIndex + loadedRecords.Count) Load(iRecord);
                return loadedRecords[iRecord - firstLoadedRecordIndex];
            }
        }
    }
 
    public interface IRecord
    {
        void Parse(BinaryReader br);
    }
}