internal static IRegistration[] RegisterManyBasedOnInterface <T>(this IKernel containerKernel, bool asSingletons = false)
            where T : class
        {
            var typesToRegister = TypesFromCurrentAssembly
                                  .Where(type => type.GetInterfaces().Contains(typeof(T)) && type.IsClass /* type.IsSubclassOf(typeof(T))*/)
                                  .ToList();

            return(containerKernel.ProcessTypesToRegister <T>(typesToRegister, asSingletons));
        }
        internal static IRegistration[] RegisterManyWithDefaultInterfacesBasedOnInterface <T>(this IKernel containerKernel, bool asSingletons = false) where T : class
        {
            var typesToRegister = TypesFromCurrentAssembly
                                  .Where(type => type.GetInterfaces().Contains(typeof(T)) && type.IsInterface)
                                  .ToList();
            var registrations = new IRegistration[typesToRegister.Count];

            for (var i = 0; i < typesToRegister.Count; i++)
            {
                var usingFactoryMethod = typeof(RegisterExtensionMethods)
                                         .GetMethod(nameof(RegisterComponentForProxy), BindingFlags.NonPublic | BindingFlags.Static);
                var usingFactoryMethodRef = usingFactoryMethod.MakeGenericMethod(typesToRegister[i],
                                                                                 TypesFromCurrentAssembly.First(type => type.GetInterfaces().Contains(typesToRegister[i]) && type.IsClass));
                registrations[i] = usingFactoryMethodRef
                                   .Invoke(new BusinessLayerInstaller(), new object[] { containerKernel, asSingletons }) as IRegistration;
            }
            return(registrations);
        }
        internal static IRegistration[] RegisterManyBasedOn(this IKernel containerKernel, Type baseType, bool asSingletons = false)
        {
            var typesToRegister = TypesFromCurrentAssembly
                                  .Where(type => !type.IsAbstract && !type.IsInterface &&
                                         type.BaseType != null && type.BaseType.IsGenericType &&
                                         type.BaseType.GetGenericTypeDefinition() == baseType)
                                  .ToList();
            var registrations = new IRegistration[typesToRegister.Count];

            var baseTypes = typesToRegister.Select(type => type.BaseType).ToList();

            for (var i = 0; i < typesToRegister.Count; i++)
            {
                var usingFactoryMethod = typeof(RegisterExtensionMethods)
                                         .GetMethod(nameof(RegisterComponentForProxy), BindingFlags.NonPublic | BindingFlags.Static);
                var usingFactoryMethodRef = usingFactoryMethod.MakeGenericMethod(baseTypes[i], typesToRegister[i]);
                registrations[i] = usingFactoryMethodRef
                                   .Invoke(new BusinessLayerInstaller(), new object[] { containerKernel, asSingletons }) as IRegistration;
            }
            return(registrations);
        }