/// <summary> /// Registers a service of the type specified in <paramref name="serviceType"/> with an /// implementation type specified in <paramref name="implementationType"/> as a lazy singleton. /// </summary> /// <param name="resolver">The <see cref="IMutableDependencyResolver"/> to register the service to.</param> /// <param name="implementationType">The type of the implementation to use.</param> /// <param name="serviceType">The type of the service to register.</param> /// <param name="contract">Can be used to isolate multiple <paramref name="implementationType"/> for /// the same <paramref name="serviceType"/>. /// </param> public static void RegisterLazySingleton(this IMutableDependencyResolver resolver, Type implementationType, Type serviceType, string contract = null) { ClassInstanceFactory classInstanceFactory = null; resolver.RegisterLazySingleton(() => { if (classInstanceFactory == null) { classInstanceFactory = GetClassInstanceFactory(resolver, implementationType, contract); } return(classInstanceFactory.Create()); }, serviceType, contract); }
private static ClassInstanceFactory GetClassInstanceFactory(IMutableDependencyResolver resolver, Type implementer, string contract = null) { var result = new ClassInstanceFactory(); result.Constructor = implementer.GetTypeInfo().DeclaredConstructors.FirstOrDefault(c => c.IsPublic); var constructorParameters = result.Constructor.GetParameters(); result.Parameters = new object[constructorParameters.Length]; for (var i = 0; i < constructorParameters.Length; i++) { result.Parameters[i] = resolver.GetService(constructorParameters[i].ParameterType, contract); if (result.Parameters[i] == null) { throw new ResolveException($"Unable to resolve {constructorParameters[i].Name} parameter for {implementer.Name}"); } } return(result); }