站在分析的角度去实现插件框架

protected void Application_Start()
        {
            // Engine初始化
            EngineContext.Initialize(DataSettingsHelper.DatabaseIsInstalled());
            // 添加自定义模型绑定
            ModelBinders.Binders.Add(typeof(BaseModel), new  AntiquatedModelBinder());
            if (DataSettingsHelper.DatabaseIsInstalled())
            {
                // 清空mvc所有viewengines
                ViewEngines.Engines.Clear();
                // 注册自定义mvc viewengines
                ViewEngines.Engines.Add(new ThemableRazorViewEngine());
            }
            // 自定义元数据验证
            ModelMetadataProviders.Current = new AntiquatedMetadataProvider();
            
            AreaRegistration.RegisterAllAreas();
            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
            DataAnnotationsModelValidatorProvider
                .AddImplicitRequiredAttributeForValueTypes = false;
            // 注册模型验证
            ModelValidatorProviders.Providers.Add(
                new FluentValidationModelValidatorProvider(new  AntiquatedValidatorFactory()));
            // 注册虚拟资源提供程序
            var viewResolver =  EngineContext.Current.Resolve<IAntiquatedViewResolver>();
            var viewProvider = new  ViewVirtualPathProvider(viewResolver.GetEmbeddedViews());
            HostingEnvironment.RegisterVirtualPathProvider(viewProvider);
        }

public static IEngine Current
{
     get
     {
         if (Singleton<IEngine>.Instance == null)
         {
              Initialize(true);
         }
         return Singleton<IEngine>.Instance;
     }
}

    /// <summary>
    /// IEngine
    /// </summary>
    public interface IEngine
    {
        /// <summary>
        /// ioc容器
        /// </summary>
        IDependencyResolver ContainerManager { get; }
        /// <summary>
        /// engine初始化
        /// </summary>
        /// <param name="config">engine配置</param>
        /// <param name="databaseIsInstalled">数据库初始化</param>
        void Initialize(AntiquatedConfig config, bool databaseIsInstalled);
        /// <summary>
        /// 反转对象-泛型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        T Resolve<T>() where T : class;
        /// <summary>
        /// 反转对象
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        object Resolve(Type type);
        IEnumerable<T> ResolveAll<T>();
    }

public class DefaultFacDependencyResolver : DisposableResource,  
Core.Ioc.IDependencyResolver, // 这就是我们上面贴出来的容器接口
IDependencyResolverMvc // MVC内置容器接口对象，实现mvc全局容器注入
{
        // autofac容器
        private IContainer _container;
        public IContainer Container { get { return _container; } }
        public System.Web.Mvc.IDependencyResolver dependencyResolverMvc { get =>  new AutofacDependencyResolver(_container); }
        public DefaultFacDependencyResolver() : this(new ContainerBuilder())
        {
        }
        public DefaultFacDependencyResolver(ContainerBuilder containerBuilder)
        {
            // build容器对象
            _container = containerBuilder.Build();
        }
        // ...... 此处省略其他代码
}

public class Engine : IEngine
    {
        public void Initialize(AntiquatedConfig config, bool databaseIsInstalled)
        {
                // 省略其他成员...
              ResolveAll<IBootstrapperTask>().ForEach(t => t.Execute());
        }
        // ...... 此处省略其他代码
    }

/// <summary>
    /// 插件
    /// </summary>
    public interface IPlugin
    {
        /// <summary>
        /// 插件描述对象
        /// </summary>
        PluginDescriptor PluginDescriptor { get; set; }
        /// <summary>
        /// 安装插件
        /// </summary>
        void Install();
        /// <summary>
        /// 卸载插件
        /// </summary>
        void Uninstall();
    }
 

    /// <summary>
    /// 插件描述对象
    /// </summary>
    public class PluginDescriptor : IComparable<PluginDescriptor>
    {
        public PluginDescriptor()
        {
        }
        /// <summary>
        /// 插件dll文件名称
        /// </summary>
        public virtual string PluginFileName { get; set; }
        /// <summary>
        /// 类型
        /// </summary>
        public virtual Type PluginType { get; set; }
        /// <summary>
        /// 插件归属组
        /// </summary>
        public virtual string Group { get; set; }
        /// <summary>
        /// 别名，友好名称
        /// </summary>
        public virtual string FriendlyName { get; set; }
        /// <summary>
        /// 插件系统名称，别名的一种
        /// </summary>
        public virtual string SystemName { get; set; }
        /// <summary>
        /// 插件版本
        /// </summary>
        public virtual string Version { get; set; }
        /// <summary>
        /// 插件作者
        /// </summary>
        public virtual string Author { get; set; }
        /// <summary>
        /// 显示顺序
        /// </summary>
        public virtual int DisplayOrder { get; set; }
        /// <summary>
        /// 是否安装
        /// </summary>
        public virtual bool Installed { get; set; }
        // 省略其他代码...
    }

// 程序集加载时自执行
[assembly: PreApplicationStartMethod(typeof(PluginManager), "Initialize")]
namespace Antiquated.Core.Plugins
{
    /// <summary>
    /// 插件管理
    /// </summary>
    public class PluginManager
    {
        // ...... 此处省略其他代码
        private static readonly ReaderWriterLockSlim Locker = new  ReaderWriterLockSlim();
        private static readonly string _pluginsPath = "~/Plugins";
        
        /// <summary>
        /// 插件管理初始化操作
        /// </summary>
        public static void Initialize()
        {
            using (new WriteLockDisposable(Locker))
            {
                
                try
                {
                    // ...... 此处省略其他代码
                    // 加载所有插件描述文件
                    foreach (var describeFile in  pluginFolder.GetFiles("PluginDescribe.txt", SearchOption.AllDirectories))
                    {
                        try
                        {
                            // 解析PluginDescribe.txt文件获取describe描述对象
                            var describe =  ParsePlugindescribeFile(describeFile.FullName);
                            if (describe == null)
                                continue;
 
                            // 解析插件是否已安装
                           describe.Installed = installedPluginSystemNames
                                .ToList()
                                .Where(x => x.Equals(describe.SystemName,  StringComparison.InvariantCultureIgnoreCase))
                                .FirstOrDefault() != null;
                            
                            // 获取所有插件dll文件
                            var pluginFiles =  describeFile.Directory.GetFiles("*.dll", SearchOption.AllDirectories)
                                .Where(x => !binFiles.Select(q =>  q.FullName).Contains(x.FullName))
                                .Where(x => IsPackagePluginFolder(x.Directory))
                                .ToList();
                            //解析插件dll主程序集
                            var mainPluginFile = pluginFiles.Where(x =>  x.Name.Equals(describe.PluginFileName,  StringComparison.InvariantCultureIgnoreCase))
　　　　　　　　　　　　　　　　　　.FirstOrDefault();
                           describe.OriginalAssemblyFile = mainPluginFile;
                            // 添加插件程序集引用
                            foreach (var plugin in pluginFiles.Where(x => !x.Name.Equals(mainPluginFile.Name,  StringComparison.InvariantCultureIgnoreCase)))
                                PluginFileDeploy(plugin);                    
                            // ...... 此处省略其他代码
                        }
                        catch (Exception ex)
                        {
                            thrownew Exception("Could not initialise plugin  folder", ex);;
                        }
                    }
                }
                catch (Exception ex)
                {
                    thrownew Exception("Could not initialise plugin folder",  ex);;
                }
            }
        }
        /// <summary>
        /// 插件文件副本部署并添加到应用程序域
        /// </summary>
        /// <param name="plug"></param>
        /// <returns></returns>
        private static Assembly PluginFileDeploy(FileInfo plug)
        {
            if (plug.Directory.Parent == null)
                throw new InvalidOperationException("The plugin directory for the "  + plug.Name +
                                                    " file exists in a folder outside of  the allowed Umbraco folder heirarchy");
            FileInfo restrictedPlug;
 
            var restrictedTempCopyPlugFolder=  Directory.CreateDirectory(_restrictedCopyFolder.FullName);  
            // copy移动插件文件到指定的文件夹             
            restrictedPlug = InitializePluginDirectory(plug,  restrictedTempCopyPlugFolder);
            // 此处省略代码...
 
            var restrictedAssembly =  Assembly.Load(AssemblyName.GetAssemblyName(restrictedPlug.FullName));
            BuildManager.AddReferencedAssembly(restrictedAssembly);
            return restrictedAssembly;
        }
        /// <summary>
        /// 插件安装
        /// </summary>
        /// <param name="systemName"></param>
        public static void Installed(string systemName)
        {
            // 此处省略其他代码....
 
            // 获取所有已安装插件
            var installedPluginSystemNames = InstalledPluginsFile();
            // 获取当前插件的安装状态
            bool markedInstalled = installedPluginSystemNames
                                .ToList()
                                .Where(x => x.Equals(systemName,  StringComparison.InvariantCultureIgnoreCase))
                                .FirstOrDefault() != null;
            // 如果当前插件状态为未安装状态，添加到待安装列表
            if (!markedInstalled)
                installedPluginSystemNames.Add(systemName);
            var text = MergeInstalledPluginsFile(installedPluginSystemNames);
            // 写入文件
            File.WriteAllText(filePath, text);
        }
        /// <summary>
        /// 插件卸载
        /// </summary>
        /// <param name="systemName"></param>
        public static void Uninstalled(string systemName)
        {
            // 此处省略其他代码....
                       //  逻辑同上
            File.WriteAllText(filePath, text);
        }
    }
 

   /// <summary>
        /// 系统初始化
        /// </summary>
        protected void Application_Start()
        {
            // 此处省略其他代码...
            // 注册虚拟资源提供程序
            var viewResolver =  EngineContext.Current.Resolve<IAntiquatedViewResolver>();
            var viewProvider = new  ViewVirtualPathProvider(viewResolver.GetEmbeddedViews());
            //注册
            HostingEnvironment.RegisterVirtualPathProvider(viewProvider);
        }

 /// <summary>
    /// 虚拟资源提供者
    /// </summary>
    public class ViewVirtualPathProvider : VirtualPathProvider
    {
        /// <summary>
        /// 嵌入的视图资源列表
        /// </summary>
        private readonly EmbeddedViewList _embeddedViews;
        /// <summary>
        /// 对象初始化
        /// </summary>
        /// <param name="embeddedViews"></param>
        public ViewVirtualPathProvider(EmbeddedViewList embeddedViews)
        {
            if (embeddedViews == null)
                throw new ArgumentNullException("embeddedViews");
            this._embeddedViews = embeddedViews;
        }
        
        /// <summary>
        /// 重写基类FileExists
        /// </summary>
        /// <param name="virtualPath"></param>
        /// <returns></returns>
        public override bool FileExists(string virtualPath)
        {
            // 如果虚拟路径文件存在
            return (IsEmbeddedView(virtualPath) ||
            Previous.FileExists(virtualPath));
        }
        /// <summary>
        /// 重写基类GetFile
        /// </summary>
        /// <param name="virtualPath"></param>
        /// <returns></returns>
        public override VirtualFile GetFile(string virtualPath)
        {
            // 判断是否为虚拟视图资源
            if (IsEmbeddedView(virtualPath))
            {
                // 部分代码省略...
                // 获取虚拟资源
                return new EmbeddedResourceVirtualFile(embeddedViewMetadata,  virtualPath);
            }
            return Previous.GetFile(virtualPath);
        }
    }