void IKernelInternal.RegisterHandler(String name, IHandler handler, bool skipRegistration)
{
if (skipRegistration == false)
{
NamingSubSystem.Register(handler);
}
RaiseHandlerRegistered(handler);
RaiseHandlersChanged();
RaiseComponentRegistered(name, handler);
}
private void DisposeHandlers()
{
var vertices = TopologicalSortAlgo.Sort(GraphNodes);
for (var i = 0; i < vertices.Length; i++)
{
var model = (ComponentModel)vertices[i];
var handler = NamingSubSystem.GetHandler(model.Name);
DisposeHandler(handler);
}
}
public virtual bool HasComponent(Type serviceType)
{
if (serviceType == null)
{
return(false);
}
if (NamingSubSystem.Contains(serviceType))
{
return(true);
}
return(Parent != null && Parent.HasComponent(serviceType));
}
public virtual bool HasComponent(string name)
{
if (name == null)
{
return(false);
}
if (NamingSubSystem.Contains(name))
{
return(true);
}
return(Parent != null && Parent.HasComponent(name));
}
public virtual IHandler GetHandler(Type service)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
IHandler handler = NamingSubSystem.GetHandler(service);
if (handler == null && Parent != null)
{
handler = Parent.GetHandler(service);
}
return(handler);
}
public virtual IHandler GetHandler(String key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
IHandler handler = NamingSubSystem.GetHandler(key);
if (handler == null && Parent != null)
{
handler = Parent.GetHandler(key);
}
return(handler);
}
public virtual IHandler GetHandler(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var handler = NamingSubSystem.GetHandler(name);
if (handler == null && Parent != null)
{
handler = WrapParentHandler(Parent.GetHandler(name));
}
return(handler);
}
public virtual bool RemoveComponent(String key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (NamingSubSystem.Contains(key))
{
IHandler handler = GetHandler(key);
if (handler.ComponentModel.Dependers.Length == 0)
{
NamingSubSystem.UnRegister(key);
if (GetHandler(handler.ComponentModel.Service) == handler)
{
NamingSubSystem.UnRegister(handler.ComponentModel.Service);
}
foreach (ComponentModel model in handler.ComponentModel.Dependents)
{
model.RemoveDepender(handler.ComponentModel);
}
RaiseComponentUnregistered(key, handler);
DisposeHandler(handler);
return(true);
}
else
{
// We can't remove this component as there are
// others which depends on it
return(false);
}
}
if (Parent != null)
{
return(Parent.RemoveComponent(key));
}
return(false);
}
public virtual bool HasComponent(Type serviceType)
{
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
if (NamingSubSystem.Contains(serviceType))
{
return(true);
}
if (Parent != null)
{
return(Parent.HasComponent(serviceType));
}
return(false);
}
public virtual bool HasComponent(String key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (NamingSubSystem.Contains(key))
{
return(true);
}
if (Parent != null)
{
return(Parent.HasComponent(key));
}
return(false);
}
/// <summary>
/// Return handlers for components that implements the specified service.
/// </summary>
/// <param name = "service"> </param>
/// <returns> </returns>
public virtual IHandler[] GetHandlers(Type service)
{
var result = NamingSubSystem.GetHandlers(service);
// If a parent kernel exists, we merge both results
var parentResult = Parent?.GetHandlers(service);
if (!(parentResult?.Length > 0))
{
return(result);
}
var newResult = new IHandler[result.Length + parentResult.Length];
result.CopyTo(newResult, 0);
parentResult.CopyTo(newResult, result.Length);
result = newResult;
return(result);
}
/// <summary>
/// Return handlers for components that implements the specified service. The check is made using IsAssignableFrom
/// </summary>
/// <param name = "service"> </param>
/// <returns> </returns>
public virtual IHandler[] GetAssignableHandlers(Type service)
{
var result = NamingSubSystem.GetAssignableHandlers(service);
// If a parent kernel exists, we merge both results
if (Parent != null)
{
var parentResult = Parent.GetAssignableHandlers(service);
if (parentResult.Length > 0)
{
var newResult = new IHandler[result.Length + parentResult.Length];
result.CopyTo(newResult, 0);
parentResult.CopyTo(newResult, result.Length);
result = newResult;
}
}
return(result);
}
private void DisposeHandlers()
{
GraphNode[] nodes = GraphNodes;
IVertex[] vertices = TopologicalSortAlgo.Sort(nodes);
for (int i = 0; i < vertices.Length; i++)
{
ComponentModel model = (ComponentModel)vertices[i];
// Prevent the removal of a component that belongs
// to other container
if (!NamingSubSystem.Contains(model.Name))
{
continue;
}
bool successOnRemoval = RemoveComponent(model.Name);
System.Diagnostics.Debug.Assert(successOnRemoval);
}
}
/// <summary>
/// Return handlers for components that
/// implements the specified service.
/// The check is made using IsAssignableFrom
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public virtual IHandler[] GetAssignableHandlers(Type service)
{
return(NamingSubSystem.GetAssignableHandlers(service));
}
public void AddHandlersFilter(IHandlersFilter filter)
{
NamingSubSystem.AddHandlersFilter(filter);
}
public void AddHandlerSelector(IHandlerSelector selector)
{
NamingSubSystem.AddHandlerSelector(selector);
}
