How to convert IList to List in C# with good performance and concisely?

Question

Despite there are some information in answers to these questions: Cast IList to List and Performance impact when calling ToList() they do not answer my specific question. I have a class that is a wrapper around List. This class was designed to be sent via WCF services and implements some additional functionality.

[DataContract]
public class DataContractList<T> : IList<T>
{
    [DataMember]
    protected readonly List<T> InnerList;

    public DataContractList()
    {
        InnerList = new List<T>();
    }

    public DataContractList(IList<T> items)
    {
        InnerList = items as List<T> ?? items.ToList(); //Question is about this line.
    }
}

So there is a constructor that accepts an IList<T> interface (in order to encourage programming to interface). I need to convert this IList<T> interface to List<T> class. I can use .ToList() extension method which internally creates a new instance of List<T> by passing IEnumrable "this" argument to it's constructor (see here). Generic List<T> constructor just iterates through this enumberable. So I would like to prevent this iteration if it's not necessary (in case inner items parameter is already a List<T>). So, is it an optimal way (in terms of performance and readability) to do this: InnerList = items as List<T> ?? items.ToList();? If no, please provide with details about better way and why.

Answer 1

To try to avoid iterating the list is a good intention, but there is more to consider.

You have protected the InnerList propety from public access, if you just assign the list to that property then that effort is pointless. If I send a list into the constructor and keep a reference to that list, then I have a reference to the list that the class uses internally:

List<sting> list = new List<string>();
var dc = new DataContractList(list);

// now I can manipulate the internal list:
list.Add("Woaaah! Where did that come from?");

To keep the internal list internal, you would always create a new list even if the input is a list:

public DataContractList(IList<T> items)
{
    InnerList = new List<T>(items);
}

Answer 2

You noticed that the WCF default serialisation doesn't work with arbitrary IList<T> implementations. That's good.

You then decide to solve that by forcing the use of List<T>. That's not so good.

Don't use the default serialisation if it doesn't do what you want. Use custom serialisation. You can make your class serialise item by item if you know that that's what you want to do, even if the inner container doesn't know about it.

And to answer your likely follow-up question: a quick search shows the basic approach of how to do that right here on Stack Overflow: How to use Custom Serialization or Deserialization in WCF to force a new instance on every property of a datacontact ?

Answer 3

Just to complete Guffa's answer. As you mentioned, using

InnerList = new List<T>(items);

or

InnerList = items.ToList();

is basically one and the same, so I would prefer the later from readability point of view.

However, the following

Generic List constructor just iterates through this enumberable.

is not true, as you may see here http://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,d2ac2c19c9cf1d44, which in turn is using http://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,0c418e0fac68ada2 when the argument is of type List<T>. Shortly, you should not be concerned about performance.

Answer 4

IMHO, if you inherit from IList<T> and then force using List<T>, it defeats the purpose, doesn't it?

The idea of using an interface is to support different classes where only the shared functionality matters.

In your case, your DataContractList class accepts any class that implements IList<T>, however if I create a class that implements IList<T> but cannot be converted to List<T>, I will get a run-time error, won't I?

I'd suggest that you inherit from List<T> if your DataContractList class can only support that implementation of the interface.

Alternatively, if your DataContractList class can really support any implementation of IList<T>, then change it to:

[DataContract]
public class DataContractList<T> : IList<T>
{
    [DataMember]
    protected readonly IList<T> InnerList;

    public DataContractList()
    {
        InnerList = new List<T>();
    }

    public DataContractList(IList<T> items)
    {
        InnerList = items;
    }
}