Casting an object to a base collection

I'm not totally convinced this is possible, but here goes. I have a method returning an object, although the actual type is Collection. Now, I can easily cast the object into the collection using

var myCollection = myObject as Collection<MyClassA>;

However the problem I have is that Collection<MyClassA> could alternatively be Collection<MyClassB> or Collection<MyClassC>. All of these MyClassX's are inherited from MyBaseClass, so ideally I would like to be able to do something like

var myCollection = myObject as Collection<MyBaseClass>;

However this throws an exception when casting. Is it possible to do this in anyway? I understand that it may be within .Net 4?

Thanks for the help.

EDIT: OK - The answers so far 开发者_StackOverflow社区are very useful, however they only solve the second part of the solution - converting/casting collections.

I am still unsure as to how I should initially cast the object to a collection (without the use of a huge if statement for each of the possible types)

This is only supported with IEnumerable<T> in .NET 4. Check out the difference in the signatures:

IEnumerable<T>:

public interface IEnumerable<out T> : IEnumerable

Collection<T>:

public class Collection<T> : IList<T>, 
ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

That out keyword in the type parameter is what tells .NET to support variance.

Before I had access to .NET 4 I wrote an extension method that achieved this:

public static IEnumerable<U> CastCollection<T, U>(this IList<T> items) where U : class
{
   var collection = new List<U>();
   foreach (var item in items)
   {
      if (item is U)
      {
           var newItem = item as U;
           collection.Add(newItem);
      }
  }
  return collection;
}

You would use it like this:

var myCollection = myObject.CastCollection<MyClassA, MyBaseClass>();

myCollection will be an IEnumerable<MyBaseClass> in this case.

Alternate solution: you could use interfaces and generics to get what you want.

public interface IMyClass
{
}

public class MyClassA : IMyClass
{
}

public class MyClassB : IMyClass
{
}

public class MyClassC : IMyClass
{
}

static void Main(string[] args)
{
    var listA = new List<IMyClass>{new MyClassA{}, new MyClassA{}};
    var listB = new List<IMyClass> { new MyClassB { }, new MyClassB { } };
    var listC = new List<IMyClass> { new MyClassC { }, new MyClassC { } };

    List<IMyClass> genericList = listA.Cast<IMyClass>().ToList();
}

Something like this will compile properly and also allow you to assign different lists of any types that implement the common interface, to the same variable (in this case genericList.

This cannot be done by casting the collection as a whole. However, you can cast the individual elements to a new collection. Look at LINQ's Cast<> extension method.