Загрузка в listview данных из двумерного массива. Обновление контрола.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Windows.Forms;

namespace WindowsFormsApplication8 {
    public partial class Form1 : Form {

        private const int COLS = 20;
        private const int ROWS = 50;

        public Form1() {
            InitializeComponent();

            listView1.OptimizeForDoubleBuffer();

            this.data = GenerateArray(COLS, ROWS);
            this.data_items = DataItemHelper.FillListView(listView1, data);
        }

        private int[,] data;

        private DataItem<int>[,] data_items;

        private static int[,] GenerateArray(int col_count, int row_count) {
            int[,] result = new int[row_count, col_count];
            int value = 0;
            for (int col = 0; col < col_count; ++col) {
                for (int row = 0; row < row_count; ++row) {
                    result[row, col] = value++;
                }
            }
            return result;
        }

        private void Form1_Load(object sender, EventArgs e) {
            timer1.Enabled = true;
        }

        private Random random = new Random();

        private void timer1_Tick(object sender, EventArgs e) {
            int items_to_change = random.Next(20);
            for (int i = 0; i < items_to_change; ++i) {
                int row = random.Next(ROWS);
                int col = random.Next(COLS);

                ++data[row, col];
            }
            DataItemHelper.RefreshListView(listView1, data, data_items);
        }
    }

    public static class ListViewHelper {

        public static void OptimizeForDoubleBuffer(this ListView list_view) {
            // list_view.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
[COLOR=Red]            list_view.GetType()
                .GetMethod("SetStyle", BindingFlags.Instance | BindingFlags.NonPublic)
                .Invoke(list_view, new object[] { ControlStyles.OptimizedDoubleBuffer, true });
[/COLOR]        }
    }

    public class DataItem<T> {

        private static readonly EqualityComparer<T> comparer = EqualityComparer<T>.Default;

        public DataItem(ListViewItem.ListViewSubItem sub_item, T value) {
            this._sub_item = sub_item;
            this._value = value;
            ValueChanged();
        }

        private readonly ListViewItem.ListViewSubItem _sub_item;

        private T _value;

        public T Value {
            get {
                return _value;
            }
            set {
                if (!comparer.Equals(_value, value)) {
                    _value = value;
                    ValueChanged();
                }
            }
        }

        private void ValueChanged() {
            _sub_item.Text = _value.ToString();
        }
    }


    public static class DataItemHelper {

        private const int COL_INDEX = 1;
        private const int ROW_INDEX = 0;

        public static DataItem<T>[,] FillListView<T>(ListView list, T[,] data) {
            int row_count = data.GetUpperBound(ROW_INDEX);
            int col_count = data.GetUpperBound(COL_INDEX);

            list.BeginUpdate();
            try {
                list.Clear();

                list.Columns.Add(new ColumnHeader() {
                    Width = 0,
                    DisplayIndex = 0
                });

                for (int col = 0; col <= col_count; ++col) {
                    list.Columns.Add(new ColumnHeader() {
                        Text = col.ToString(),
                        Width = 30
                    });
                }

                DataItem<T>[,] result = new DataItem<T>[row_count + 1, col_count + 1];
                for (int row = 0; row <= row_count; ++row) {
                    ListViewItem item = list.Items.Add("");
                    for (int col = 0; col <= col_count; ++col) {
                        result[row, col] = new DataItem<T>(item.SubItems.Add(""), data[row, col]);
                    }
                }
                return result;
            } finally {
                list.EndUpdate();
            }
        }

        public static void RefreshListView<T>(ListView list, T[,] data, DataItem<T>[,] data_items) {
            int row_count = data.GetUpperBound(ROW_INDEX);
            int col_count = data.GetUpperBound(COL_INDEX);

            if (row_count != data_items.GetUpperBound(ROW_INDEX))
                throw new ArgumentException();

            if (col_count != data_items.GetUpperBound(COL_INDEX))
                throw new ArgumentException();

            for (int row = 0; row <= row_count; ++row) {
                for (int col = 0; col <= col_count; ++col) {
                    data_items[row, col].Value = data[row, col];
                }
            }
        }

    }

}

if (row_count != data_items.GetUpperBound(ROW_INDEX))
                throw new ArgumentException();

ArgumentException не обработано
Значение не попадает в ожидаемый диапазон.

private void RefreshDataTimer_Tick(object sender, EventArgs e)
        {
            int SelectItem=0;
            DataItemHelper.RefreshListView(ListView1, data, data_items);
            if (Torrents_list.SelectedIndices.Count > 0)
            {
                SelectItem = ListView1.SelectedIndices[0];
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (Working == false)
            {
                backgroundWorker1.RunWorkerAsync();
                Working = true;
                GetDataTimer.Enabled = true;
            }
            else
            {
                backgroundWorker1.CancelAsync();
                GetDataTimer.Enabled = false;
                RefreshDataTimer.Enabled = false; FirstTime = true;
                Working = false;
            }
        }

        private void GetDataTimer_Tick(object sender, EventArgs e)
        {
            if (swap != null) { data = swap; }
            if (data != null && FirstTime == true)
            {
                FirstTime = false;
                data_items=DataItemHelper.FillListView(ListView1, data);
                RefreshDataTimer.Enabled = true;
            }
        }

public static void RefreshListView<T>(ListView list, T[,] data, DataItem<T>[,] data_items)
        {
            int row_count = data.GetUpperBound(ROW_INDEX);
            int col_count = data.GetUpperBound(COL_INDEX);

            if (row_count != data_items.GetUpperBound(ROW_INDEX))
----------------                FirstTime = true;// throw new ArgumentException(); ------------------------------
           
            if (col_count != data_items.GetUpperBound(COL_INDEX))
                throw new ArgumentException();

            for (int row = 0; row <= row_count; ++row)
            {
                for (int col = 0; col <= col_count; ++col)
                {
                    data_items[row, col].Value = data[row, col];
                }
            }