gistfile1.cs

public interface IFoo<T>
{}

public class SimpleFoo<T>: IFoo<T>
{}

public class StructOnlyFoo<T>: IFoo<T> where T : struct
{}

public class FooWithBar<T>:IFoo<T>
{
   public FooWithBar(IBar<T> bar){}
}

public interface IBar<T>
{}

public class DefaultCtorBar<T>: IBar<T> where T: new()
{}

// now you register all those classes in the container as their respective interfaces, in open generic version
// and then call container.ResolveAll<IFoo<String>>(); // notice string is not a struct and does not have public parameterless constructor
//
// what should happen ?

Without having pondered this extensively, I'd expect an exception to be thrown. I'd expect ResolveAll<IFoo<string>> to return instances of SimpleFoo<string> and FooWithBar<string> - however FooWithBar<string> is waiting for dependencies to be satisfied, as there are no registrations of IBar<string>.

Code should explode so guy who made this code will get as much damage as possible.
1.StructOnlyFoo should not return of course, this is silently.
2.FooWithBar could be return, so Windsor should cry with as much details as you have, because this will be really hard to find an issue like this.

So as results ResolveAll should throw an exception.

Seems we can only create SimpleFoo<T> as FooWithBar<T> is depending an IBar<T> and DefaultCtorBar<T> can not be used for strings (no public ctor) and StructOnlyFoo is also out of question for strings. What I expect would be an exception though (unless all IFoo<T> implementations can be resolved successfully using ResolveAll). Given there is a Resolve<IFoo<string>> which returns just one implementation and there is one implementation that can be constructed, I expect it to return SimpleFoo<string> instead of throwing exceptions.