Implementing IList interface

Question

I am new to generics. I want to implement my own collection by deriving it from IList interface.

Can you please provide me some link to a class

Answer 1

In most cases you can simply use List<T> or derive from List<T>. If you derive from List<T> you will automatically get the implementation for Add and Remove.

Answer 2

Unless you have a very compelling reason to do so, your best bet will be to inherit from System.Collections.ObjectModel.Collection<T> since it has everything you need.

Please note that although implementors of IList<T> are not required to implement this[int] (indexer) to be O(1) (basically, constant-time access), it's strongly recommended you do so.

Answer 3

You can look at Mono project. There is available complete source codes, sou you can look how are some classes implemented. For example "System.Collections.Generics.List<T>".

Answer 4

In addition to deriving from List<T>, you can facade List<T> and add more features to your facade class.

class MyCollection<T> : IList<T>
{
    private readonly IList<T> _list = new List<T>();

    #region Implementation of IEnumerable

    public IEnumerator<T> GetEnumerator()
    {
        return _list.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion

    #region Implementation of ICollection<T>

    public void Add(T item)
    {
        _list.Add(item);
    }

    public void Clear()
    {
        _list.Clear();
    }

    public bool Contains(T item)
    {
        return _list.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _list.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        return _list.Remove(item);
    }

    public int Count
    {
        get { return _list.Count; }
    }

    public bool IsReadOnly
    {
        get { return _list.IsReadOnly; }
    }

    #endregion

    #region Implementation of IList<T>

    public int IndexOf(T item)
    {
        return _list.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        _list.Insert(index, item);
    }

    public void RemoveAt(int index)
    {
        _list.RemoveAt(index);
    }

    public T this[int index]
    {
        get { return _list[index]; }
        set { _list[index] = value; }
    }

    #endregion

    #region Your Added Stuff

    // Add new features to your collection.

    #endregion
}

Answer 5

Visual Studio offers an automatic full working implementation of interfaces like IList<>.

You need only to write something like this code:

public class MyCollection<T> : IList<T>
{
    // This line is important. Without it the auto implementation creates only
    // methods with "NotImplemented" exceptions
    readonly IList<T> _list = new List<T>();
}

(while the line

readonly IList<T> _list = new List<T>(); 

is the important one!)

Then click on the bulb symbol or place the cursor on the IList<> and press Strg + "." You will become several implementations offered, like:

Answer 6

Inheriting from List is often the quickest approach but can be limiting later on down the line if you need to inherit from another class (e.g. ContextBoundObject etc.). It's pretty quick to implement IList and as pointed out above, it gives a lot more flexibility.