/// <summary>
/// 创建 HtmlContentResult 实例
/// </summary>
/// <param name="provider">负责加载的提供程序</param>
/// <param name="content">加载的内容</param>
/// <param name="virtualPath">内容的虚拟路径</param>
/// <param name="cacheKey">缓存内容所使用的缓存键</param>
public HtmlContentResult(IHtmlContentProvider provider, string content, string virtualPath, string cacheKey)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (content == null)
{
throw new ArgumentNullException("content");
}
if (virtualPath == null)
{
throw new ArgumentNullException("virtualPath");
}
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw HtmlProviders.VirtualPathFormatError("virtualPath");
}
Provider = provider;
Content = content;
VirtualPath = virtualPath;
CacheKey = cacheKey;
}
private void OnPreMapRequestHandler(object sender, EventArgs e)
{
var context = HttpContext.Current;
var request = context.Request;
var result = HtmlProviders.MapRequest(new HttpRequestWrapper(request));
if (result == null)
{
return;
}
var handler = result.Handler;
var httpHandler = handler as JumonyHandler;
if (httpHandler == null)
{
httpHandler = new HttpHandler(handler);
}
context.SetMapping(result);
context.RemapHandler(httpHandler);
}
/// <summary>
/// 检测是否能加载指定虚拟路径的文档内容
/// </summary>
/// <param name="virtualPath">虚拟路径</param>
/// <returns>是否能加载指定虚拟路径的文档内容</returns>
public bool CanLoadContent(string virtualPath)
{
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw HtmlProviders.VirtualPathFormatError("virtualPath");
}
return(SupportedExtensions.Contains(VirtualPathUtility.GetExtension(virtualPath)));
}
/// <summary>
/// 加载 HTML 文档内容
/// </summary>
/// <param name="virtualPath">虚拟路径</param>
/// <returns></returns>
public HtmlContentResult LoadContent(string virtualPath)
{
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw HtmlProviders.VirtualPathFormatError("virtualPath");
}
var provider = GetProvider(virtualPath);
return(provider.LoadContent(virtualPath));
}
private static Uri CreateDocumentUri(string virtualPath)
{
if (virtualPath == null)
{
throw new ArgumentNullException("virtualPath");
}
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw HtmlProviders.VirtualPathFormatError("virtualPath");
}
return(new Uri(baseUri, VirtualPathUtility.ToAbsolute(virtualPath)));
}
/// <summary>
/// 尝试获取缓存的输出
/// </summary>
/// <returns>缓存的输出</returns>
protected virtual ICachedResponse ResolveCache()
{
var policy = HtmlProviders.GetCachePolicy(HttpContext);
if (policy == null)
{
return(null);
}
CachePolicy = policy;
return(CachePolicy.ResolveCache());
}
/// <summary>
/// 派生类可以重写此方法自定义加载虚拟路径处的文档的逻辑
/// </summary>
/// <returns></returns>
protected virtual IHtmlDocument LoadDocument(string virtualPath, out CacheDependency cacheDependency)
{
string cacheKey;
var document = HtmlProviders.LoadDocument(virtualPath, out cacheKey);
if (cacheKey != null)
{
cacheDependency = new CacheDependency(new string[0], new string[] { cacheKey });
}
else
{
cacheDependency = HtmlProviders.CreateCacheDependency(virtualPath);
}
return(document);
}
/// <summary>
/// 获取指定虚拟路径的文档内容加载程序
/// </summary>
/// <param name="virtualPath">虚拟路径</param>
/// <returns></returns>
public IHtmlContentProvider GetProvider(string virtualPath)
{
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw HtmlProviders.VirtualPathFormatError("virtualPath");
}
var extensions = VirtualPathUtility.GetExtension(virtualPath);
IHtmlContentProvider provider;
lock ( _sync )
{
if (data.TryGetValue(extensions, out provider))
{
return(provider);
}
else
{
return(null);
}
}
}
/// <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 = HtmlProviders.CreateCacheDependency(provider, virtualPath);
content = LoadContent(file);
HttpRuntime.Cache.Insert(key, content, dependency);
}
return(new HtmlContentResult(this, content, virtualPath, key));
}
/// <summary>
/// 加载文档
/// </summary>
/// <param name="cacheKey">文档缓存键</param>
/// <returns>HTML 文档</returns>
protected virtual IHtmlDocument LoadDocument(out string cacheKey)
{
var document = HtmlProviders.LoadDocument(new HttpContextWrapper(HttpContext.Current), TemplatePath, out cacheKey);
return(document);
}
/// <summary>
/// 渲染部分视图（重写此方法以实现自定义输出 partial 元素）
/// </summary>
/// <param name="partialElement">partial 元素</param>
/// <returns></returns>
protected virtual string RenderPartial(IHtmlElement partialElement)
{
var action = partialElement.Attribute("action").Value();
var view = partialElement.Attribute("view").Value();
var path = partialElement.Attribute("path").Value();
var handler = partialElement.Attribute("handler").Value();
var name = partialElement.Attribute("name").Value();
if (!_partialExecutors.IsNullOrEmpty() && name != null)
{
var executor = _partialExecutors.FirstOrDefault(e => e.Name.EqualsIgnoreCase(name));
if (executor != null)
{
var wrapper = ViewHandler as IHandlerWrapper;
if (wrapper != null)
{
return(executor.Execute(wrapper.Handler, partialElement));
}
else
{
return(executor.Execute(ViewHandler, partialElement));
}
}
}
var helper = MakeHelper();
try
{
if (action != null)//Action 部分视图
{
var routeValues = Url.GetRouteValues(partialElement);
return(RenderAction(partialElement, action, partialElement.Attribute("controller").Value(), routeValues));
}
else if (view != null)
{
return(RenderPartial(partialElement, view));
}
else if (path != null)
{
if (!VirtualPathUtility.IsAppRelative(path))
{
throw new FormatException("path 只能使用应用程序根相对路径，即以 \"~/\" 开头的路径，调用 VirtualPathUtility.ToAppRelative 方法或使用 HttpRequest.AppRelativeCurrentExecutionFilePath 属性获取");
}
var content = HtmlProviders.LoadContent(path);
if (content != null)
{
return(content.Content);
}
}
}
catch (ThreadAbortException)
{
}
catch //若渲染时发生错误
{
if (MvcEnvironment.Configuration.IgnorePartialRenderException || partialElement.Attribute("ignoreError") != null)
{
return("<!--parital view render failed-->");
}
else
{
throw;
}
}
throw new NotSupportedException("无法处理的partial标签：" + ContentExtensions.GenerateTagHtml(partialElement, false));
}
/// <summary>
/// 加载文档
/// </summary>
/// <param name="cacheKey">文档缓存键</param>
/// <returns>HTML 文档</returns>
protected virtual IHtmlDocument LoadDocument(out string cacheKey)
{
var document = HtmlProviders.LoadDocument(VirtualPath, out cacheKey);
return(document);
}
public CachePolicy CreateCachePolicy(HttpContextBase context)
{
return(HtmlProviders.GetCachePolicy(context));
}
