Cannot implicitly convert List<T> to Collection<T>

Valentin_Vasiliev_430254 0
Viewed 107083

This is a compiler error (slightly changed for readability).

This one always puzzled me. FxCop tells that this is a bad thing to return List<T> and classes that are derived from Collection<T> should be preferable as return types.

Also, FxCop says that it is OK to use List<T> for internal data storage/manipulation. Ok, I get it, but what I don't get is why the compiler complains about trying to implicitly convert List<T> to Collection<T>. Isn't List<T> more interface-charged and functional? Why prohibit implicit conversion?

And another question that stems from above: is the new List<int>(some collection<int>) constructor expensive?

collections generics c#
7 Answers

List<T> doesn't derive from Collection<T> - it does, however, implement ICollection<T>. That would be a better choice of return type.

As for the new List<int>(some collection<int>) question - it partly depends on what the collection is. If it implements ICollection<T> (at execution time) then the constructor can use its Count property to create the list with the right initial capacity before iterating through it and adding each item. If it doesn't implement ICollection<T> then it's just equivalent to:

List<int> list = new List<int>();
foreach (int x in otherCollection)
{
    list.Add(x);
}

Still nice to have in a convenient constructor, but not hugely efficient - it can't be, really.

I don't believe the constructor does anything cunning for arrays, which it potentially could - using Array.Copy or whatever to just copy the lot in one go rather than iterating though. (Likewise if it were another List<T> it could get at the backing array and copy that directly.)

user_226560

List<T> doesn't inherit from Collection<T>. Plain and simple. Unless List<T> provides an operator to implicitly convert to/from Collection<T>, you can't do it. I would actually suggest returning List<T> if you can, as I believe the rules go something like this:

Accept as a parameter the least constrictive interface possible. Return as a return parameter the most constrictive type possible.

user_459160

Here is a generic extension method written in C# 3.0 used to convert List<T> to Collection<T>

using System.Collections.Generic;
using System.Collections.ObjectModel;

public static class ExtensionMethods
{
    public static Collection<T> ToCollection<T>(this List<T> items)
    {
        Collection<T> collection = new Collection<T>();

        for (int i = 0; i < items.Count; i++)
        {
            collection.Add(items[i]);
        }

        return collection;
    }
}

and it is used like this…

List<string> entities = new List<string>();
entities.Add("Value 1");
entities.Add("Value 2");
entities.Add("Value 3");
entities.Add("Value 4");

Collection<string> convertedEntities = entities.ToCollection<string>();
Admin1

The other way around, it is not necessary to loop... you can make just .ToList()

    ICollection<T> collection = new Collection<T>();

fill your collection using any method, and when you need the list, just do this:

    List<T> list = collection.ToList();

after that you can use whatever you want with your list.

Have a good coding!

user_93668470
Related