private void AddInjectorDependencies(InjectionKey injected)
{
var injector = InjectorCache.GetOrCreateInjector(injected.InjectedResourceType);
foreach (var dependsOn in injector.DependsOn)
{
AddDependency(injected, dependsOn, false);
}
}
private DependencyNode GetOrCreateNode(InjectionKey key, out bool created)
{
created = false;
if (!nodeLookup.TryGetValue(key, out var node))
{
node = new DependencyNode(key);
nodeLookup[key] = node;
created = true;
AddInjectorDependencies(key);
}
return(node);
}
internal bool HasCycle(out InjectionKey onDependency)
{
onDependency = default;
var stack = new Stack <DependencyNode>();
var visited = new HashSet <DependencyNode>();
var nodeStates = new Dictionary <DependencyNode, NodeState>();
NodeState GetNodeState(DependencyNode node)
{
if (nodeStates.TryGetValue(node, out var v))
{
return(v);
}
return(NodeState.Unvisited);
}
foreach (var root in OrderedRoots)
{
stack.Push(root);
}
while (stack.Count != 0)
{
var current = stack.Peek();
if (visited.Add(current))
{
nodeStates[current] = NodeState.Open;
foreach (var dependsOn in current.DependsOn)
{
if (!visited.Contains(dependsOn))
{
stack.Push(dependsOn);
}
else if (GetNodeState(dependsOn) == NodeState.Open)
{
return(true);
}
}
}
else
{
nodeStates[current] = NodeState.Closed;
stack.Pop();
}
}
return(false);
}
private void AddDependency(InjectionKey dependsOn, InjectionKey dependency, bool isRoot)
{
var sourceNode = GetOrCreateNode(dependsOn);
//If a concrete class is bound to an implementation of itself, these will be equal. No need to track a self-referencing dependency
if (!dependsOn.Equals(dependency))
{
sourceNode.AddDependsOn(GetOrCreateNode(dependency));
cachedSortedList = null;
}
if (isRoot)
{
roots.Add(sourceNode);
cachedSortedList = null;
}
}
private DependencyNode GetOrCreateNode(InjectionKey key) => GetOrCreateNode(key, out _);
/// <summary> /// Add a dependency. /// /// dependsOn will depend on dependency. Any subsequent dependencies will subsequently be added. /// </summary> /// <param name="dependsOn"></param> /// <param name="dependency"></param> internal void AddDependency(InjectionKey dependsOn, InjectionKey dependency) => AddDependency(dependsOn, dependency, true);
public DependencyNode(InjectionKey injectionKey)
{
InjectionKey = injectionKey;
}
internal IEnumerable <InjectionKey> GetDependenciesFor(InjectionKey key)
{
return(GetOrCreateNode(key).DependsOn.Select(d => d.InjectionKey));
}
