/// <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); }