public InMemoryVirtualDirectory(IVirtualPathProvider owningProvider) 
     : base(owningProvider)
 {
     this.files = new List<InMemoryVirtualFile>();
     this.dirs = new List<InMemoryVirtualDirectory>();
     this.DirLastModified = DateTime.MinValue;
 }

        public ThemeService(
            IOrchardServices orchardServices,
            IExtensionManager extensionManager,
            IFeatureManager featureManager,
            IEnumerable<IThemeSelector> themeSelectors,
            IVirtualPathProvider virtualPathProvider,
            ICacheManager cacheManager,
            ISiteThemeService siteThemeService) {

            Services = orchardServices;

            _extensionManager = extensionManager;
            _featureManager = featureManager;
            _themeSelectors = themeSelectors;
            _virtualPathProvider = virtualPathProvider;
            _cacheManager = cacheManager;
            _siteThemeService = siteThemeService;

            if (_featureManager.FeatureDependencyNotification == null) {
                _featureManager.FeatureDependencyNotification = GenerateWarning;
            }

            Logger = NullLogger.Instance;
            T = NullLocalizer.Instance;
        }

        public PlacementService(
            IContentManager contentManager,
            ISiteThemeService siteThemeService,
            IExtensionManager extensionManager,
            IShapeFactory shapeFactory,
            IShapeTableLocator shapeTableLocator,
            RequestContext requestContext,
            IEnumerable<IContentPartDriver> contentPartDrivers,
            IEnumerable<IContentFieldDriver> contentFieldDrivers,
            IVirtualPathProvider virtualPathProvider,
            IWorkContextAccessor workContextAccessor
            )
        {
            _contentManager = contentManager;
            _siteThemeService = siteThemeService;
            _extensionManager = extensionManager;
            _shapeFactory = shapeFactory;
            _shapeTableLocator = shapeTableLocator;
            _requestContext = requestContext;
            _contentPartDrivers = contentPartDrivers;
            _contentFieldDrivers = contentFieldDrivers;
            _virtualPathProvider = virtualPathProvider;
            _workContextAccessor = workContextAccessor;

            Logger = NullLogger.Instance;
        }

 public ReferencedExtensionLoader(IDependenciesFolder dependenciesFolder, IVirtualPathProvider virtualPathProvider, IBuildManager buildManager)
     : base(dependenciesFolder)
 {
     _virtualPathProvider = virtualPathProvider;
     _buildManager = buildManager;
     Logger = NullLogger.Instance;
 }

        /// <summary>
        /// 初始化一个新的扩展装载机。
        /// </summary>
        /// <param name="dependenciesFolder">依赖文件夹。</param>
        /// <param name="virtualPathProvider">虚拟路提供程序。</param>
        public RawThemeExtensionLoader(IDependenciesFolder dependenciesFolder, IVirtualPathProvider virtualPathProvider)
            : base(dependenciesFolder)
        {
            _virtualPathProvider = virtualPathProvider;

            Logger = NullLogger.Instance;
        }

        public static Stack<string> TokenizeVirtualPath(this string str, IVirtualPathProvider pathProvider)
        {
            if (pathProvider == null)
                throw new ArgumentNullException("pathProvider");

            return TokenizeVirtualPath(str, pathProvider.VirtualPathSeparator);
        }

 public DefaultVirtualPathMonitor(IClock clock, IVirtualPathProvider virtualPathProvider)
 {
     _clock = clock;
     _virtualPathProvider = virtualPathProvider;
     _thunk = new Thunk(this);
     Logger = NullLogger.Instance;
 }

        public ResourceFileService(
            IVirtualPathProvider virtualPathProvider)
        {
            _virtualPathProvider = virtualPathProvider;

            T = NullLocalizer.Instance;
        }

        public DefaultBuildManager(
            IVirtualPathProvider virtualPathProvider, 
            IAssemblyLoader assemblyLoader) {

            _virtualPathProvider = virtualPathProvider;
            _assemblyLoader = assemblyLoader;
        }

        public ImportedExtensionsProvider(
            IDependenciesFolder dependenciesFolder,
            IEnumerable<Assembly> extensions,
            IVirtualPathProvider virtualPathProvider)
            : base(dependenciesFolder)
        {
            // It's not nice to do this in the ctor but this way we spare to implement locking that would be needed with lazy-loading
            // and this class will be instantiated once anyway.
            _extensionsByName = extensions
                .ToDictionary
                (
                    assembly => assembly.ShortName(),
                    assembly => new Extension
                        {
                            Assembly = assembly,
                            Features = assembly
                                .GetExportedTypes()
                                .Where(type => type.GetCustomAttribute(typeof(OrchardFeatureAttribute)) != null)
                                .Select(type => ((OrchardFeatureAttribute)type.GetCustomAttribute(typeof(OrchardFeatureAttribute))).FeatureName)
                                .Union(new[] { assembly.ShortName() })
                                .Distinct()
                        }
                );

            _virtualPathProvider = virtualPathProvider;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WebAssetHttpHandler"/> class.
 /// </summary>
 /// <param name="assetRegistry">The asset registry.</param>
 /// <param name="httpResponseCompressor">The HTTP response compressor.</param>
 /// <param name="httpResponseCacher">The HTTP response cacher.</param>
 public JsHttpHandler(IHttpResponseCompressor httpResponseCompressor, IHttpResponseCacher httpResponseCacher,
     IVirtualPathProvider virtualPathProvider)
 {
     _httpResponseCompressor = httpResponseCompressor;
     _httpResponseCacher = httpResponseCacher;
     _virtualPathProvider = virtualPathProvider;
 }

        public WebSiteFolder(IVirtualPathMonitor virtualPathMonitor, IVirtualPathProvider virtualPathProvider)
        {
            _virtualPathMonitor = virtualPathMonitor;
            _virtualPathProvider = virtualPathProvider;

            Logger = NullLogger.Instance;
        }

        public PackageBuilder(IWebSiteFolder webSiteFolder,
            IVirtualPathProvider virtualPathProvider,
            IOrchardFrameworkAssemblies frameworkAssemblies) {

            _webSiteFolder = webSiteFolder;
            _virtualPathProvider = virtualPathProvider;
            _frameworkAssemblies = frameworkAssemblies;
        }

        protected AbstractVirtualDirectoryBase(IVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory)
        {
            if (owningProvider == null)
                throw new ArgumentNullException("owningProvider");

            this.VirtualPathProvider = owningProvider;
            this.ParentDirectory = parentDirectory;
        }

        public EditorSnippetBuilder(IList<DropDownItem> items)
        {
            Guard.IsNotNull(items, "items");

            pathProvider = ServiceLocator.Current.Resolve<IVirtualPathProvider>();

            this.items = items;
        }

 protected EditorImageBrowserController(IDirectoryBrowser directoryBrowser,
     IDirectoryPermission permission,
     IVirtualPathProvider pathProvider,
     IThumbnailCreator thumbnailCreator)
     : base(directoryBrowser, permission, pathProvider)
 {
     this.thumbnailCreator = thumbnailCreator;
 }

        public FileSystemVirtualDirectory(IVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory, DirectoryInfo dInfo)
            : base(owningProvider, parentDirectory)
        {
            if (dInfo == null)
                throw new ArgumentNullException("dInfo");

            this.BackingDirInfo = dInfo;
        }

        public FileSystemVirtualFile(IVirtualPathProvider owningProvider, IVirtualDirectory directory, FileInfo fInfo) 
            : base(owningProvider, directory)
        {
            if (fInfo == null)
                throw new ArgumentNullException("fInfo");

            this.BackingFile = fInfo;
        }

 public DynamicExtensionLoader(
     IVirtualPathProvider virtualPathProvider,
     IServiceProvider serviceProvider,
     IAssemblyLoaderContainer container)
 {
     _virtualPathProvider = virtualPathProvider;
     _serviceProvider = serviceProvider;
     _loaderContainer = container;
 }

 public DynamicExtensionLoader(
     IVirtualPathProvider virtualPathProvider,
     IAssemblyLoaderContainer container,
     IExtensionAssemblyLoader extensionAssemblyLoader)
 {
     _virtualPathProvider = virtualPathProvider;
     _loaderContainer = container;
     _extensionAssemblyLoader = extensionAssemblyLoader;
 }