Convert IList<T1> to IList<BaseT1>

As the easiest way to convert the IList<T1> to IList<BaseT1>?

IList<T1>.Count() is very large number!!!

class BaseT1 { };
class T1 : BaseT1
{
    static public IList<BaseT1> convert(IList<T1> p)
    {
        IList<BaseT1> result = new List<BaseT1>();
        f开发者_运维技巧oreach (BaseT1 baseT1 in p)
            result.Add(baseT1);
        return result;
    }
}

You'll get much better performance in your implementation if you specify the size of the result list when it is initalized, and call the Add method on List<T> directly:

List<BaseT1> result = new List<BaseT1>(p.Count);

that way, it isn't resizing lots of arrays when new items get added. That should yield an order-of-magnitude speedup.

Alternatively, you could code a wrapper class that implements IList<BaseT1> and takes an IList<T1> in the constructor.

linq?

var baseList = derivedList.Cast<TBase>();

Edit:

Cast returns an IEnumerable, do you need it in a List? List can be an expensive class to deal with

IList<T1>.Count() is very large number!!!

Yes, which means that no matter what syntax sugar you use, the conversion is going to require O(n) time and O(n) storage. You cannot cast the list to avoid re-creating it. If that was possible, client code could add an element of BaseT1 to the list, violating the promise that list only contains objects that are compatible with T1.

The only way to get ahead is to return an interface type that cannot change the list. Which would be IEnumerable<BaseT1> in this case. Allowing you to iterate the list, nothing else. That conversion is automatic in .NET 4.0 thanks to its support for covariance. You'll have to write a little glue code in earlier versions:

    public static IEnumerable<BaseT1> enumerate(IList<T1> p) {
        foreach (BaseT1 item in p) yield return item;
    }