How to create a custom collection in .NET 2.0

Question

Hi I want to create my custom collection, I am deriving my custom collection class from CollectionBase class as below:

public class MyCollection : System.Collectio.CollectionBase
{
    MyCollection(){}
    public void Add(MyClass item)
    {
        this.List.Add(item);
    }
}

class MyClass
{
    public string name;
}

Let me ask a few questions:

1. Whether this approach is correct and new, as I working on .NET 3.5 framework.
2. I want to expose this collection from my web service ( WCF) .How can I do that?
3. Do I have to implement GetEnumerator?
4. Whether this will Bind to DataGridView.

Answer 1

I think you would be better off using one of the container classes defined in System.Collections.Generic

1. Whether this approach is correct and new, as I working on .NET 3.5 framework.
   
   • No. Use List or something instead.
2. I want to expose this collection from my web service ( WCF) .How can I do that?
   
   • pass. haven't used WCF.
3. Do I have to implement GetEnumerator?
   
   • not if you use one of the standard System.Collections.Generic container classes. It's already done for you
4. Whether this will Bind to DataGridView.
   • Any of the standard collections that support IEnumerable will bind to controls pretty well. You could look at using IBindingListView if you want sorting and filtering.

Answer 2

Why not using a generic collection?

using System;
using System.Collections.Generic;

namespace Test {
    class MyClass { 
    }
    class Program {
        static void Main(string[] args) {
            // this is a specialized collection
            List<MyClass> list = new List<MyClass>();
            // add elements of type 'MyClass'
            list.Add(new MyClass());
            // iterate
            foreach (MyClass m in list) { 
            }
        }
    }
}

EDIT: Ashu, if you want to do some validation on Add and Remove operations you could use a generic collection as member of your specialized collection:

using System;
using System.Collections.Generic;
namespace Test {
    class MyClass { 
    }
    class MyClassList {
        protected List<MyClass> _list = new List<MyClass>();
        public void Add(MyClass m) { 
            // your validation here...
            _list.Add(m);
        }
        public void Remove(MyClass m) {
            // your validation here...
            _list.Remove(m);
        }
        public IEnumerator<MyClass> GetEnumerator() {
            return _list.GetEnumerator();
        }
    }
    class Program {
        static void Main(string[] args) {
            MyClassList l = new MyClassList();
            l.Add(new MyClass());
            // iterate
            foreach (MyClass m in l) { 
            }
        }
    }
}

Answer 3

If you want your own collection class you can also inherit from a generic collection to a non-generic class, eg:

public class MyCollection : List<MyClass>
{

}

This way you get all the functionality of a list (for example). You just need to add a few constructors.

Answer 4

Deriving from List<T> is somewhat pointless, especially now that it has the IEnumerable<T> constructor and the availability of extension methods. It has no virtual methods that you can override except Equals, GetHashCode, and ToString. (I suppose you could derive from List<T> if your goal was to implement Java's toString() functionality for lists.)

If you want to create your own strongly-typed collection class and possibly customize the collection behavior when items are add/removed, you want to derive from the new (to .NET 2.0) type System.Collections.ObjectModel.Collection<T>, which has protected virtual methods including InsertItem and RemoveItem that you can override to perform actions at those times. Be sure to read the documentation - this is a very easy class to derive from but you have to realize the difference between the public/non-virtual and protected/virtual methods. :)

public class MyCollection : Collection<int>
{
    public MyCollection()
    {
    }

    public MyCollection(IList<int> list)
        : base(list)
    {
    }

    protected override void ClearItems()
    {
        // TODO: validate here if necessary
        bool canClearItems = ...;
        if (!canClearItems)
            throw new InvalidOperationException("The collection cannot be cleared while _____.");

        base.ClearItems();
    }

    protected override void RemoveItem(int index)
    {
        // TODO: validate here if necessary
        bool canRemoveItem = ...;
        if (!canRemoveItem)
            throw new InvalidOperationException("The item cannot be removed while _____.");

        base.RemoveItem(index);
    }
}

Answer 5

Maybe I'm missing something here, but if you just need to add validations why don't you inherit from a generic collection and override the New() Remove() or any other method.

class CustomeCollection<T> : List<T>
{
    public new void Add(T item)
    {
        //Validate Here
        base.Add(item);
    }

    public new void Remove(T item)
    {
        //Validate Here
        base.Remove(item);
    }

}