Adding more compile time safety to the StronglyTypedServiceConfigurator As method

[barsonax]

Adding more compile time safety to the StronglyTypedServiceConfigurator As method

[Barsonax]

#143 added some overloads for the Register method:

void Register<TImplementation>(...)
void Register<TService1, TImplementation>(...)
void Register<TService1, TService2, TImplementation>(...)
void Register<TService1, TService2, TService3, TImplementation>(...)
void Register<TService1, TService2, TService3, TService4, TImplementation>(...)

I believe up to 4 services for a given implementation should cover all sensible use cases. Furthermore this way it was possible to add generic constraints to all of these methods for some extra compile time safety.

Also in this PR TImplementation is now also registered as a service type which will allow you to resolve TImplementation directly and with the correct lifetimes etc.

The As method was removed as its no longer needed.

With this change we can close this issue.

[BrunoZell]

There are two aspects of the registration API I think can be improved:

There are two ways of defining a dependency type

• By passing the dependency type as a parameter intoRegister(Type dependencyType, Type instanceType, ...) or Register<TDependency, TInstance>(...).
• By using As on either WeaklyTypedServiceConfigurator or StronglyTypedServiceConfigurator<TDependency, TInstance>.

Only the latter one allows for multiple service types, is thus more powerful and in turn is used more often.

I also find the signature StronglyTypedServiceConfigurator<TDependency, TInstance> As<TService>() quite confusing on first sight. Why do I have two service types here (TDependency and TService) and how do they relate?

Delegate-based configuration can be hard to format

I find all code that uses WeaklyTypedServiceConfigurator or StronglyTypedServiceConfigurator<TDependency, TInstance> is hard to format in a clean way as it is primarily delegate based. Every registration is really just one big function call.

I am all for fluent design, but this makes it hard to mentally parse the code.

Proposal

The service configurators use the builder pattern anyway, so we reasonably can just pull that into the Register method, which currently returns void.

var builder = new ContainerBuilder();
builder.Register<Implementation>().As<IService>();

var singleton = new Singleton();
builder.Register<Singleton>()
    .As<ISingleton>()
    .As<ISecondaryInterface>()
    .With(Lifetime.PerContainer)
    .Inject(Expression.Constant(singleton));

[Barsonax]

Your proposal doesn't actually make it possible to add compile time checks when registering with multiple services.

Iam thinking to drop the As method completely and simply add some overloads with more generic parameters for the common use cases. This does mean there is going to be a maximum amount of service types for a given implementation. If really needed one could pass in a array of service types when using the weakly typed api but having a dependency with many service types is not really good design so its not a common use case.