/// <summary>
/// 创建解析插件
/// </summary>
/// <param name="bundle"></param>
public ResolverNode CreateResolverBundle(AbstractBundle bundle)
{
try
{
// 建立跟踪器
Tracker tracker = new Tracker();
// 建立依赖关系
ResolverNode resolverBundle = new ResolverNode(this, bundle, null);
// 内部调用解析插件构造器
InternalCreateResolverBundle(tracker, resolverBundle, bundle);
// 检查当前插件是否已解析,并且解析失败
if (bundle.ResolveState != (ResolveState.Resolved | ResolveState.Success))
{
return(null);
}
return(resolverBundle);
}
catch (Exception ex)
{
Log.Debug(ex);
// 记录错误
}
return(null);
}
public ResolverNode(ResolverTree resolverAdmin, AbstractBundle bundle, ResolverNode depencyProviderBy)
{
this.resolverAdmin = resolverAdmin;
this.depencyProvidersBy = new ResolverNodeCollection();
dependencies = new ResolverNodeCollection();
this.bundle = bundle;
this.depencyProvidersBy.Add(depencyProviderBy);
}
/// <summary>
/// 解析插件启动策略，如果启动插件本身是立即启动，则会导致其依赖项也会启动
/// </summary>
internal void ResolveBundleStartPolicy(ResolverNode resolverNode, ActivatorPolicy policy)
{
// 检查当前解析解点，并进行启动策略处理
if (policy == ActivatorPolicy.Immediate &&
resolverNode.Bundle.ActivatorPolicy == ActivatorPolicy.Lazy)
{
resolverNode.Bundle.ActivatorPolicy = policy;
}
// 变更当前上下文策略
if (resolverNode.Bundle.ActivatorPolicy == ActivatorPolicy.Immediate)
{
policy = ActivatorPolicy.Immediate;
}
// 处理依赖解析插件解点启动策略
foreach (ResolverNode dependency in resolverNode.Dependencies)
{
ResolveBundleStartPolicy(dependency, policy);
}
}
/// <summary>
/// 根据插件列表创建解析管理器
/// </summary>
/// <param name="bundle"></param>
/// <returns></returns>
public static ResolverTree Parse(Framework framework, ResolverImpl resolver, IList <AbstractBundle> bundles)
{
Hashtable cache = new Hashtable();
ResolverTree admin = new ResolverTree(framework, resolver);
foreach (AbstractBundle bundle in bundles)
{
if (!cache.Contains(bundle.ToString()))
{
ResolverNode resolverBundle = admin.CreateResolverBundle(bundle);
if (resolverBundle != null)
{
//resolver.ResolveBundleStartPolicy(resolverBundle, ActivatorPolicy.Lazy);
admin.resolvers.Add(resolverBundle);
cache.Add(bundle.ToString(), bundle);
}
}
}
return(admin);
}
/// <summary>
/// 获取有序的依赖插件序列
/// </summary>
/// <returns></returns>
public IList <AbstractBundle> QueryBundlesInOrder()
{
if (resolvers.Count == 0)
{
return(null);
}
// 创建插件列表
IList <AbstractBundle> bundles = new List <AbstractBundle>();
IList <ResolverNode> lResolvers = new List <ResolverNode>();
// 获取当前所有解析的跟节点
ResolverNode[] resolverBundles = new ResolverNode[leafResolverBundles.Count];
leafResolverBundles.Values.CopyTo(resolverBundles, 0);
BundleUtil.Sort(resolverBundles, 0, resolverBundles.Length);
// 放入有序队列中
Combine(bundles, resolverBundles);
// 解析下一个层次
ScanBundlesByOrder(bundles, resolverBundles);
return(bundles);
}
/// <summary>
/// 内部创建解析插件
/// </summary>
/// <param name="bundle"></param>
private void InternalCreateResolverBundle(Tracker tracker, ResolverNode depencyProviderBy, AbstractBundle bundle)
{
// 检查当前插件是否已解析,并且解析失败
if (bundle.ResolveState == (ResolveState.Resolved | ResolveState.Fault))
{
return;
}
// 检查缓存中是否存在,如果存在则说明出现了循环依赖
if (tracker.Contains(depencyProviderBy))
{
LinkedListNode <ResolverNode> dependencyNode = tracker.Find(depencyProviderBy);
if (dependencyNode.Next != null)
{
return;
}
}
// 将当前解析插件放入追踪链中
tracker.AddLast(depencyProviderBy);
// 获取所有依赖
DependentBundle[] dependencies = bundle.BundleData.DependentBundles;
bool isResolved = false;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
// 检查依赖插件唯一标示名是否为空，为空则视依赖项无效
if (string.IsNullOrEmpty(dependency.BundleSymbolicName))
{
continue;
}
// 获取插件
AbstractBundle dependencyBundle = framework.Bundles.GetBundle(dependency.BundleSymbolicName, dependency.BundleVersion);
if ((dependencyBundle == null || dependencyBundle.IsFragment) &&
dependency.Resolution == ResolutionMode.Mandatory)
{
// 设置解析状态
bundle.ResolveState = ResolveState.Resolved | ResolveState.Fault;
// 将当前解析插件从追踪器中移除
tracker.Remove(depencyProviderBy);
return;
}
// 构建解析插件对象
string key = dependencyBundle.ToString();
bool exist = trackCache.ContainsKey(key);
ResolverNode resolverBundle = !exist ? new ResolverNode(this, dependencyBundle, depencyProviderBy)
: trackCache[key] as ResolverNode;
if (exist)
{
resolverBundle.DepencyProvidersBy.Add(depencyProviderBy);
}
// 嵌套搜索解析
if (!exist)
{
InternalCreateResolverBundle(tracker, resolverBundle, dependencyBundle);
}
// 检查是否解析成功
isResolved = resolverBundle.Bundle.ResolveState == (ResolveState.Resolved | ResolveState.Success);
if (!isResolved && dependency.Resolution == ResolutionMode.Mandatory)
{
// 设置解析状态
bundle.ResolveState = ResolveState.Resolved | ResolveState.Fault;
// 将当前解析插件从追踪器中移除
tracker.Remove(depencyProviderBy);
return;
}
// 加入到依赖项中
depencyProviderBy.Dependencies.Add(resolverBundle);
// 调整逆向层级关系
int desLevel = resolverBundle.DesLevel + 1;
if (desLevel > depencyProviderBy.DesLevel)
{
depencyProviderBy.DesLevel = desLevel;
}
}
}
// 未解析状态下，解析当前插件，并设置解析状态
if (bundle.ResolveState == ResolveState.Unresolved)
{
if (!resolver.ResolvePackage(bundle))
{
bundle.ResolveState = ResolveState.Resolved | ResolveState.Fault;
}
else
{
bundle.ResolveState = ResolveState.Resolved | ResolveState.Success;
// 加入缓存
string key = bundle.ToString();
if (!trackCache.ContainsKey(key))
{
trackCache.Add(key, depencyProviderBy);
}
// 记录叶子节点
key = depencyProviderBy.Bundle.ToString();
if (leafResolverBundles.ContainsKey(key))
{
if (depencyProviderBy.Dependencies.Count > 0)
{
leafResolverBundles.Remove(key);
}
}
else if (depencyProviderBy.Dependencies.Count == 0)
{
leafResolverBundles.Add(key, depencyProviderBy);
}
}
}
// 将当前解析插件从追踪器中移除
tracker.Remove(depencyProviderBy);
}