For LoadAssemblyFrom, why use an error-prone string not an Assembly object – e.g. LoadAssemblyFrom(typeof(ISomeService).Assembly)
?

Is this the simplest way to register all objects in an assembly as their implemented interfaces?

container.ConfigureAutoRegistration().

LoadAssemblyFrom("AutoregisteredClasses.dll").

Include(t => true,

Then.Register().AsAllInterfacesOfType()).

ApplyAutoRegistration();

Why does this registration take about 9 second to run? The target assembly only contains 10 types and is 5kb in size.

Difference between AsSingleInterfaceOfType, AsFirstInterfaceOfType and AsAllInterfacesOfType is easy to explain using following example: say you have a Logger class that implements ILogger interface and IConfigurable interface. AsSingleInterfaceOfType will
throw an exception when trying to register the class because it expects types to implement single interface. AsFirstInterfaceOfType will register Logger as ILogger, but not as IConfigurable. AsAllInterfacesOfType will register logger as both ILogger
and IConfigurable so that Logger instance will be returned when calling Resolve<ILogger>() and Resolve<IConfigurable>().

For LoadAssemblyFrom string is used because as method states assembly gets loaded into current app domain (using Assembly.LoadFrom). Using typeof(ISomeService).Assembly would means that assebly of type ISomeService is already loaded (as we've referenced
its type) and doesn't need loading. You don't need to call LoadAssemblyFrom for assemblies that are already loaded into current app domain.

2) scan it and register all types from all assemblies currently loaded into application domain as all interfaces that these types implement

In regards to performance issue - as mentioned before, autoregistration scans ALL assemblies currently loaded into application domain, including system ones.

To exclude certain assemblies from auto-scanning, please use ExcludeAssemblies method that takes predicate to filter what assemblies to exclude or ExcludeSystemAssemblies method to exclude system assemblies, for example

So if there are 2 assemblies in the application, and I exclude the system assemblies and currrent assembly, I am left with the target assembly. This works fine and runs in 0.9 seconds rather than 9 seconds.

.. or not. It gets even faster if I exclude NUnit like so:

ExcludeAssemblies(a => a == typeof(TestFixtureAttribute).Assembly).

So the problem with *excluding* assemblies is that it's easy to overlook one. It seems better to me if I could include only the assemblies that I know are needed (and I'll get an error if they aren't included).

I have also just remembered that actually auto-registration used to work like you've been expecting, however I have changed as a result of this request: http://autoregistration.codeplex.com/workitem/6026,
to minimize amount of code to use auto-registration.