Hi Marcus,

I recently went through the same thing with the datagrid using C#, I
was trying to bind a collection object to my datagrid and whenever I
removed an item from my collection I got an IndexOutOfRangeException.
I was only able to find 1 article that helped me with this problem,
perhaps it may help you as well, I know the discussion centers around
VB.NET but there is some code from this thread done in C# that may
give you an idea on how to solve your problem.

Mike

http://groups.google.ca/group/microsoft.public.dotnet.framework.windowsforms.dat
abinding/browse_thread/thread/f3fd32e6d4ab4556/6c65a2f4672ffa6c?lnk=st&q=System.
IndexOutOfRangeException%3A+Index+was+outside+the+bounds+of+the+array.+at+System
.Windows.Forms.DataGrid.Edit(String+instantText)+%2B+Object&rnum=1&hl=en#6c65a2f
4672ffa6c

public class Customer : IEditableObject
{

   struct CustomerData
   {
       internal string id ;
       internal string firstName ;
       internal string lastName ;
   }

   private CustomersList parent;
   private CustomerData custData;
   private CustomerData backupData;
   private bool inTxn = false;

   // Implements IEditableObject
   void IEditableObject.BeginEdit()
   {
       Console.WriteLine("Start BeginEdit");
       if (!inTxn)
       {
           this.backupData = custData;
           inTxn = true;
           Console.WriteLine("BeginEdit - " +
this.backupData.lastName);
       }
       Console.WriteLine("End BeginEdit");
   }

   void IEditableObject.CancelEdit()
   {
       Console.WriteLine("Start CancelEdit");
       if (inTxn)
       {
           this.custData = backupData;
           inTxn = false;
           Console.WriteLine("CancelEdit - " +
this.custData.lastName);
       }
       Console.WriteLine("End CancelEdit");
   }

   void IEditableObject.EndEdit()
   {
       Console.WriteLine("Start EndEdit" + this.custData.id +
this.custData.lastName);
       if (inTxn)
       {
           backupData = new CustomerData();
           inTxn = false;
           Console.WriteLine("Done EndEdit - " + this.custData.id +
this.custData.lastName);
       }
       Console.WriteLine("End EndEdit");
   }

   public Customer(string ID) : base()
   {
       this.custData = new CustomerData();
       this.custData.id = ID;
       this.custData.firstName = "";
       this.custData.lastName = "";
   }

   public string ID
   {
       get
       {
           return this.custData.id;
       }
   }

   public string FirstName
   {
       get
       {
           return this.custData.firstName;
       }
       set
       {
           this.custData.firstName = value;
       }
   }

   public string LastName
   {
       get
       {
           return this.custData.lastName;
       }
       set
       {
           this.custData.lastName = value;
       }
   }

   internal CustomersList Parent
   {
       get
       {
           return parent;
       }
       set
       {
           parent = value ;
       }
   }

   private void OnCustomerChanged()
   {
       if (!inTxn && Parent != null)
       {
           Parent.CustomerChanged(this);
       }
   }

}

public class CustomersList :  CollectionBase, IBindingList
{
   private ListChangedEventArgs resetEvent = new
ListChangedEventArgs(ListChangedType.Reset, -1);
   private ListChangedEventHandler onListChanged;

   public void LoadCustomers()
   {
       IList l = (IList)this;
       l.Add(ReadCustomer1());
       l.Add(ReadCustomer2());
       OnListChanged(resetEvent);
   }

   public Customer this[int index]
   {
       get
       {
           return (Customer)(List[index]);
       }
       set
       {
           List[index] = value;
       }
   }

   public int Add (Customer value)
   {
       return List.Add(value);
   }

   public Customer AddNew()
   {
       return (Customer)((IBindingList)this).AddNew();
   }

   public void Remove (Customer value)
   {
       List.Remove(value);
   }

   protected virtual void OnListChanged(ListChangedEventArgs ev)
   {
       if (onListChanged != null)
       {
           onListChanged(this, ev);
       }
   }

   protected override void OnClear()
   {
       foreach (Customer c in List)
       {
           c.Parent = null;
       }
   }

   protected override void OnClearComplete()
   {
       OnListChanged(resetEvent);
   }

   protected override void OnInsertComplete(int index, object value)
   {
       Customer c = (Customer)value;
       c.Parent = this;
       OnListChanged(new
ListChangedEventArgs(ListChangedType.ItemAdded,
index));
   }

   protected override void OnRemoveComplete(int index, object value)
   {
       Customer c = (Customer)value;
       c.Parent = this;
       OnListChanged(new
ListChangedEventArgs(ListChangedType.ItemDeleted,
index));
   }

   protected override void OnSetComplete(int index, object oldValue,
object newValue)
   {
       if (oldValue != newValue)
       {

           Customer oldcust = (Customer)oldValue;
           Customer newcust = (Customer)newValue;

           oldcust.Parent = null;
           newcust.Parent = this;

           OnListChanged(new
ListChangedEventArgs(ListChangedType.ItemAdded, index));
       }
   }

   // Called by Customer when it changes.
   internal void CustomerChanged(Customer cust)
   {

       int index = List.IndexOf(cust);

       OnListChanged(new
ListChangedEventArgs(ListChangedType.ItemChanged,
index));
   }

   // Implements IBindingList.
   bool IBindingList.AllowEdit
   {
       get { return true ; }
   }

   bool IBindingList.AllowNew
   {
       get { return true ; }
   }

   bool IBindingList.AllowRemove
   {
       get { return true ; }
   }

   bool IBindingList.SupportsChangeNotification
   {
       get { return true ; }
   }

   bool IBindingList.SupportsSearching
   {
       get { return false ; }
   }

   bool IBindingList.SupportsSorting
   {
       get { return false ; }
   }

   // Events.
   public event ListChangedEventHandler ListChanged
   {
       add
       {
           onListChanged += value;
       }
       remove
       {
           onListChanged -= value;
       }
   }

   // Methods.
   object IBindingList.AddNew()
   {
       Customer c = new Customer(this.Count.ToString());
       List.Add(c);
       return c;
   }

   // Unsupported properties.
   bool IBindingList.IsSorted
   {
       get { throw new NotSupportedException(); }
   }

   ListSortDirection IBindingList.SortDirection
   {
       get { throw new NotSupportedException(); }
   }

   PropertyDescriptor IBindingList.SortProperty
   {
       get { throw new NotSupportedException(); }
   }

   // Unsupported Methods.
   void IBindingList.AddIndex(PropertyDescriptor property)
   {
       throw new NotSupportedException();
   }

   void IBindingList.ApplySort(PropertyDescriptor property,
ListSortDirection direction)
   {
       throw new NotSupportedException();
   }

   int IBindingList.Find(PropertyDescriptor property, object key)
   {
       throw new NotSupportedException();
   }

   void IBindingList.RemoveIndex(PropertyDescriptor property)
   {
       throw new NotSupportedException();
   }

   void IBindingList.RemoveSort()
   {
       throw new NotSupportedException();
   }

   // Worker functions to populate the list with data.
   private static Customer ReadCustomer1()
   {
       Customer cust = new Customer("536-45-1245");
       cust.FirstName = "Jo";
       cust.LastName = "Brown";
       return cust;
   }

   private static Customer ReadCustomer2()
   {
       Customer cust = new Customer("246-12-5645");
       cust.FirstName = "Robert";
       cust.LastName = "Brown";
       return cust;
   }

}