bool HasDirectOrIndirectDependencyRecursive(DependencyEntry toBeLookedUp, IList <DependencyEntry> dependencies)
{
foreach (var entry in dependencies)
{
if (entry == toBeLookedUp)
{
return(true);
}
if (m_Processed.Contains(entry.Name))
{
// We've found a cycle in the assemblies (which has already been logged)
return(false);
}
m_Processed.Add(entry.Name);
try
{
if (HasDirectOrIndirectDependencyRecursive(toBeLookedUp, entry.m_Dependencies))
{
return(true);
}
}
finally
{
m_Processed.Remove(entry.Name);
}
}
return(false);
}
/// <summary>
/// 注册
/// </summary>
/// <param name="dependencyEntry"></param>
public void RegisterEntry(DependencyEntry dependencyEntry)
{
if (dependencyEntry == null)
throw new ArgumentNullException(nameof(dependencyEntry));
_container.Add(dependencyEntry);
}
private bool HasPropertyDependency(DependencyEntry entry)
{
return(entry.GetImplementationType().
GetProperties(BindingFlags.Public | BindingFlags.Instance).
Select(p => p.PropertyType).
Any(p => PropertyEntryTable.ContainsKey(p)
));
}
private bool HasPropertyDependency(DependencyEntry entry)
{
return entry.GetImplementationType().
GetProperties(BindingFlags.Public | BindingFlags.Instance).
Select(p => p.PropertyType).
Any(p => PropertyEntryTable.ContainsKey(p)
);
}
public ResolverContext(DependencyEntry dependencyEntry)
{
if (dependencyEntry == null)
{
throw new ArgumentNullException(nameof(dependencyEntry));
}
DependencyEntry = dependencyEntry;
}
/// <summary>
/// 注册
/// </summary>
/// <param name="dependencyEntry"></param>
public void RegisterEntry(DependencyEntry dependencyEntry)
{
if (dependencyEntry == null)
{
throw new ArgumentNullException(nameof(dependencyEntry));
}
_container.Add(dependencyEntry);
}
private static bool HasDirectOrIndirectDependency(DependencyEntry lhs, DependencyEntry rhs)
{
var lhsDependendsOnRhs = lhs.m_Dependencies.Contains(rhs);
if (lhsDependendsOnRhs)
{
return(true);
}
return(HasDirectOrIndirectDependencyRecursive(rhs, lhs.m_Dependencies));
}
private bool HasDirectOrIndirectDependency(DependencyEntry lhs, DependencyEntry rhs)
{
var lhsDependsOnRhs = lhs.m_Dependencies.Contains(rhs);
if (lhsDependsOnRhs)
{
return(true);
}
m_Processed.Clear();
return(HasDirectOrIndirectDependencyRecursive(rhs, lhs.m_Dependencies));
}
/// <summary>
/// 获取或添加委托缓存
/// </summary>
internal static Func<IDependencyResolver, Object[], Object> GetOrAddCompile(this IDependencyTable dependencyTable,
DependencyEntry depencyEntry, Func<Type, Type, Func<IDependencyResolver, Object[], Object>> valueFactory)
{
if (depencyEntry == null) throw new ArgumentNullException(nameof(depencyEntry));
Func<IDependencyResolver, Object[], Object> resultingValue;
if (dependencyTable.CompileTable.TryGetValue(depencyEntry, out resultingValue))
{
return resultingValue;
}
return (dependencyTable.CompileTable[depencyEntry] = valueFactory(depencyEntry.ServiceType, depencyEntry.GetImplementationType()));
}
/// <summary>
/// 获取或添加委托缓存
/// </summary>
internal static Func<IDependencyResolver, Object> GetOrAddCompile(this IDependencyTable dependencyTable,
DependencyEntry depencyEntry, Func<Type, Type, Func<IDependencyResolver, Object>> valueFactory)
{
if (depencyEntry == null) throw new ArgumentNullException(nameof(depencyEntry));
var key = DependencyTableHelper.GetCompileKey(depencyEntry);
Func<IDependencyResolver, Object> resultingValue;
if (dependencyTable.CompileTable.TryGetValue(key, out resultingValue))
{
return resultingValue;
}
return (dependencyTable.CompileTable[key] = valueFactory(key.Item1, key.Item2));
}
/// <summary>
/// 将依赖注入对象添加到容器中
/// </summary>
/// <param name="dependencyEntry"></param>
public void Add(DependencyEntry dependencyEntry)
{
if (dependencyEntry == null) throw new ArgumentNullException(nameof(dependencyEntry));
lock (_sync)
{
var serviceType = dependencyEntry.ServiceType;
if (_dependencyDictionary.ContainsKey(serviceType))
{
_dependencyDictionary[serviceType].Add(dependencyEntry);
}
else
{
_dependencyDictionary.Add(serviceType, dependencyEntry);
}
}
}
/// <summary>
/// 获取或添加委托缓存
/// </summary>
internal static Func <IDependencyResolver, Object[], Object> GetOrAddCompile(this IDependencyTable dependencyTable,
DependencyEntry depencyEntry, Func <Type, Type, Func <IDependencyResolver, Object[], Object> > valueFactory)
{
if (depencyEntry == null)
{
throw new ArgumentNullException(nameof(depencyEntry));
}
Func <IDependencyResolver, Object[], Object> resultingValue;
if (dependencyTable.CompileTable.TryGetValue(depencyEntry, out resultingValue))
{
return(resultingValue);
}
return(dependencyTable.CompileTable[depencyEntry] = valueFactory(depencyEntry.ServiceType, depencyEntry.GetImplementationType()));
}
private static bool HasDirectOrIndirectDependencyRecursive(DependencyEntry toBeLookedUp, IEnumerable <DependencyEntry> dependencies)
{
foreach (var entry in dependencies)
{
if (entry == toBeLookedUp)
{
return(true);
}
if (HasDirectOrIndirectDependencyRecursive(toBeLookedUp, entry.m_Dependencies))
{
return(true);
}
}
return(false);
}
/*
* Given two nodes (A & B ) in the graph
* A > B if A -> B (direct or indirect)
* A < B if B -> A (direct or indirect)
*/
private int CompareElements(DependencyEntry lhs, DependencyEntry rhs)
{
var rshDependsOnLhs = HasDirectOrIndirectDependency(lhs, rhs);
if (rshDependsOnLhs)
{
return(1);
}
var lhsDependsOnRhs = HasDirectOrIndirectDependency(rhs, lhs);
if (lhsDependsOnRhs)
{
return(-1);
}
return(0);
}
private DependencyEntry InternalAddDependencies(string root, params string[] dependencies)
{
var existsingDependency = FindRoot(root);
if (existsingDependency == null)
{
existsingDependency = new DependencyEntry(root);
m_Graph.Add(existsingDependency);
}
foreach (var dependency in dependencies)
{
var dep = FindRoot(dependency)
?? InternalAddDependencies(dependency);
existsingDependency.m_Dependencies.Add(dep);
}
return(existsingDependency);
}
private void resolveItem(XmlNode node, IDictionary <string, DependencyEntry> collector)
{
XmlAttribute attrName = node.Attributes[ATTR_NAME];
XmlAttribute attrType = node.Attributes[ATTR_TYPE];
if (attrName == null)
{
throw new XmlException("Xml file " + _fileName + " has incorrect format: missing attribute " + ATTR_NAME + " in element " + TAG_ITEM);
}
string name = attrName.Value;
string type = null;
if (attrType == null || StringUtils.isEmpty(attrType.Value))
{
type = DEPENDENCY_TYPE_ONTOLINGUA;
}
else
{
type = attrType.Value;
}
if (!accept(type))
{
throw new XmlException("Xml file " + _fileName + " has incorrect format: unknown value " + type + " of attribute " + ATTR_TYPE);
}
DependencyEntry entry = new DependencyEntry(type);
XmlNodeList dependencies = node.ChildNodes;
if (dependencies != null)
{
for (int k = 0; k < dependencies.Count; k++)
{
XmlNode dependency = dependencies[k];
if (TAG_DEPENDENCY.Equals(dependency.LocalName))
{
entry.addDependency(dependency.InnerText);
}
}
}
collector.Add(name, entry);
}
public ResolverContext(DependencyEntry dependencyEntry)
{
if (dependencyEntry == null) throw new ArgumentNullException(nameof(dependencyEntry));
DependencyEntry = dependencyEntry;
}
internal static IDependencyRegistration ForDelegate <TService>(Type serviceType, Func <IDependencyResolver, TService> implementationDelegate)
where TService : class
{
return(new DependencyRegistration(
DependencyEntry.ForDelegate(serviceType, DependencyLifetime.Transient, implementationDelegate)));
}
internal static IDependencyRegistration ForInstance(Type serviceType, Object implementationInstance)
{
return(new DependencyRegistration(
DependencyEntry.ForInstance(serviceType, DependencyLifetime.Transient, implementationInstance)));
}
internal static IDependencyRegistration ForType(Type serviceType, Type implementationType)
{
return(new DependencyRegistration(
DependencyEntry.ForType(serviceType, DependencyLifetime.Transient, implementationType)));
}
private bool TryGetDependency(FullKey key, int hashCode, out DependencyEntry dependencyEntry)
{
lock (_eventSubject)
{
dependencyEntry = _dependencies.Get(hashCode, key);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
dependencyEntry = _dependencies.Get(hashCode, key);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
var type = key.Type;
var typeDescriptor = type.Descriptor();
// Generic type
if (typeDescriptor.IsConstructedGenericType())
{
var genericType = typeDescriptor.GetGenericTypeDefinition();
var genericKey = new FullKey(genericType, key.Tag);
// For generic type
dependencyEntry = _dependencies.Get(genericKey.GetHashCode(), genericKey);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
// For generic type and Any tag
dependencyEntry = _dependenciesForTagAny.GetByRef(genericType.GetHashCode(), genericType);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
}
// For Any tag
dependencyEntry = _dependenciesForTagAny.GetByRef(type.GetHashCode(), type);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
// For array
if (typeDescriptor.IsArray())
{
var arrayType = typeof(IArray);
var arrayKey = new FullKey(arrayType, key.Tag);
// For generic type
dependencyEntry = _dependencies.Get(arrayKey.GetHashCode(), arrayKey);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
// For generic type and Any tag
dependencyEntry = _dependenciesForTagAny.GetByRef(arrayType.GetHashCode(), arrayType);
if (dependencyEntry != default(DependencyEntry))
{
return(true);
}
}
return(false);
}
}
public DependencyRegistration(DependencyEntry entry)
{
Entry = entry;
}
/// <summary>
/// 获取委托缓存的key
/// </summary>
internal static Tuple<Type, Type> GetCompileKey(DependencyEntry depencyEntry)
{
return new Tuple<Type, Type>(depencyEntry.ServiceType, depencyEntry.GetImplementationType());
}
public bool TryRegisterDependency(IEnumerable <FullKey> keys, IDependency dependency, ILifetime lifetime, out IDisposable dependencyToken)
{
if (keys == null)
{
throw new ArgumentNullException(nameof(keys));
}
if (dependency == null)
{
throw new ArgumentNullException(nameof(dependency));
}
var isRegistered = true;
var registeredKeys = new List <FullKey>();
var dependencyEntry = new DependencyEntry(dependency, lifetime, Disposable.Create(UnregisterKeys), registeredKeys);
void UnregisterKeys()
{
lock (_eventSubject)
{
foreach (var curKey in registeredKeys)
{
if (curKey.Tag == AnyTag)
{
TryUnregister(curKey, curKey.Type, ref _dependenciesForTagAny);
}
else
{
TryUnregister(curKey, curKey, ref _dependencies);
}
}
_eventSubject.OnNext(new ContainerEvent(this, EventType.DependencyUnregistration, registeredKeys));
}
}
try
{
var dependenciesForTagAny = _dependenciesForTagAny;
var dependencies = _dependencies;
lock (_eventSubject)
{
foreach (var curKey in keys)
{
var type = curKey.Type.ToGenericType();
var key = type != curKey.Type ? new FullKey(type, curKey.Tag) : curKey;
if (key.Tag == AnyTag)
{
var hashCode = key.Type.GetHashCode();
isRegistered &= dependenciesForTagAny.GetByRef(hashCode, key.Type) == default(DependencyEntry);
if (isRegistered)
{
dependenciesForTagAny = dependenciesForTagAny.Set(hashCode, key.Type, dependencyEntry);
}
}
else
{
var hashCode = key.GetHashCode();
isRegistered &= dependencies.Get(hashCode, key) == default(DependencyEntry);
if (isRegistered)
{
dependencies = dependencies.Set(hashCode, key, dependencyEntry);
}
}
if (!isRegistered)
{
break;
}
registeredKeys.Add(key);
}
if (isRegistered)
{
_dependenciesForTagAny = dependenciesForTagAny;
_dependencies = dependencies;
_eventSubject.OnNext(new ContainerEvent(this, EventType.DependencyRegistration, registeredKeys));
}
}
}
catch (Exception)
{
isRegistered = false;
throw;
}
finally
{
if (isRegistered)
{
dependencyToken = dependencyEntry;
}
else
{
dependencyEntry.Dispose();
dependencyToken = default(IDisposable);
}
}
return(isRegistered);
}
public DependencyRegistration(DependencyEntry entry)
{
Entry = entry;
}
