I have recently been playing with IExtenderProvider trying to implement a
Collection Property and came upon this curious scenario:

If I set up a property to return a Componet Array the code is correctly
serialized as follows:
\\\
this.foo1.SetBar(this.button1, new FooBarExtension.FooBar[] {
                this.fooBar1});
///

If, however, I change the return type to a Collection the property is
incorrectly serialized like this:
\\\
this.button1.BarCollection.AddRange(new FooBarExtension.FooBar[]{
                this.fooBar2});
///

Manually correcting it as follows has the desired effect:
\\\
this.foo1.SetBarCollection(this.button1,
   new FooBarExtension.FooBarCollection(new FooBarExtension.FooBar[]
                {this.fooBar2}));
///
... but if I then change the items it is once again serialized incorrectly.

Can anyone offer an explanation of this as it has been driving me nuts?

The code used in this test follows:
\\\
using System.Windows.Forms;
using System.Globalization;
using System.Reflection;
using System.ComponentModel.Design.Serialization;

namespace FooBarExtension
{
   [ProvideProperty("Bar",typeof(Control))]
   [ProvideProperty("BarCollection",typeof(Control))]
   public class Foo : System.ComponentModel.Component, IExtenderProvider
   {
       private System.ComponentModel.Container components = null;
       public Foo(System.ComponentModel.IContainer container)
       {
           container.Add(this);
           InitializeComponent();
       }
       public Foo()
       {
           InitializeComponent();
       }
       protected override void Dispose( bool disposing )
       {
           if( disposing )
           {
               if(components != null)
               {
                   components.Dispose();
               }
           }
           base.Dispose( disposing );
       }
       #region Component Designer generated code
       private void InitializeComponent()
       {
           components = new System.ComponentModel.Container();
       }
       #endregion
       bool IExtenderProvider.CanExtend(object extendee)
       {
           return extendee is Control;
       }
       private Hashtable bar = new Hashtable();
       private Hashtable barCollection = new Hashtable();
       public FooBar[] GetBar(object extendee)
       {
           if (bar.Contains(extendee))
               return (FooBar[])bar[extendee];
           return new FooBar[]{};
       }
       public void SetBar(object extendee, FooBar[] value)
       {
           if (bar.Contains(extendee))
               bar.Remove(extendee);
           bar.Add(extendee, value);
       }
       [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
       public FooBarCollection GetBarCollection(object extendee)
       {
           if (barCollection.Contains(extendee))
               return (FooBarCollection)barCollection[extendee];
           FooBarCollection fbc = new FooBarCollection();
           barCollection.Add(extendee, fbc);
           return fbc;
       }
       public void SetBarCollection(object extendee, FooBarCollection
value)
       {
           if (barCollection.Contains(extendee))
               barCollection.Remove(extendee);
           barCollection.Add(extendee, value);
       }
   }

   [DesignTimeVisible(false)]
   public class FooBar : Component
   {
       public FooBar(){}
       public FooBar(string text) : this()
       {
           this.text=text;
       }
       private string text = "";
       public string Text
       {
           get{return this.text;}
           set{this.text = value;}
       }
       public bool ShouldSerializeText()
       {
           return this.text != "";
       }
   }

   public class FooBarCollection : CollectionBase
   {
       public FooBarCollection() : base(){}
       public FooBarCollection(FooBar[] items) : this()
       {
           this.InnerList.AddRange(items);
       }
       public int Add(FooBar item)
       {
           return this.InnerList.Add(item);
       }
       public void AddRange(FooBar[] items)
       {
           this.InnerList.AddRange(items);
       }
       public void AddRange(FooBarCollection items)
       {
           this.InnerList.AddRange(items);
       }
       public void Remove(FooBar item)
       {
           this.InnerList.Remove(item);
       }
       public FooBar this[int index]
       {
           get{return this[index];}
       }
   }
}
///