public void RegisterTest()
{
var service1 = "~/test/1.html";
var service2 = "~/test/";
var service3 = "~/";
var globalService = "global";
WebServiceLocator.RegisterService(service1, "~/test/1.html");
WebServiceLocator.RegisterService(service2, "~/test/");
WebServiceLocator.RegisterService(service3, "~/");
WebServiceLocator.RegisterService(globalService);
string path = "~/test/1.html";
var services = WebServiceLocator.GetServices <string>(path);
Assert.Contains(services, service1, "注册服务在页面失败");
Assert.Contains(services, service2, "注册服务在目录失败");
Assert.Contains(services, service3, "注册服务在根目录失败");
Assert.Contains(services, globalService, "注册全局服务失败");
WebServiceLocator.UnregisterService(service1, path);
Assert.NotContains(WebServiceLocator.GetServices <string>(path), service1, "在页面解除注册服务失败");
WebServiceLocator.UnregisterService(service2, path);
Assert.NotContains(WebServiceLocator.GetServices <string>(path), service2, "在目录解除注册服务失败");
WebServiceLocator.UnregisterService(service3, path);
Assert.NotContains(WebServiceLocator.GetServices <string>(path), service3, "在根目录解除注册服务失败");
WebServiceLocator.UnregisterService(globalService);
Assert.NotContains(WebServiceLocator.GetServices <string>(path), globalService, "解除注册全局服务失败");
}
/// <summary>
/// 获取 HTML 筛选器
/// </summary>
/// <param name="virtualPath">HTML 文档虚拟路径</param>
/// <returns>HTML 筛选器</returns>
protected virtual IHtmlFilter[] GetFilters(string virtualPath)
{
return(WebServiceLocator
.GetServices <IHtmlFilterProvider>(virtualPath)
.SelectMany(p => p.GetFilters())
.Reverse().ToArray());
}
/// <summary>
/// 获取指定虚拟路径的 HTML 处理程序
/// </summary>
/// <param name="virtualPath">要获取 HTML 处理程序的虚拟路径</param>
/// <returns>HTML 处理程序</returns>
public static IHtmlHandler GetHandler(string virtualPath)
{
var services = WebServiceLocator.GetServices <IHtmlHandlerProvider>(virtualPath);
foreach (var provider in services)
{
var handler = provider.GetHandler(virtualPath);
if (handler != null)
{
return(handler);
}
}
if (!HostingEnvironment.VirtualPathProvider.FileExists(virtualPath))//如果文件不存在，则直接返回 null 。
{
return(null);
}
return
(GetHandlerInternal <IHtmlHandler>(virtualPath + ".ashx") ??
GetHandlerInternal <IHtmlHandler>(GetHandlerPath(virtualPath)) ??
GetHandlerInternal <IHtmlHandler>(VirtualPathHelper.FallbackSearch(virtualPath, "_handler.ashx")));
}
/// <summary>
/// 加载 HTML 文档内容
/// </summary>
/// <param name="virtualPath">文档的虚拟路径</param>
/// <returns>HTML 内容加载结果</returns>
public static HtmlContentResult LoadContent(string virtualPath)
{
if (virtualPath == null)
{
throw new ArgumentNullException("virtualPath");
}
if (!VirtualPathUtility.IsAppRelative(virtualPath))
{
throw VirtualPathFormatError("virtualPath");
}
var services = WebServiceLocator.GetServices <IHtmlContentProvider>(virtualPath).Concat(Default.GetContentServices(virtualPath));
foreach (var provider in services)
{
var result = provider.LoadContent(virtualPath);
if (result != null)
{
result.Provider = provider;
result.VirtualPath = virtualPath;
return(result);
}
}
return(null);
}
public void WebServiceLocator_Bestaat()
{
//Arrange
var webServiceLocator = new WebServiceLocator<IKlant>("http://www.test.nl", "basicHttpBinding");
//Assert
Assert.IsInstanceOfType(webServiceLocator, typeof(WebServiceLocator<IKlant>));
}
/// <summary>
/// 获取当前视图所需要应用的筛选器。
/// </summary>
/// <returns></returns>
protected virtual IViewFilter[] GetFilters(ViewContext context)
{
var filterProviders = WebServiceLocator.GetServices <IViewFilterProvider>(VirtualPath);
var filters = filterProviders.SelectMany(p => p.GetFilters(VirtualPath)).Reverse();
filters = filters.Concat(context.ViewData[ViewFiltersDataKey] as IEnumerable <IViewFilter> ?? Enumerable.Empty <IViewFilter>());
return(filters.ToArray());
}
public void ContentService()
{
var provider = new TestContentService();
WebServiceLocator.RegisterService(provider, VirtualPathUtility.GetDirectory(testContentPath));
var result = HtmlServices.LoadContent(testContentPath);
Assert.AreEqual(result.Content, testContent, "测试内容提供程序失败");
Assert.AreEqual(result.Provider, provider, "内容结果中的提供程序错误");
Assert.AreEqual(result.VirtualPath, testContentPath, "内容结果中的虚拟路径错误");
}
/// <summary>
/// 查找母板视图的处理程序
/// </summary>
/// <param name="virtualPath">母板视图虚拟路径</param>
/// <returns>视图处理程序</returns>
public static IViewHandler GetMasterViewHandler(string virtualPath)
{
foreach (var provider in WebServiceLocator.GetServices <IViewHandlerProvider>(virtualPath))
{
var handler = provider.FindViewHandler(virtualPath);
if (handler != null)
{
return(handler);
}
}
return(GetViewHandlerInternal(virtualPath + ".ashx", false));
}
/// <summary>
/// 获取当前请求的缓存策略
/// </summary>
/// <param name="context">当前 HTTP 请求</param>
/// <returns>适用于当前请求的缓存策略</returns>
public static CachePolicy GetCachePolicy(HttpContextBase context)
{
var virtualPath = context.Request.AppRelativeCurrentExecutionFilePath;
foreach (var provider in WebServiceLocator.GetServices <ICachePolicyProvider>(virtualPath))
{
CachePolicy policy = provider.CreateCachePolicy(context);
if (policy != null)
{
return(policy);
}
}
return(null);
}
/// <summary>
/// 获取用于分析 HTML 文档的分析器
/// </summary>
/// <param name="contentResult">文档内容加载结果</param>
/// <returns>HTML 分析器相关信息</returns>
public static IHtmlParser GetParser(HtmlContentResult contentResult)
{
if (contentResult == null)
{
throw new ArgumentNullException("contentResult");
}
foreach (var provider in WebServiceLocator.GetServices <IHtmlParserProvider>(contentResult.VirtualPath))
{
var parser = provider.GetParser(contentResult.VirtualPath, contentResult.Content);
if (parser != null)
{
return(parser);
}
}
return(Default.GetParser(contentResult.VirtualPath));
}
/// <summary>
/// 获取当前请求的缓存策略
/// </summary>
/// <param name="context">当前请求的 MVC 上下文</param>
/// <param name="action">请求的 Action</param>
/// <param name="parameters">Action 的参数信息</param>
/// <returns></returns>
public static CachePolicy CreateCachePolicy(ControllerContext context, ActionDescriptor action, IDictionary <string, object> parameters)
{
foreach (var provider in WebServiceLocator.GetServices <IMvcCachePolicyProvider>())
{
var policy = provider.CreateCachePolicy(context, action, parameters);
if (policy != null)
{
return(policy);
}
}
if (Configuration.FallbackCachePolicy)
{
return(FallbackCachePolicyProvider.CreateCachePolicy(context, action, parameters));
}
else
{
return(null);
}
}
/// <summary>
/// 分析 HTML 文档，此方法会根据情况缓存文档模型
/// </summary>
/// <param name="contentResult">文档加载结果</param>
/// <param name="parser">HTML 解析器</param>
/// <returns>HTML 文档对象</returns>
public static IHtmlDocument ParseDocument(HtmlContentResult contentResult, IHtmlParser parser)
{
var domProvider = parser.DomProvider;
if (contentResult.CacheKey != null && domProvider != null)//如果可以缓存
{
var key = contentResult.CacheKey;
var cacheKey = string.Format(CultureInfo.InvariantCulture, DocumentCacheKey, contentResult.VirtualPath);
var createDocument = Cache.Get(cacheKey) as Func <IHtmlDomProvider, IHtmlDocument>;
if (createDocument != null)
{
return(createDocument(domProvider));
}
WebServiceLocator.GetTraceService().Trace(TraceLevel.Info, "Jumony Web", "Document cache missed");
var document = ParseDocument(parser, contentResult.Content, contentResult.VirtualPath);
createDocument = document.Compile();//必须同步编译文档，否则文档对象可能被修改。
new Action(delegate
{
createDocument(domProvider);//可以异步预热，预热后再存入缓存。
Cache.Insert(cacheKey, createDocument, new CacheDependency(new string[0], new[] { key }), CacheItemPriority.High);
}
).BeginInvoke(null, null);//立即在新线程预热此方法
return(document);
}
else
{
return(ParseDocument(parser, contentResult.Content, contentResult.VirtualPath));
}
}
/// <summary>
/// 写入追踪信息
/// </summary>
/// <param name="message">消息内容</param>
/// <param name="category">消息分类</param>
/// <param name="level">消息级别</param>
protected void Trace(string message, string category = null, TraceLevel level = TraceLevel.Info)
{
WebServiceLocator.GetTraceService().Trace(level, category ?? "Jumony Web", message);
}
/// <summary>
/// 写入一条追踪信息
/// </summary>
/// <param name="message">追踪消息</param>
protected virtual void Trace(string message)
{
WebServiceLocator.GetTraceService().Trace(TraceLevel.Info, "Jumony Partial", message);
}
public void WebServiceLocator_BevatEenBindingDieNietOndersteundWordt()
{
//Arrange
var webServiceLocator = new WebServiceLocator<IKlant>("http://www.test.nl", "basicHttpsBinding");
}
