how List<T> does not implement Add(object value)?

Question

I believe it's pretty stupid, and I am a bit embarrassed to ask this kind of question, but I still could not find the answer:

I am looking at the class List<T> , which implemetns IList.

public class List<T> : IList

one of the methods included in Ilist is

int Add(object value)

I understand that List<T> should not expose that method (type safety...), and it really does not. But how can it be? mustnt class implement the entire interface?

Ametropia

I'm not sure what you mean by not exposing it, interfaces can only have public members. – Aude

@Brad: List<T> is not an interface, and he's saying that List<T> should not expose it. – Ogburn

It is called "Explicit interface implementation". – Pyroxylin

Ahh, coffee deprivation; I understand the question now, it's what happens when you skim between sips. Also why I posted a comment not an answer. ;p – Aude

Answer 1

I believe that this (interface) method is implemented explicitly:

public class List<T> : IList
{
     int IList.Add( object value ) {this.Add((T)value);}
}

By doing so, the Add( object ) method will by hidden. You'll only able to call it, if you cast the List<T> instance back to an IList instance.

Prestigious

You're right about the explicit implementation. But you should fix your example ("recursion" and "can't compile" keep popping up in my mind)... :) – Lofton

Answer 2

A quick trip to reflector shows that IList.Add is implemented like this:

int IList.Add(object item)
{
    ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(item, ExceptionArgument.item);
    try
    {
        this.Add((T) item);
    }
    catch (InvalidCastException)
    {
        ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));
    }
    return (this.Count - 1);
}

In other words, the implementation casts it to T to make it work and fails it you pass a non T compatible type in.

Babs

The information is correct, but it doesn't answer the question. – Viper

Sure it does. IList.Add does a cast and calls the IList<T>.Add implementation. – Babs

Answer 3

List<T> explicitly implements IList.Add(object value) which is why it's not typically visible. You can test by doing the following:

IList list = new List<string>();
list.Add(new SqlDataReader()); // valid at compile time, will fail at runtime

Primogeniture

Answer 4

It implements it explicitly, so you have to cast to IList first to use it.

List<int> l = new List<int>();
IList il = (IList)l;
il.Add(something);

Hobgoblin

Answer 5

You can call it be casting your list instance to the interface first:

List<int> lst = new List<int>();
((IList)lst).Add("banana");

And you'll get as nice, runtime, ArgumentException.

Emotionalize

Answer 6

Frederik is right that List<T>'s implementation of IList is explicit for certain members, particularly those that pose a threat to type safety.

The implementation he suggests in his answer can't be right, of course, since it wouldn't compile.

In cases like this, the typical approach is to make a valiant effort to try to get the interface member to work, but to give up if it's impossible.

Note that the IList.Add method is defined to return:

The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection.

So in fact, a full implementation is possible:

int IList.Add(object value)
{
    if (value is T)
    {
        Add((T)value);
        return Count - 1;
    }

    return -1;
}

This is just a guess, of course. (If you really want to know for sure, you can always use Reflector.) It may be slightly different; for example it could throw a NotSupportedException, which is often done for incomplete interface implementations such as ReadOnlyCollection<T>'s implementation of IList<T>. But since the above meets the documented requirements of IList.Add, I suspect it's close to the real thing.

Ferrante

The actual implementation (at least in .NET4) throws an ArgumentException if you attempt to add an item of the wrong type. (And, if I recall correctly, there was a small bug prior to .NET4 where trying to add null to a List<Nullable<T>> via IList.Add would also erroneously throw the exception.) – Engaging