Cannot convert expanded class to IList

Question

Given the following classes:

public class MyList<T> : IList<T>, ICloneable
{ ... }

public class PinList : MyList<SomeClass>, ICloneable, IEquatable<PinList>
{ ... }

Why wont this work?

public void Main()
{
    PinList pins = new PinList();
    Method2(pins); // Does not work

    List<string> strings = new List<string>();
    Method2(strings); // WORKS
}

public void Method2(object obj)
{
    // returns TRUE
    obj.GetType().GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IList<>)); 

    var things = ((IList)obj).Cast<object>().ToList();
    // Unable to cast object of type 'PinList' to type 'System.Collections.IList'.
}

I've tried hard casting the obj to obj.GetType(), and I've looked on google to no avail.

Note that you could cast to `IEnumerable` if you're just trying to call `Cast` on `obj`, but I don't see the purpose in what you're doing. — D Stanley, Dec 22 '16 at 21:03
Please check my answer, maybe you're wasting your time using custom lists while you might be able to stay with out-of-the-box collections. — Matías Fidemraizer, Dec 22 '16 at 21:07

score 3 · Answer 1 · answered Dec 22 '16 at 20:57

3

The class implements IList<T>, not IList. If you want it to implement IList you'll need to add it to the class's definition, and add appropriate methods for the various methods of that interface.

answered Dec 22 '16 at 20:57

Servy

202,030
26
332
449

Heinzi · Accepted Answer · 2016-12-22T21:03:30.843

It won't work, because your class does not implement IList.

It directly implements IList<SomeClass>, ICloneable and IEquatable<PinList>.
It indirectly (via IList<SomeClass>) implements ICollection<SomeClass>, IEnumerable<SomeClass> and IEnumerable.

One might expect IList<T> to implement IList, but this is not the case. If you think about it, this makes sense: IList guarantees that arbitrary objects can be added to the list. An IList<T>, however, only allows objects of type T or a subtype thereof to be added. Thus, if IList<T> implemented IList, the Liskov substitution principle would be violated.

You don't have this problem with IEnumerable, since there's no way to add items to an IEnumerable. Thus, IEnumerable<T> satisfies all contracts that IEnumerable satisfies, and, hence, IEnumerable<T> implements IEnumerable.

Must be why List works and my class doesn't! Ug, thanks!! – Tizz Dec 22 '16 at 21:02 — Tizz, Dec 22 '16 at 21:02

score 1 · Answer 3 · edited May 23 '17 at 11:59

Just a hint:

public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable

While List<T>:

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, 
    IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>

I see IList implemented on List<T> but IList<T> doesn't also implement IList!

???

See your custom list derived class signature:

public class PinList : MyList<SomeClass>, ICloneable, IEquatable<PinList>

I got a surprise when I saw IEquatable<PinList>. Are you trying to implement a custom list just because you want to be able to detemine if two given lists of type PinList have the same items?

HashSet<T> to the rescue! See this other Q&A: Check if two list have the same items

And...

Perhaps you're also implementing a custom list just because you want to be able to make it cloneable, and I would say that it's a bad design decision.

If you need to just clone the list and not its items, list.ToList() is enough.
If you need to clone the list and its items should be also cloned: list.Select(o => (SomeType)o.Clone()).ToList(). Obviously stored objects should implement ICloneable. In the other hand, if you thought that you don't want to repeat yourself, you could use an extension method:

public static class ListExtensions
{
      public static IList<T> CloneList<T>(this IList<T> source)
           where T : ICloneable
           => source.Select(o => (T)o.Clone()).ToList(); 
}

...and call it wherever you want: list.CloneList().

So... No need to implement IList<T> or derive List<T> anymore!

Wow thanks. I will have to look to see if this will affect a lot of code and worth the effort to change it. (Working from an inherited code base) — Tizz, Dec 22 '16 at 21:33
Yea well, nothing I can do right now. ... So how would I get that cast to work if I cant change from IList<>? Tried (cellVal as IList).Cast — Tizz, Dec 22 '16 at 21:49
Yes, I got it: dynamic convertedIList = Convert.ChangeType(obj, obj.GetType()); Now I can iterate through each item and create a List — Tizz, Dec 22 '16 at 23:10
@Tizz But if you use dynamic typing, you don't need to change the type anymore! :D — Matías Fidemraizer, Dec 23 '16 at 07:11

score 1 · Answer 4 · answered Dec 22 '16 at 21:09

You PinList implements IList<T>, but you are trying to cast obj to IList.

IList<T> and IList are 2 different interfaces.

Change your class to

public class MyList<T> : IList, ICloneable
{ ... }

you'll be able to get obj converted to IList.

When converting, you do not need this long statement

 var things = ((IList)obj).Cast<object>().ToList();

Just

IList things = (IList)obj;

or

IList things = obj as IList;

will do your job. First one will throw exception if obj is not convertible to IList while the 2nd one just return null.

Cannot convert expanded class to IList

4 Answers4

???

And...