IEnumerable<T1> data = [some query];
// convert to baseclass T2
IEnumberable <T2> converted = data.Cast<T2>();

[)amien

public IEnumerable<TBase> As<TBase, TDerived>(IEnumerable<TDerived> items) {
   foreach(TDerived derived in items) yield return derived;
}

You can use it like this:

IEnumerable<Square> squares = ...;
IEnumerable<Shape> shapes = As<Shape, Square>(squares);

Simple, easy, and clean. Thank you, C# yield iterators. :-)

My point is that I question the need for IEnumerable<Derived>, period. If Derived really is-a Base, and holding a collection of Base is useful, you should not need to cast it to a collection of Derived, unless your interfaces are written in a restrictive way that requires that, at which point I question the interface design, not the language feature.

I’ve been using C++ with templates (generics) for 10 years with hierarchies of objects in base-type containers and have never once needed to do this kind of conversion, because polymorphism occurs on the contained types alone.

With this solution he can now pass objects that implement this technique to methods that take an IEnumerable<Base> like this:

Foo(list.BaseClasses);

It doesn’t really have anything to do with casting or loops/iterators.

Basically if generalising the collection contents is useful, then the processing abstraction given to you by the visitor pattern must also be useful – unless you’ve used a base class collection for the wrong reason of course. IMO, when you hit these kinds of problems your first thought should be about the the appropriateness of the design, not a language feature.

Surely you can just use a container using instances of the base type, iterate using that, and make your polymorphism kick in for each instance of the type? We have this situation all the time with C++/STL and it’s never a problem:

std::list<BaseType*> baseTypeList;
std::list<BaseType*>::iterator i  = baseTypeList.begin();

BaseType* baseType = *i;
// virtual methods on object itself
baseType->somePolymorphicMethod();
// polymorphic non-member functions
somePolymorphicFunction(baseType);

You should never need to cast the container itself, all that matters is maintaining polymorphism on the elements it contains. I think the fact that C# makes / encourages you define a subtype rather than thinking of a generic usage like a typedef (type alias) makes you think you have to make your methods polymorphic on the container, which you do not.