Collection class keeps loosing its items when building

Question

I've built this custom control that has Items inside of it class HeaderItem : Component, INotifyPropertyChanged. The list where these items is a BindingList<HeaderItem>

I've been having this problem with my custom control lately, where everytime I build the project with the form designer, the control looses all its items but they stay in the form.designer.cs file.

Here's the most important code:

[DefaultEvent("SelectedIndexChanged"), DefaultProperty("Items")]
class Header : Control
{

    [field: NonSerialized]
    private BindingList<HeaderItem> _items = new BindingList<HeaderItem>();

    public Header()
    {
        _items.ListChanged += (sender, args) => 
        {
            if (SelectedIndex > Items.Count) SelectedIndex = Items.Count - 1;
            Invalidate();
        };
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public BindingList<HeaderItem> Items
    {
        get { return _items; }
    }

    [field: NonSerialized]
    public event EventHandler SelectedIndexChanged;

    protected virtual void OnSelectedIndexChanged()
    {
        EventHandler handler = SelectedIndexChanged;
        if (handler != null) handler(this, EventArgs.Empty);
    }

}

[DesignTimeVisible(false)]
class HeaderItem : Component, INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

Answer 1

The first problem is that you are telling VS not to serialize it when you use the .Hidden setting. Content indicates the property is an object and so the contents need to be serialized:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public BindingList<HeaderItem> Items
{
    get { return _items; }
}

Your original code was correct in omitting the setter¹. You probably do not want something changing or resetting the contents - you already have some liability for that by exposing a List object as a property rather than as a collection class¹. The VS serializer will not use or need the setter (nor will any Collection Editor), items are added using the Add/AddRange methods:

this.header1 = new WindowsFormsApplication1.Header();
this.headerItem1 = new WindowsFormsApplication1.HeaderItem();
this.headerItem2 = new WindowsFormsApplication1.HeaderItem();
...
this.header1.Items.Add(this.headerItem4);
this.header1.Items.Add(this.headerItem5);

Other Problems and Issues

It is hard to say for certain because the classes posted are clearly simplified for here. For instance, HeaderItem probably includes a propertyName property to save what it is watching. But tweaking it a bit to get it to compile, these issues emerge:

A. As noted, a List property type can be dangerous.

B. You probably need to may want to implement ShouldSerializexxx and Resetxxx. These are generally a good idea for this sort of thing.

C. Why does HeaderItem inherit from Component?

It doesnt seem like it needs to be a Component². I suspect you read somewhere that this was an easy way to let VS/Net create a unique name and serialize it for you without having to write a TypeConverter. That's largely true, but if you delete your Header control/object, the attendant HeaderItems will likely remain orphaned in the form designer:

' Note that there is no Header control/object to add these to
this.label1 = new System.Windows.Forms.Label();
this.headerItem1 = new WindowsFormsApplication1.HeaderItem();
this.headerItem2 = new WindowsFormsApplication1.HeaderItem();
this.SuspendLayout();

Normally, the user deletes Components from the form tray but yours are hidden. Unlike Components, collection class objects get removed from the designer when the control is removed. So, unless you really need some Component capability, consider changing it.

With simple properties and a parameterless ctor, you probably wont need a TypeConverter, maybe some Attributes. This near-clone has three string properties and does not rely on Component:

(Click for larger image)
Beforehand, it displays the simple TypeName (or it could be something static like NewHeaderItem), then once the property is set, the Name displays.

This CodeProject article might seem unrelated, but has some good starting stuff relating to Collections, TypeConverters, Designer Serialization and the like. The Code is in VB, but the concepts should be clear enough. Disclaimer: I wrote the article.

¹ _{See MSDN Guidelines for Collections.}
² _{Based on whats there.}

Answer 2

Try changing your code as follows:

    [DefaultEvent( "SelectedIndexChanged" ), DefaultProperty( "Items" )]
    class Header : Control
    {
        ...

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public BindingList<HeaderItem> Items
        {
            get { return _items; }
            set { _items = value; }
        }

       ...
}