Question

How can I implement an easier solution, I’m looking for a better approach instead having to create a complex implementation class, appreciate some advice.

Current I’m doing the following:

public interface IAddressCollection : IList<IAddress>
{
      new void Add(IAddress address);    
}

so then I’ve got to implement everything something like the below the code. I want to avoid doing this, I’m looking for a simple way.

public class AddressCollection : IAddressCollection
{
    private List<IAddress> _data = new List<IAddress>();

    new public void Add(IAddress applicationAddress)
    {
        // some logic here... e.g.
        if (!this.Any(x => x.AddressType != applicationAddress.AddressType))
        {
            _data.Add(applicationAddress);
        }
    }
    // Plus all the members of IList

EDIT******

How can I avoid implementing all IList members, and still have a base interface which implements a collection?

Furthermore how can u get 5 votes for “What’s the question exactly?” seriously, if he gave me a half decent answer I’d give him/she a vote but not for question to a question.

Answer 1

The most common approach would be to derive from Collection<T>:

public class AddressCollection : Collection<IAddress>, IAddressCollection
{
    public AddressCollection() : base(new List<IAddress>())
    {
    }
}

Collection<T> implements IList<T>.

UPDATE in response to comments.

If you want to implement custom logic when adding or removing items, it’s better to override one or more of the protected virtual methods InsertItem, SetItem, RemoveItem and ClearItems, rather than implementing a new Add method.

InsertItem is called whenever the public Add or Insert method is called to add an element to the list. Similarly SetItem is called when an element is replaced (myCollection[index] = newValue), RemoveItem is called when the public Remove method is called and ClearItems when the public Clear method is called.

By doing this you will address the concern raised by Florian Greinacher in the comments – your custom logic will always be executed even if the list is used polymorphically as an IList<IAddress> or Collection<IAddress>

For example, to match your sample, you could ignore inserting / setting items that don’t match a predicate with code something like the following (untested):

protected override void InsertItem(int index, IAddress newItem)
{
    if (!this.Any(x => x.AddressType != newItem.AddressType)
    {
        base.InsertItem(index, newItem);
    }
    else
    {
        // ... item does not match, do whatever is appropriate e.g. throw an exception
    }
}

protected override void SetItem(int index, IAddress newItem)
{
    ... etc ...
}