public static TInterface Resolve <TInterface>()
where TInterface : class
{
var type = typeof(TInterface);
var id = GetTypeId(type);
lock (internals)
{
object obj;
IFactory factory;
if (services.ContainsKey(id) && (obj = services[id]) != null)
{
return((TInterface)services[id]);
}
else if (factories.ContainsKey(id) && (factory = factories[id]) != null)
{
var instance = factory.Create();
if (!(factory is FactoryFactoryService))
{
services[id] = instance;
}
TraceEx.Info("ApplicationServices", "Created instance of " + (instance != null ? instance.ToString() : id.ToString()));
return((TInterface)instance);
}
}
return(null);
}
/// <summary>
/// Unregisters a service with from specified interface type.
/// </summary>
/// <typeparam name="TInterface">The type of the interface.</typeparam>
public static void Unregister <TInterface>()
where TInterface : class
{
var type = typeof(TInterface);
var id = type.GUID;
lock (internals)
{
if (services.ContainsKey(id))
{
services.Remove(id);
TraceEx.Info("ApplicationServices", "Removed instance for " + type.Name);
}
}
}
/// <summary>
/// Drops the instance of a service registered with the TInterface type (does not call <see cref="IDisposable.Dispose"/>).
/// Does not unregister the factory (the object will be recreated if resolved).
/// </summary>
public static void DropInstance <TInterface>()
where TInterface : class
{
var type = typeof(TInterface);
var id = GetTypeId(type);
lock (internals)
{
if (services.ContainsKey(id))
{
var instance = services[id];
services[id] = null;
TraceEx.Info("ApplicationServices", "Removed instance of " + (instance != null ? instance.ToString() : id.ToString()));
}
}
}
/// <summary>
/// Registers a service with a specified interface type.
/// The service is automatically instanciated on the first call to it using the default constructor.
/// </summary>
/// <typeparam name="TInterface">The resolving type (interface).</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <exception cref="ArgumentException">If service or factory already exists</exception>
public static void Register <TInterface, TImplementation>()
where TInterface : class
where TImplementation : class, TInterface, new()
{
var type = typeof(TInterface);
var implType = typeof(TImplementation);
var id = GetTypeId(type);
lock (internals)
{
ThrowIfRegisteredOrInstanciated(type, id);
factories.Add(id, new LazyEmptyService(implType));
TraceEx.Info("ApplicationServices", "Registered factory for " + type.Name);
}
}
/// <summary>
/// Registers a service with a specified interface type.
/// The service is automatically instanciated on ALL call to it.
/// </summary>
/// <typeparam name="TInterface">The resolving type (interface).</typeparam>
/// <param name="factory">The factory for the instantiation.</param>
/// <exception cref="ArgumentException">If service or factory already exists</exception>
public static void RegisterFactory <TInterface>(Func <TInterface> factory)
where TInterface : class
{
var type = typeof(TInterface);
var id = GetTypeId(type);
lock (internals)
{
ThrowIfRegisteredOrInstanciated(type, id);
#if SILVERLIGHT || NETFX_CORE
factories.Add(id, new FactoryFactoryService(() => factory()));
#else
factories.Add(id, new FactoryFactoryService(factory));
#endif
TraceEx.Info("ApplicationServices", "Registered factory for " + type.Name);
}
}
/// <summary>
/// Drops an instance of a service with the specified reference (does not call <see cref="IDisposable.Dispose"/>).
/// Does not unregister the factory (the object will be recreated if resolved).
/// </summary>
/// <param name="obj">The object to drop.</param>
/// <exception cref="ArgumentNullException">if the argument is null</exception>
public static void DropInstance(object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
lock (internals)
{
foreach (var item in services.ToArray())
{
if (item.Value == obj)
{
services.Remove(item.Key);
TraceEx.Info("ApplicationServices", "Removed instance for " + (item.Value != null ? item.Value.ToString() : item.Key.ToString()));
}
}
}
}
/// <summary>
/// Registers a service with a specified resolving type and instance.
/// </summary>
/// <typeparam name="TImplementation">The resolving type (interface).</typeparam>
/// <param name="service">The reference to the service instance.</param>
/// <exception cref="ArgumentException">If service or factory already exists</exception>
/// <exception cref="ArgumentNullException"></exception>
public static void Register <TImplementation>(TImplementation service)
where TImplementation : class
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var type = typeof(TImplementation);
var id = GetTypeId(type);
lock (internals)
{
ThrowIfRegisteredOrInstanciated(type, id);
services.Add(id, service);
TraceEx.Info("ApplicationServices", "Registered instance for " + type.Name);
}
}
/// <summary>
/// Registers the a service with a specified interface type.
/// The service is automatically instanciated on the first call to it.
/// </summary>
/// <typeparam name="TInterface">The type of the interface.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="service">The reference to the service instance.</param>
public static void Register <TInterface, TImplementation>()
where TInterface : class
where TImplementation : class, TInterface, new()
{
var type = typeof(TInterface);
var implType = typeof(TImplementation);
var id = type.GUID;
lock (internals)
{
if (services.ContainsKey(id))
{
throw new ArgumentException("Service of type '" + type.Name + "' is already registered");
}
services.Add(id, new LazyEmptyService(implType));
TraceEx.Info("ApplicationServices", "Registered implementation for " + type.Name);
}
}
/// <summary>
/// Clears all instances (and calls <see cref="IDisposable.Dispose"/>).
/// </summary>
public static void ClearInstances()
{
lock (internals)
{
if (services.Count > 0)
{
foreach (var item in services.Values)
{
var disposable = item as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
services.Clear();
TraceEx.Info("ApplicationServices", "Cleared");
}
}
/// <summary>
/// Registers the a service with a specified interface type.
/// The service is automatically instanciated on the first call to it.
/// </summary>
/// <typeparam name="TInterface">The type of the interface.</typeparam>
/// <param name="factory">The factory for the instantiation.</param>
public static void Register <TInterface>(Func <TInterface> factory)
where TInterface : class
{
var type = typeof(TInterface);
var id = type.GUID;
lock (internals)
{
if (services.ContainsKey(id))
{
throw new ArgumentException("Service of type '" + type.Name + "' is already registered");
}
#if SILVERLIGHT
services.Add(id, new LazyFactoryService(() => factory()));
#else
services.Add(id, new LazyFactoryService(factory));
#endif
TraceEx.Info("ApplicationServices", "Registered factory for " + type.Name);
}
}
/// <summary>
/// Registers the a service with a specified interface type.
/// </summary>
/// <typeparam name="TInterface">The type of the interface.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="service">The reference to the service instance.</param>
public static void Register <TImplementation>(TImplementation service)
where TImplementation : class
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var type = typeof(TImplementation);
var id = type.GUID;
lock (internals)
{
if (services.ContainsKey(id))
{
throw new ArgumentException("Service of type '" + type.Name + "' is already registered");
}
services.Add(id, service);
TraceEx.Info("ApplicationServices", "Registered instance for " + type.Name);
}
}
