Why doesn't Unity support explicitly implemented interfaces

When programming against an interface I prefer to implement the interfaces explicitly. The result is that the methods and properties are only available through the interface:

IFoo foo = new Foo() // where Foo implements IFoo explicitly.

In my opinion this is better a design than implementing the interfaces implicitly. This is what i call class automation (you generate proeprties and method skeletons via the Visual Studio IDE).

But I came to the conclusion that explicit implementation and dependency injection does not work. This makes Unity in my opinion useless (at least for property injection). I am not going to change my opinion on design principles because some framework dictates
me tot do so.

My question is: is there a way to use explicitly implemented interfaces with Unity.

Like Chris I am confused as to why you think Unity doesn't work with explicit interface implementations. I agree with you completely on the principle and am using Unity with explicit interfaces to great effect. In fact, this is precisely why I requested
that Unity support metamappings--so that the same class can implement multiple interfaces explicitly and have several interface mappings to the same concrete type. The only difficulty with the current Unity implementation is you have to define a separate mapping
for each interface. That's a maintenance issue, though, not a show-stopper.