/// <summary>
/// Creates the service instance.
/// </summary>
/// <param name="registration">The registration.</param>
/// <returns>The service instance.</returns>
private object CreateServiceInstance(ServiceLocatorRegistration registration)
{
object instance;
if (SupportDependencyInjection)
{
instance = TypeFactory.CreateInstance(registration.ImplementingType);
}
else
{
instance = TypeFactory.CreateInstanceUsingActivator(registration.ImplementingType);
}
if (instance != null)
{
var handler = TypeInstantiated;
if (handler != null)
{
handler(this, new TypeInstantiatedEventArgs(registration.DeclaringType, registration.ImplementingType,
registration.Tag, registration.RegistrationType));
}
}
return(instance);
}
/// <summary>
/// Registers a specific instance of an service.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="instance">The specific instance to register.</param>
/// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param>
/// <param name="originalContainer">The original container where the instance was found in.</param>
/// <exception cref="ArgumentNullException">The <paramref name="serviceType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="instance"/> is <c>null</c>.</exception>
private void RegisterInstance(Type serviceType, object instance, object tag, object originalContainer)
{
Argument.IsNotNull("serviceType", serviceType);
Argument.IsNotNull("instance", instance);
Log.Debug("Registering type '{0}' to instance of type '{1}'", serviceType.FullName, instance.GetType().FullName);
var registeredTypeInfo = new ServiceLocatorRegistration(serviceType, instance.GetType(), tag, RegistrationType.Singleton, x => instance);
lock (this)
{
var serviceInfo = new ServiceInfo(serviceType, tag);
if (_registeredTypes.ContainsKey(serviceInfo))
{
// Re-use previous subscription
registeredTypeInfo = _registeredTypes[serviceInfo];
}
else
{
_registeredTypes[serviceInfo] = registeredTypeInfo;
}
_registeredInstances[serviceInfo] = new RegisteredInstanceInfo(registeredTypeInfo, instance);
}
TypeRegistered.SafeInvoke(this, new TypeRegisteredEventArgs(registeredTypeInfo.DeclaringType, registeredTypeInfo.ImplementingType, tag, RegistrationType.Singleton));
Log.Debug("Registered type '{0}' to instance of type '{1}'", serviceType.FullName, instance.GetType().FullName);
}
/// <summary>
/// Registers the specific implementing type for the service type.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="serviceImplementationType">Type of the implementing.</param>
/// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param>
/// <param name="registrationType">The registration type.</param>
/// <param name="registerIfAlreadyRegistered">if set to <c>true</c>, an older type registration is overwritten by this new one.</param>
/// <param name="originalContainer">The original container where the type was found in.</param>
/// <param name="createServiceFunc">The create service function.</param>
/// <exception cref="System.InvalidOperationException"></exception>
/// <exception cref="ArgumentNullException">The <paramref name="serviceType" /> is <c>null</c>.</exception>
private void RegisterType(Type serviceType, Type serviceImplementationType, object tag, RegistrationType registrationType, bool registerIfAlreadyRegistered, object originalContainer, Func <ServiceLocatorRegistration, object> createServiceFunc)
{
Argument.IsNotNull("serviceType", serviceType);
if (serviceImplementationType == null)
{
// Dynamic late-bound type
serviceImplementationType = typeof(LateBoundImplementation);
}
if (serviceImplementationType.IsInterfaceEx())
{
string error = string.Format("Cannot register interface type '{0}' as implementation, make sure to specify an actual class", serviceImplementationType.GetSafeFullName());
Log.Error(error);
throw new InvalidOperationException(error);
}
/* TODO: This code have to be here to ensure the right usage of non-generic overloads of register methods.
* TODO: If it is finally accepted then remove it from ServiceLocatorAutoRegistrationManager
* if (serviceImplementationType.IsAbstractEx() || !serviceType.IsAssignableFromEx(serviceImplementationType))
* {
* string message = string.Format("The type '{0}' is abstract or can't be registered as '{1}'", serviceImplementationType, serviceType);
* Log.Error(message);
* throw new InvalidOperationException(message);
* }
*/
// Outside lock scope for event
ServiceLocatorRegistration registeredTypeInfo = null;
lock (this)
{
if (!registerIfAlreadyRegistered && IsTypeRegistered(serviceType, tag))
{
//Log.Debug("Type '{0}' already registered, will not overwrite registration", serviceType.FullName);
return;
}
var serviceInfo = new ServiceInfo(serviceType, tag);
if (_registeredInstances.ContainsKey(serviceInfo))
{
_registeredInstances.Remove(serviceInfo);
}
Log.Debug("Registering type '{0}' to type '{1}'", serviceType.FullName, serviceImplementationType.FullName);
registeredTypeInfo = new ServiceLocatorRegistration(serviceType, serviceImplementationType, tag, registrationType,
x => (createServiceFunc != null) ? createServiceFunc(x) : CreateServiceInstance(x));
_registeredTypes[serviceInfo] = registeredTypeInfo;
}
TypeRegistered.SafeInvoke(this, new TypeRegisteredEventArgs(registeredTypeInfo.DeclaringType, registeredTypeInfo.ImplementingType, tag, registeredTypeInfo.RegistrationType));
Log.Debug("Registered type '{0}' to type '{1}'", serviceType.FullName, serviceImplementationType.FullName);
}
/// <summary>
/// Creates the service instance.
/// </summary>
/// <param name="registration">The registration.</param>
/// <returns>The service instance.</returns>
private object CreateServiceInstance(ServiceLocatorRegistration registration)
{
object instance = _typeFactory.CreateInstance(registration.ImplementingType);
if (instance == null)
{
ThrowTypeNotRegisteredException(registration.DeclaringType, "Failed to instantiate the type using the TypeFactory. Check if the required dependencies are registered as well or that the type has a valid constructor that can be used.");
}
var handler = TypeInstantiated;
if (handler != null)
{
handler(this, new TypeInstantiatedEventArgs(registration.DeclaringType, registration.ImplementingType,
registration.Tag, registration.RegistrationType));
}
return(instance);
}
public RegisteredInstanceInfo(ServiceLocatorRegistration registration, object instance)
: base(registration.DeclaringType, registration.ImplementingType, registration.Tag, registration.RegistrationType, registration.CreateServiceFunc)
{
ImplementingInstance = instance;
}
/// <summary>
/// Creates the service instance.
/// </summary>
/// <param name="registration">The registration.</param>
/// <returns>The service instance.</returns>
private object CreateServiceInstance(ServiceLocatorRegistration registration)
{
object instance = _typeFactory.CreateInstance(registration.ImplementingType);
if (instance == null)
{
ThrowTypeNotRegisteredException(registration.DeclaringType, "Failed to instantiate the type using the TypeFactory. Check if the required dependencies are registered as well or that the type has a valid constructor that can be used.");
}
var handler = TypeInstantiated;
if (handler != null)
{
handler(this, new TypeInstantiatedEventArgs(registration.DeclaringType, registration.ImplementingType,
registration.Tag, registration.RegistrationType));
}
return instance;
}
/// <summary>
/// Registers the specific implementing type for the service type.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="serviceImplementationType">Type of the implementing.</param>
/// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param>
/// <param name="registrationType">The registration type.</param>
/// <param name="registerIfAlreadyRegistered">if set to <c>true</c>, an older type registration is overwritten by this new one.</param>
/// <param name="originalContainer">The original container where the type was found in.</param>
/// <param name="createServiceFunc">The create service function.</param>
/// <exception cref="System.InvalidOperationException"></exception>
/// <exception cref="ArgumentNullException">The <paramref name="serviceType" /> is <c>null</c>.</exception>
private void RegisterType(Type serviceType, Type serviceImplementationType, object tag, RegistrationType registrationType, bool registerIfAlreadyRegistered, object originalContainer, Func<ServiceLocatorRegistration, object> createServiceFunc)
{
Argument.IsNotNull("serviceType", serviceType);
if (serviceImplementationType == null)
{
// Dynamic late-bound type
serviceImplementationType = typeof(LateBoundImplementation);
}
if (serviceImplementationType.IsInterfaceEx())
{
throw Log.ErrorAndCreateException<InvalidOperationException>("Cannot register interface type '{0}' as implementation, make sure to specify an actual class", serviceImplementationType.GetSafeFullName());
}
/* TODO: This code have to be here to ensure the right usage of non-generic overloads of register methods.
* TODO: If it is finally accepted then remove it from ServiceLocatorAutoRegistrationManager
if (serviceImplementationType.IsAbstractEx() || !serviceType.IsAssignableFromEx(serviceImplementationType))
{
string message = string.Format("The type '{0}' is abstract or can't be registered as '{1}'", serviceImplementationType, serviceType);
Log.Error(message);
throw new InvalidOperationException(message);
}
*/
// Outside lock scope for event
ServiceLocatorRegistration registeredTypeInfo = null;
lock (this)
{
if (!registerIfAlreadyRegistered && IsTypeRegistered(serviceType, tag))
{
//Log.Debug("Type '{0}' already registered, will not overwrite registration", serviceType.FullName);
return;
}
var serviceInfo = new ServiceInfo(serviceType, tag);
if (_registeredInstances.ContainsKey(serviceInfo))
{
_registeredInstances.Remove(serviceInfo);
}
Log.Debug("Registering type '{0}' to type '{1}'", serviceType.FullName, serviceImplementationType.FullName);
registeredTypeInfo = new ServiceLocatorRegistration(serviceType, serviceImplementationType, tag, registrationType,
x => (createServiceFunc != null) ? createServiceFunc(x) : CreateServiceInstance(x));
_registeredTypes[serviceInfo] = registeredTypeInfo;
}
TypeRegistered.SafeInvoke(this, new TypeRegisteredEventArgs(registeredTypeInfo.DeclaringType, registeredTypeInfo.ImplementingType, tag, registeredTypeInfo.RegistrationType));
Log.Debug("Registered type '{0}' to type '{1}'", serviceType.FullName, serviceImplementationType.FullName);
}
/// <summary>
/// Registers a specific instance of an service.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="instance">The specific instance to register.</param>
/// <param name="tag">The tag to register the service with. The default value is <c>null</c>.</param>
/// <param name="originalContainer">The original container where the instance was found in.</param>
/// <exception cref="ArgumentNullException">The <paramref name="serviceType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="instance"/> is <c>null</c>.</exception>
private void RegisterInstance(Type serviceType, object instance, object tag, object originalContainer)
{
Argument.IsNotNull("serviceType", serviceType);
Argument.IsNotNull("instance", instance);
Log.Debug("Registering type '{0}' to instance of type '{1}'", serviceType.FullName, instance.GetType().FullName);
var registeredTypeInfo = new ServiceLocatorRegistration(serviceType, instance.GetType(), tag, RegistrationType.Singleton, x => instance);
lock (this)
{
var serviceInfo = new ServiceInfo(serviceType, tag);
if (_registeredTypes.ContainsKey(serviceInfo))
{
// Re-use previous subscription
registeredTypeInfo = _registeredTypes[serviceInfo];
}
else
{
_registeredTypes[serviceInfo] = registeredTypeInfo;
}
_registeredInstances[serviceInfo] = new RegisteredInstanceInfo(registeredTypeInfo, instance);
}
TypeRegistered.SafeInvoke(this, new TypeRegisteredEventArgs(registeredTypeInfo.DeclaringType, registeredTypeInfo.ImplementingType, tag, RegistrationType.Singleton));
Log.Debug("Registered type '{0}' to instance of type '{1}'", serviceType.FullName, instance.GetType().FullName);
}
public RegisteredInstanceInfo(ServiceLocatorRegistration registration, object instance)
: base(registration.DeclaringType, registration.ImplementingType, registration.Tag, registration.RegistrationType, registration.CreateServiceFunc)
{
ImplementingInstance = instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceLocatorRegistrationGroup"/> class.
/// </summary>
/// <param name="entryRegistration">The entry registration.</param>
/// <exception cref="ArgumentNullException">The <paramref name="entryRegistration"/> is <c>null</c>.</exception>
public ServiceLocatorRegistrationGroup(ServiceLocatorRegistration entryRegistration)
{
Argument.IsNotNull("entryRegistration", entryRegistration);
EntryRegistration = entryRegistration;
}
/// <summary>
/// Default create service function, uses <see cref="_typeFactory"/> to create a service instance.
/// </summary>
/// <param name="registration">The registration.</param>
/// <returns>The service instance.</returns>
private object DefaultCreateServiceFunc(ServiceLocatorRegistration registration)
{
var instance = _typeFactory.CreateInstanceWithTag(registration.ImplementingType, registration.Tag);
return(instance);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceLocatorRegistrationGroup"/> class.
/// </summary>
/// <param name="entryRegistration">The entry registration.</param>
/// <exception cref="ArgumentNullException">The <paramref name="entryRegistration"/> is <c>null</c>.</exception>
public ServiceLocatorRegistrationGroup(ServiceLocatorRegistration entryRegistration)
{
Argument.IsNotNull("entryRegistration", entryRegistration);
EntryRegistration = entryRegistration;
}
/// <summary>
/// Creates the service instance.
/// </summary>
/// <param name="registration">The registration.</param>
/// <returns>The service instance.</returns>
private object CreateServiceInstance(ServiceLocatorRegistration registration)
{
object instance;
if (SupportDependencyInjection)
{
instance = TypeFactory.CreateInstance(registration.ImplementingType);
}
else
{
instance = TypeFactory.CreateInstanceUsingActivator(registration.ImplementingType);
}
if (instance != null)
{
var handler = TypeInstantiated;
if (handler != null)
{
handler(this, new TypeInstantiatedEventArgs(registration.DeclaringType, registration.ImplementingType,
registration.Tag, registration.RegistrationType));
}
}
return instance;
}
