public static void RegisterVirtualPathProvider(VirtualPathProvider virtualPathProvider)
{
if (HttpRuntime.AppDomainAppVirtualPath == null)
{
throw new InvalidOperationException();
}
if (virtualPathProvider == null)
{
throw new ArgumentNullException("virtualPathProvider");
}
VirtualPathProvider previous = vpath_provider;
vpath_provider = virtualPathProvider;
vpath_provider.InitializeAndSetPrevious(previous);
if (!(virtualPathProvider is DefaultVirtualPathProvider))
{
HaveCustomVPP = true;
}
else
{
HaveCustomVPP = false;
}
}
public void RegisterVirtualPathProvider(VirtualPathProvider virtualPathProvider)
{
// Sets up the provider chain
var previousField = typeof(VirtualPathProvider).GetField("_previous", BindingFlags.NonPublic | BindingFlags.Instance);
previousField.SetValue(virtualPathProvider, VirtualPathProvider);
VirtualPathProvider = virtualPathProvider;
}
/// <summary>
/// 利用指定 VirtualPathProvider 将虚拟路径所指向文件当作静态文件加载。
/// </summary>
/// <param name="provider">指定的 VirtualPathProvider</param>
/// <param name="virtualPath">虚拟路径</param>
/// <returns>加载结果</returns>
public HtmlContentResult LoadContent( VirtualPathProvider provider, string virtualPath )
{
if ( !VirtualPathUtility.IsAppRelative( virtualPath ) )
return null;
if ( !provider.FileExists( virtualPath ) )
return null;
var file = provider.GetFile( virtualPath );
if ( file == null )
return null;
var key = provider.GetCacheKey( virtualPath ) ?? "StaticFile_" + virtualPath;
var content = HttpRuntime.Cache.Get( key ) as string;
if ( content == null )
{
var dependency = HtmlServices.CreateCacheDependency( provider, virtualPath );
content = LoadContent( file );
HttpRuntime.Cache.Insert( key, content, dependency );
}
return new HtmlContentResult( content, key );
}
/*
* Helper method to open a file from its virtual path
*/
public static Stream OpenFile(string virtualPath)
{
VirtualPathProvider vpathProvider = HostingEnvironment.VirtualPathProvider;
VirtualFile vfile = vpathProvider.GetFileWithCheck(virtualPath);
return(vfile.Open());
}
public EPiServerHostingEnvironment()
{
//We need the first provider to be one that doesn't delegates to its parent.
//The default hosting environment uses a MapPathBasedVirtualPathProvider but that's internal
//so we use our custom dummy provider.
_provider = new DummyVirtualPathProvider();
}
public void Register(VirtualPathProvider provider)
{
if (provider == null)
throw new ArgumentNullException("provider");
_providers.Add(provider);
}
public virtual IEnumerable<ViewTemplateDescription> FindRegistrations(VirtualPathProvider vpp, HttpContextBase httpContext, IEnumerable<ViewTemplateSource> sources)
{
foreach (var source in sources)
{
string virtualDir = "~/Views/" + source.ControllerName;
if (!vpp.DirectoryExists(virtualDir))
continue;
List<ViewTemplateDescription> descriptions = new List<ViewTemplateDescription>();
foreach (var file in vpp.GetDirectory(virtualDir).Files.OfType<VirtualFile>().Where(f => f.Name.EndsWith(source.ViewFileExtension)))
{
var description = AnalyzeView(httpContext, file, source.ControllerName, source.ModelType);
if (description != null)
descriptions.Add(description);
}
foreach (var description in descriptions)
{
description.Definition.Add(new TemplateSelectorAttribute
{
Name = "TemplateName",
Title = "Template",
AllTemplates = descriptions.Select(d => new TemplateSelectorAttribute.Info { Name = d.Registration.Template, Title = d.Registration.Title }).ToArray(),
ContainerName = source.TemplateSelectorContainerName,
Required = true,
HelpTitle = "The page must be saved for another template's fields to appear",
RequiredPermission = Security.Permission.Administer
});
}
foreach (var description in descriptions)
yield return description;
}
}
internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
{
if (viewPageActivator != null)
{
_viewPageActivator = viewPageActivator;
}
else
{
_activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
() => null,
new DefaultViewPageActivator(dependencyResolver),
"BuildManagerViewEngine constructor");
}
if (pathProvider != null)
{
Func<VirtualPathProvider> providerFunc = () => pathProvider;
_fileExistsCache = new FileExistenceCache(providerFunc);
VirtualPathProviderFunc = providerFunc;
}
else
{
if (_sharedFileExistsCache == null)
{
// Startup initialization race is OK providing service remains read-only
_sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
}
_fileExistsCache = _sharedFileExistsCache;
}
}
public virtual IEnumerable<ContentRegistration> AnalyzeViews(VirtualPathProvider vpp, HttpContextBase httpContext, IEnumerable<ViewTemplateSource> sources)
{
var registrations = new List<ContentRegistration>();
foreach (var source in sources)
{
string virtualDir = Url.ResolveTokens(Url.ThemesUrlToken) + "Default/Views/" + source.ControllerName;
logger.DebugFormat("Analyzing directory {0}", virtualDir);
if (!vpp.DirectoryExists(virtualDir))
{
virtualDir = "~/Views/" + source.ControllerName;
if (!vpp.DirectoryExists(virtualDir))
continue;
}
foreach (var file in vpp.GetDirectory(virtualDir).Files.OfType<VirtualFile>().Where(f => f.Name.EndsWith(source.ViewFileExtension)))
{
logger.DebugFormat("Analyzing file {0}", file.VirtualPath);
var registration = AnalyzeView(httpContext, file, source.ControllerName, source.ModelType);
if (registration != null)
registrations.Add(registration);
}
}
return registrations;
}
internal static CacheDependency GetCacheDependency(VirtualPath virtualPath)
{
VirtualPathProvider vpathProvider = HostingEnvironment.VirtualPathProvider;
return(vpathProvider.GetCacheDependency(virtualPath,
new SingleObjectCollection(virtualPath.VirtualPathString), DateTime.MaxValue));
}
private void Write(HttpContext context, VirtualPathProvider vpp, string cssPath)
{
var mappedPath = context.Server.MapPath(cssPath);
if(File.Exists(mappedPath))
context.Response.AddFileDependency(mappedPath);
var file = vpp.GetFile(cssPath);
using (var s = file.Open())
using (var tr = new StreamReader(s))
{
while (tr.Peek() >= 0)
{
var line = tr.ReadLine();
string importPath = GetImportedPath(context, vpp, cssPath, line);
if (string.IsNullOrEmpty(importPath))
// process all lines except imports
context.Response.Write(Process(line, VirtualPathUtility.GetDirectory(cssPath)));
else if (vpp.FileExists(importPath))
// recurse into imports and output
Write(context, vpp, importPath);
else
// fallback just write the line
context.Response.Write(line);
context.Response.Write(Environment.NewLine);
}
}
}
public ContentPathProvider(VirtualPathProvider baseProvider, Configuration.Configuration services)
{
_baseProvider = baseProvider;
_config = services;
_internalResources = new Dictionary<string, string>();
switch (_config.ViewEngineOptions.Type)
{
case Configuration.ViewEngineType.Razor:
_extension = ".cshtml";
break;
case Configuration.ViewEngineType.ASPX:
_extension = ".aspx";
break;
default:
throw new ArgumentException("Invalid ViewEngine Specified.");
}
Action<string> addResource = (file) =>
_internalResources.Add(file + _extension, string.Format("Meek.Content.{0}.{1}{2}", _config.ViewEngineOptions.Type.ToString(), file, _extension));
addResource("Manage");
addResource("CreatePartial");
addResource("List");
addResource("BrowseFiles");
addResource("UploadFileSuccess");
}
public FileExistenceCache(VirtualPathProvider virtualPathProvider, int milliSecondsBeforeReset = 1000)
{
Contract.Assert(virtualPathProvider != null);
_virtualPathProvider = virtualPathProvider;
_virtualPathFileExists = virtualPathProvider.FileExists;
_ticksBeforeReset = milliSecondsBeforeReset * TicksPerMillisecond;
Reset();
}
public override void SetUp()
{
base.SetUp();
var routeData = new RouteData();
routeData.Values["controller"] = "MyController";
virtualPathProvider = new XsltTestVirtualPathProvider();
_context = new ControllerContext(HttpContext, routeData, MockRepository.GenerateStub<ControllerBase>());
mockRepository.ReplayAll();
}
public BuildManagerDirectoryBuilder (VirtualPath virtualPath)
{
if (virtualPath == null)
throw new ArgumentNullException ("virtualPath");
this.vpp = HostingEnvironment.VirtualPathProvider;
this.virtualPath = virtualPath;
this.virtualPathDirectory = VirtualPathUtility.GetDirectory (virtualPath.Absolute);
}
/// <summary>
/// Initialise a new Pattern Lab view
/// </summary>
/// <param name="engine">The current view engine</param>
/// <param name="controllerContext">The current controller context</param>
/// <param name="virtualPathProvider">The current virtual path provider</param>
/// <param name="viewPath">The path to the view</param>
/// <param name="masterPath">The optional path to the master view</param>
/// <param name="parameters">Any pattern parameters</param>
public MustacheView(MustacheViewEngine engine, ControllerContext controllerContext,
VirtualPathProvider virtualPathProvider, string viewPath, string masterPath, Dictionary<string, object> parameters)
{
_engine = engine;
_controllerContext = controllerContext;
_masterPath = masterPath;
_parameters = parameters;
_viewPath = viewPath;
_virtualPathProvider = virtualPathProvider;
}
internal static VirtualPath CombineVirtualPathsInternal(VirtualPath basePath, VirtualPath relativePath)
{
VirtualPathProvider virtualPathProvider = HostingEnvironment.VirtualPathProvider;
if (virtualPathProvider != null)
{
return(virtualPathProvider.CombineVirtualPaths(basePath, relativePath));
}
return(basePath.Parent.Combine(relativePath));
}
/*
* Helper method to call CombineVirtualPaths if there is a VirtualPathProvider
*/
internal static VirtualPath CombineVirtualPathsInternal(VirtualPath basePath, VirtualPath relativePath)
{
VirtualPathProvider vpathProvider = HostingEnvironment.VirtualPathProvider;
if (vpathProvider != null)
{
return(vpathProvider.CombineVirtualPaths(basePath, relativePath));
}
// If there is no provider, just combine them normally
return(basePath.Parent.Combine(relativePath));
}
private static string ResolveThemedContent(HttpContextBase httpContext, VirtualPathProvider vpp, string contentPath)
{
string theme = httpContext.GetTheme();
if (string.IsNullOrEmpty(theme))
return Url.ToAbsolute(contentPath);
string themeContentPath = "~/Themes/" + theme + contentPath.TrimStart('~');
if (!vpp.FileExists(themeContentPath))
return Url.ToAbsolute(contentPath);
return Url.ToAbsolute(themeContentPath);
}
public virtual IEnumerable<ContentRegistration> AnalyzeViews(VirtualPathProvider vpp, HttpContextBase httpContext, IEnumerable<ViewTemplateSource> sources)
{
var registrations = new List<ContentRegistration>();
foreach (var source in sources)
{
var virtualDirList = new List<string>
{
Url.ResolveTokens(Url.ThemesUrlToken) + "Default/Views/" + source.ControllerName,
"~/Views/" + source.ControllerName
};
virtualDirList.AddRange(
from virtualDirectory in vpp.GetDirectory("~/Areas/").Directories.Cast<VirtualDirectory>()
let virtualPath = String.Format("~/Areas/{0}/Views/{1}", virtualDirectory.Name, source.ControllerName)
select virtualPath);
foreach (var virtualDir in virtualDirList.Where(vpp.DirectoryExists))
{
logger.Debug(String.Format("Analyzing directory {0}", virtualDir));
foreach (var file in vpp.GetDirectory(virtualDir).Files.OfType<VirtualFile>())
{
Debug.Assert(file.Name != null, "file.Name != null");
if (!file.Name.EndsWith(source.ViewFileExtension) || file.Name.StartsWith("_"))
{
logger.Info(String.Format("Skipping file {0}", file.VirtualPath));
continue;
}
logger.Debug(String.Format("Analyzing file {0}", file.VirtualPath));
ContentRegistration registration = null;
if (httpContext.IsDebuggingEnabled)
{
registration = AnalyzeView(httpContext, file, source.ControllerName, source.ModelType);
}
else
{
try
{
registration = AnalyzeView(httpContext, file, source.ControllerName, source.ModelType);
}
catch (Exception ex)
{
logger.Error(ex);
}
}
if (registration != null)
registrations.Add(registration);
}
}
}
return registrations;
}
public ResourcePathProvider(IEnumerable<Assembly> assemblies, VirtualPathProvider previous)
{
this.previous = previous;
resources = new Dictionary<string, EmbeddedFile>();
foreach (var embeddedFile in assemblies.SelectMany(a => a.GetManifestResourceNames().Select(n => new EmbeddedFile(a, n))))
{
if (!resources.ContainsKey(embeddedFile.Key))
{
resources.Add(embeddedFile.Key, embeddedFile);
}
}
}
public static Stream OpenFile(string virtualPath)
{
// This thing throws a nullref when we're not inside an ASP.NET appdomain, which is what MS does.
VirtualPathProvider provider = HostingEnvironment.VirtualPathProvider;
VirtualFile file = provider.GetFile(virtualPath);
if (file != null)
{
return(file.Open());
}
return(null);
}
public ContentPathProvider(VirtualPathProvider baseProvider, Configuration.Configuration services)
{
_baseProvider = baseProvider;
_config = services;
_internalResources = new Dictionary<string, string>()
{
{"Manage.cshtml", "Meek.Content.Manage.cshtml"},
{"CreatePartial.cshtml", "Meek.Content.CreatePartial.cshtml"},
{"List.cshtml", "Meek.Content.List.cshtml"},
{"BrowseFiles.cshtml", "Meek.Content.BrowseFiles.cshtml"},
{"UploadFileSuccess.cshtml", "Meek.Content.UploadFileSuccess.cshtml"}
};
}
public BuildManagerDirectoryBuilder (VirtualPath virtualPath)
{
if (virtualPath == null)
throw new ArgumentNullException ("virtualPath");
this.vpp = HostingEnvironment.VirtualPathProvider;
this.virtualPath = virtualPath;
this.virtualPathDirectory = VirtualPathUtility.GetDirectory (virtualPath.Absolute);
if (HttpRuntime.CaseInsensitive) {
this.stringComparer = StringComparison.OrdinalIgnoreCase;
this.dictionaryComparer = StringComparer.OrdinalIgnoreCase;
} else {
this.stringComparer = StringComparison.Ordinal;
this.dictionaryComparer = StringComparer.Ordinal;
}
}
public XsltViewFactory(VirtualPathProvider virtualPathProvider)
{
if(virtualPathProvider != null)
{
VirtualPathProvider = virtualPathProvider;
}
MasterLocationFormats = new string[0];
ViewLocationFormats = new[]
{
"~/Views/{1}/{0}.xslt",
"~/Views/Shared/{0}.xslt"
};
PartialViewLocationFormats = ViewLocationFormats;
}
private static string ResolveThemedContent(RequestContext requestContext, VirtualPathProvider vpp, string contentPath)
{
string themeFolderPath = requestContext.RouteData.DataTokens["ThemeViewEngine.ThemeFolderPath"] as string
?? Url.ResolveTokens(Url.ThemesUrlToken);
string theme = requestContext.HttpContext.GetTheme();
if (!string.IsNullOrEmpty(theme))
{
string themeContentPath = themeFolderPath + theme + contentPath.TrimStart('~');
if (vpp.FileExists(themeContentPath))
return Url.ToAbsolute(themeContentPath);
}
string defaultThemeContentPath = themeFolderPath + "Default" + contentPath.TrimStart('~');
if (vpp.FileExists(defaultThemeContentPath))
return Url.ToAbsolute(defaultThemeContentPath);
return Url.ToAbsolute(contentPath);
}
public virtual IEnumerable<ViewTemplateDescription> FindRegistrations(VirtualPathProvider vpp, HttpContextBase httpContext, IEnumerable<ViewTemplateSource> sources)
{
foreach (var source in sources)
{
string virtualDir = "~/Views/" + source.ControllerName;
if (!vpp.DirectoryExists(virtualDir))
continue;
List<ViewTemplateDescription> descriptions = new List<ViewTemplateDescription>();
foreach (var file in vpp.GetDirectory(virtualDir).Files.OfType<VirtualFile>().Where(f => f.Name.EndsWith(source.ViewFileExtension)))
{
var description = AnalyzeView(httpContext, file, source.ControllerName, source.ModelType);
if (description != null)
descriptions.Add(description);
}
foreach (var description in descriptions)
yield return description;
}
}
/// <summary>
/// 在指定虚拟路径上溯搜索指定文件名的文件
/// </summary>
/// <param name="provider">自定义的虚拟路径提供程序</param>
/// <param name="virtualPath">要搜索的虚拟路径</param>
/// <param name="fileNames">要搜索的文件名列表</param>
/// <returns>返回找到的文件路径，若无法找到匹配的文件，则返回null</returns>
public static string FallbackSearch( VirtualPathProvider provider, string virtualPath, params string[] fileNames )
{
if ( !VirtualPathUtility.IsAppRelative( virtualPath ) )
throw VirtualPathFormatError( "virtualPath" );
while ( true )
{
virtualPath = GetParentDirectory( virtualPath );
if ( virtualPath == null )
break;
foreach ( var name in fileNames )
{
var filePath = VirtualPathUtility.Combine( virtualPath, name );
if ( provider.FileExists( filePath ) )
return filePath;
}
}
return null;
}
public FileExistenceCache(VirtualPathProvider virtualPathProvider, int milliSecondsBeforeReset = 1000)
{
_virtualPathProvider = virtualPathProvider;
_ticksBeforeReset = milliSecondsBeforeReset * TickPerMiliseconds;
Reset();
}
private FileMonitor(VirtualPathProvider vpp,
Action<string> changeCallback)
{
_vpp = vpp;
_changeCallback = changeCallback;
}
public ThemeVarsVirtualPathProvider(VirtualPathProvider previous)
{
_previous = previous;
}
public VirtualPathFileHandler(VirtualPathProvider vpp)
{
this.vpp = vpp;
}
public VirtualPathFileHandler()
{
vpp = HostingEnvironment.VirtualPathProvider;
}
// for testing purposes
internal FilterFactory(VirtualPathProvider vpp)
: this() {
_templateFactory.VirtualPathProvider = vpp;
}
private ConfigFileChangeNotifier(VirtualPathProvider vpp,
Action<string> changeCallback)
{
_vpp = vpp;
_changeCallback = changeCallback;
}
public ScriptBundlePathProvider(VirtualPathProvider virtualPathProvider)
{
_virtualPathProvider = virtualPathProvider;
}
public static void RegisterVirtualPathProvider(VirtualPathProvider virtualPathProvider)
{
}
internal void InitializeAndSetPrevious(VirtualPathProvider prev)
{
this.prev = prev;
Initialize();
}
internal virtual void Initialize(VirtualPathProvider previous)
{
this._previous = previous;
this.Initialize();
}