public IConstructorParameter FindByType(IConstructorParameters parameters, Type type)
{
IConstructorParameter selected = parameters.Parameters.First(x => type.IsAssignableFrom(x.Type));
parameters.Parameters.Remove(selected);
return(selected);
}
public IEnumerable <IParameter> GenerateParameters(IConstructor constructor, IConstructorParameters constructorParameters)
{
foreach (IParameter parameter in constructor.Parameters)
{
IConstructorParameter constructorParameter = ConstructorParameterByTypeFinder.FindByType(constructorParameters, parameter.Type);
parameter.Value = constructorParameter.Value;
yield return(parameter);
}
}
public StorageBuilder Register(Type type, params object[] constructorParameters)
{
IConstructorParameters parameters = ConstructorParametersGenerator.GenerateParameters(constructorParameters);
return(Update(x =>
{
AssemblyRegistrar.RegisterIfNotExist(x.Assemblies, type.Assembly);
IEnumerable <IService> services = ServicesGenerator.GenerateServices(type, Object.Assemblies, null, parameters);
ServiceRegistrar.Register(Object.Services, services);
}));
}
public List <Type> GenerateList(IConstructorParameters parameters)
{
IEnumerable <Type> generate(IConstructorParameters p)
{
foreach (IConstructorParameter parameter in parameters.Parameters)
{
yield return(parameter.Type);
}
}
return(generate(parameters).ToList());
}
public object CreateInstance(Type @class, IConstructorParameters constructorParameters)
{
ConstructorInfo[] constructorInfos = ConstructorInfoListGenerator.GenerateList(@class);
IEnumerable <IConstructor> constructors = ConstructorListGenerator.GenerateList(constructorInfos);
IConstructor constructor = ConstructorFinder.FindBy(constructors, constructorParameters);
IEnumerable <IParameter> parameters = ParametersGenerator.GenerateParameters(constructor, constructorParameters);
object[] values = ParametersValuesExtractor.ExtractValues(parameters);
object instance = ConstructorInvoker.InvokeConstructor(constructor, values);
return(instance);
}
public void Register <T>(params object[] parameters)
{
Type type = TypeGetter.GetType <T>();
IConstructorParameters constructorParameters = ConstructorParametersByObjectsGenerator.GenerateParameters(parameters);
IEnumerable <IService> services = ServicesGenerator.GenerateServices(type, Storage.Assemblies, this, constructorParameters);
foreach (IService service in services)
{
if (ServiceIsAutoValueChecker.Check(service))
{
ServiceInitializer.Initialize(service, this);
}
}
ServiceRegistrar.Register(Storage.Services, services);
}
public IConstructor FindBy(IEnumerable <IConstructor> ctors, IConstructorParameters constructorParameters)
{
// TODO please.
List <IConstructor> matchingLen = ctors
.Where(x => x.Parameters.Count() >= constructorParameters.Parameters.Count)
.ToList();
List <IConstructor> matchingParameters = matchingLen.Where(
x => x.Parameters.All(y => constructorParameters.Parameters.FirstOrDefault(z => z.Type.IsAssignableFrom(y.Type)) != null))
.ToList();
List <IConstructor> ordered = matchingParameters.OrderBy(x => x.Parameters.Count()).ToList();
IConstructor result = ordered.FirstOrDefault();
return(result);
}
public IEnumerable <IService> GenerateServices(Type type, IAssemblyList assemblies, IReadOnlyContainer container,
IConstructorParameters constructorParameters = null, object instance = null)
{
if (TypeIsClassValidator.Validate(type))
{
IService service = ServiceGenerator.GenerateService(type, container, instance, constructorParameters);
yield return(service);
}
else
{
IEnumerable <Type> types = ImplementationsFinder.FindImplementations(assemblies, type);
foreach (Type @class in types)
{
IService service = ServiceGenerator.GenerateService(@class, container, null, constructorParameters);
yield return(service);
}
}
}
public IService GenerateService(Type @class, object instance = null, IConstructorParameters constructorParameters = null)
{
if (ClassHasFactoryChecker.HasFactory(@class))
{
IServiceFactory factory = FactoryProvider.ProvideServiceFactory(@class);
return(FactoryInvoker.Invoke(factory));
}
ServiceFlags flags = FlagsGenerator.GenerateFlags(@class);
ServiceInfo info = InfoGenerator.Generate(@class);
IServiceRegistration registration = RegistrationGenerator.Generate(flags, @class, instance, constructorParameters);
return(new ServiceBuilder()
.AddFlags(flags)
.AddInfo(info)
.AddData(new ServiceData()
{
Instance = instance
})
.AddRegistration(registration)
.Build());
}
public IServiceRegistration Generate(ServiceFlags flags, Type type, object instance = null, IConstructorParameters constructorParameters = null)
{
return(new ServiceRegistration()
{
TargetType = type,
RegistrationFlags = RegistrationFlagsGenerator.GenerateFlags(flags, type, instance, constructorParameters)
});
}
public IEnumerable <ServiceRegistrationFlag> GenerateFlags(ServiceFlags flags, Type type, object instance, IConstructorParameters constructorParameters)
{
if (instance != null)
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.HasInstance, instance));
}
if (constructorParameters != null)
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.HasConstructorParameters, true));
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.ConstructorParameters, constructorParameters));
}
Type baseType = BaseTypeFinder.GetBaseTypeAnotherOf(type, null, typeof(object));
if (baseType != null)
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.AsClass, baseType));
}
IEnumerable <IInterface> interfaces = InterfacesGenerator.GenerateInterfaces(flags, type);
foreach (IInterface @interface in interfaces)
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.AsInterface, @interface));
}
ConstructorInfo[] constructors = ConstructorInfoListGenerator.GenerateList(type);
if (flags.HasFlag(ServiceFlagConstants.ServiceCtor))
{
ServiceFlag flag = flags.GetFlag(ServiceFlagConstants.ServiceCtor);
IMember member = flag.Member;
IConstructor serviceConstructor = ConstructorGenerator.GenerateConstructor((ConstructorInfo)member.Instance);
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.DefaultConstructor, serviceConstructor));
}
else
{
ConstructorInfo defaultConstructorInfo = DefaultConstructorInfoProvider.ProvideDefaultConstructor(constructors);
IConstructor defaultConstructor = ConstructorGenerator.GenerateConstructor(defaultConstructorInfo);
if (defaultConstructor != null)
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.DefaultConstructor, defaultConstructor));
}
}
foreach (ConstructorInfo constructor in constructors)
{
IConstructor ctor = ConstructorGenerator.GenerateConstructor(constructor);
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.Constructor, ctor));
}
Type[] genericArguments = type.GetGenericArguments();
if (genericArguments.Any())
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.HasGenericParameters, null));
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.GenericParameters, genericArguments));
}
foreach (ServiceFlag factoryFlag in flags.GetFlags(ServiceFlagConstants.ServiceFactory))
{
yield return(new ServiceRegistrationFlag(RegistrationFlagConstants.Factory, null)
{
Member = factoryFlag.Member
});
}
}
public object CreateInstance(Type type, IConstructorParameters constructorParameter)
{
return(CtorInstanceCreator.CreateInstance(type, constructorParameter));
}
