Casting of Generic List to a Class derived from a List

Question

I created a class derived from List. However when I tried casting the class to another List object I get a runtime error. My code is similar to the one posted below:

public class CategoryObj
{
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }
    public string Description { get; set; }
}

public class CategoryObjCollection:List<CategoryObj>
{

}

public void Test()
{
        CategoryObjCollection cat = new CategoryObjCollection();
        using (NWDataContext db = new NWDataContext())
        {
            var qry = (from c in db.Categories
                       select new CategoryObj
                       {
                           CategoryID = c.CategoryID,
                           CategoryName = c.CategoryName,
                           Description = c.Description
                       }).ToList();
            cat = (CategoryObjCollection)qry; //runtime error Unable to cast object of type 'System.Collections.Generic.List`1[WindowsFormsApplication1.CategoryObj]' to type 'WindowsFormsApplication1.CategoryObjCollection'.
        }
}

I hope someone can help me on this. Thanks.

Answer 1

Why would you expect to be able to cast? The object isn't an instance of CategoryObjCollection. The point of reference type casts (when they're actually casting rather than invoking explicit conversions) is to tell the compiler that you believe the execution time type of the object is actually compatible with the type you specify, so that you can use members of that specific type (after the execution time test). In this case, the ToList extension method just creates a new List<T>.

More to the point, what is your CategoryObjCollection type meant to achieve in the first place? If it has any state other than the normal list, where would you expect that state to come from after your LINQ query? If it doesn't have any other state, is it really adding any benefit? Maybe your type should actually contain a list rather than deriving from it? Then you could create a new instance of the type using the results of the query.

In general, it's usually a design smell to derive from List<T>. It doesn't provide many ways to specialize its "listiness" (unlike, say, Collection<T>). It's usually a sign that you should be thinking of composition instead of inheritance.