Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

227 lines
9.8 KiB
C#

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.Routing;
using System.Web.UI;
namespace System.Web.DynamicData {
/// <summary>
/// Route handler used for Dynamic Data
/// </summary>
public class DynamicDataRouteHandler : IRouteHandler {
private static object s_requestContextKey = new object();
private static object s_metaTableKey = new object();
private object _requestItemsKey = new object();
/// <summary>
/// ctor
/// </summary>
public DynamicDataRouteHandler() {
VirtualPathProvider = HostingEnvironment.VirtualPathProvider;
CreateHandlerCallback = delegate(string s) {
return (Page)BuildManager.CreateInstanceFromVirtualPath(s, typeof(Page));
};
}
/// <summary>
/// The MetaModel that the handler is associated with
/// </summary>
public MetaModel Model { get; internal set; }
// the following properties are for mocking purposes
internal VirtualPathProvider VirtualPathProvider { get; set; }
private HttpContextBase _context;
internal HttpContextBase HttpContext {
get {
return _context ?? new HttpContextWrapper(System.Web.HttpContext.Current);
}
set { _context = value; }
}
internal Func<string, IHttpHandler> CreateHandlerCallback { get; set; }
/// <summary>
/// Create a handler to process a Dynamic Data request
/// </summary>
/// <param name="route">The Route that was matched</param>
/// <param name="table">The MetaTable found in the route</param>
/// <param name="action">The Action found in the route</param>
/// <returns></returns>
public virtual IHttpHandler CreateHandler(DynamicDataRoute route, MetaTable table, string action) {
// First, get the path to the page (could be custom, shared, or null)
string virtualPath = GetPageVirtualPath(route, table, action);
if (virtualPath != null) {
// Gets called only for custom pages that we know exist or templates that may or may not
// exist. This method will throw if virtualPath does not exist, which is fine for templates
// but is not fine for custom pages.
return CreateHandlerCallback(virtualPath);
} else {
// This should only occur in the event that scaffolding is disabled and the custom page
// virtual path does not exist.
return null;
}
}
private string GetPageVirtualPath(DynamicDataRoute route, MetaTable table, string action) {
long cacheKey = Misc.CombineHashCodes(table, route.ViewName ?? action);
Dictionary<long, string> virtualPathCache = GetVirtualPathCache();
string virtualPath;
if (!virtualPathCache.TryGetValue(cacheKey, out virtualPath)) {
virtualPath = GetPageVirtualPathNoCache(route, table, action);
lock (virtualPathCache) {
virtualPathCache[cacheKey] = virtualPath;
}
}
return virtualPath;
}
private Dictionary<long, string> GetVirtualPathCache() {
var httpContext = HttpContext;
Dictionary<long, string> virtualPathCache = (Dictionary<long, string>)httpContext.Items[_requestItemsKey];
if (virtualPathCache == null) {
virtualPathCache = new Dictionary<long, string>();
httpContext.Items[_requestItemsKey] = virtualPathCache;
}
return virtualPathCache;
}
private string GetPageVirtualPathNoCache(DynamicDataRoute route, MetaTable table, string action) {
// The view name defaults to the action
string viewName = route.ViewName ?? action;
// First, get the path to the custom page
string customPageVirtualPath = GetCustomPageVirtualPath(table, viewName);
if (VirtualPathProvider.FileExists(customPageVirtualPath)) {
return customPageVirtualPath;
} else {
if (table.Scaffold) {
// If it doesn't exist, try the scaffolded page, but only if scaffolding is enabled on this table
return GetScaffoldPageVirtualPath(table, viewName);
} else {
// If scaffolding is disabled, null the path so BuildManager doesn't get called.
return null;
}
}
}
/// <summary>
/// Build the path to a custom page. By default, it looks like ~/DynamicData/CustomPages/[tablename]/[viewname].aspx
/// </summary>
/// <param name="table">The MetaTable that the page is for</param>
/// <param name="viewName">The view name</param>
/// <returns></returns>
protected virtual string GetCustomPageVirtualPath(MetaTable table, string viewName) {
string pathPattern = "{0}CustomPages/{1}/{2}.aspx";
return String.Format(CultureInfo.InvariantCulture, pathPattern, Model.DynamicDataFolderVirtualPath, table.Name, viewName);
}
/// <summary>
/// Build the path to a page template. By default, it looks like ~/DynamicData/PageTemplates/[tablename]/[viewname].aspx
/// </summary>
/// <param name="table">The MetaTable that the page is for</param>
/// <param name="viewName">The view name</param>
/// <returns></returns>
protected virtual string GetScaffoldPageVirtualPath(MetaTable table, string viewName) {
string pathPattern = "{0}PageTemplates/{1}.aspx";
return String.Format(CultureInfo.InvariantCulture, pathPattern, Model.DynamicDataFolderVirtualPath, viewName);
}
/// <summary>
/// Return the RequestContext for this request. A new one is created if needed (can happen if the current request
/// is not a Dynamic Data request)
/// </summary>
/// <param name="httpContext">The current HttpContext</param>
/// <returns>The RequestContext</returns>
public static RequestContext GetRequestContext(HttpContext httpContext) {
if (httpContext == null) {
throw new ArgumentNullException("httpContext");
}
return GetRequestContext(new HttpContextWrapper(httpContext));
}
internal static RequestContext GetRequestContext(HttpContextBase httpContext) {
Debug.Assert(httpContext != null);
// Look for the RequestContext in the HttpContext
var requestContext = httpContext.Items[s_requestContextKey] as RequestContext;
// If the current request didn't go through the routing engine (e.g. normal page),
// there won't be a RequestContext. If so, create a new one and save it
if (requestContext == null) {
var routeData = new RouteData();
requestContext = new RequestContext(httpContext, routeData);
// Add the query string params to the route data. This allows non routed pages to support filtering.
DynamicDataRoute.AddQueryStringParamsToRouteData(httpContext, routeData);
httpContext.Items[s_requestContextKey] = requestContext;
}
return requestContext;
}
/// <summary>
/// The MetaTable associated with the current HttpRequest. Can be null for non-Dynamic Data requests.
/// </summary>
/// <param name="httpContext">The current HttpContext</param>
public static MetaTable GetRequestMetaTable(HttpContext httpContext) {
if (httpContext == null) {
throw new ArgumentNullException("httpContext");
}
return GetRequestMetaTable(new HttpContextWrapper(httpContext));
}
internal static MetaTable GetRequestMetaTable(HttpContextBase httpContext) {
Debug.Assert(httpContext != null);
return (MetaTable)httpContext.Items[s_metaTableKey];
}
/// <summary>
/// Set the MetaTable associated with the current HttpRequest. Normally, this is set automatically from the
/// route, but this method is useful to set the table when used outside of routing.
/// </summary>
public static void SetRequestMetaTable(HttpContext httpContext, MetaTable table) {
SetRequestMetaTable(new HttpContextWrapper(httpContext), table);
}
internal static void SetRequestMetaTable(HttpContextBase httpContext, MetaTable table) {
Debug.Assert(httpContext != null);
httpContext.Items[s_metaTableKey] = table;
}
#region IRouteHandler Members
IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext) {
// Save the RequestContext
Debug.Assert(requestContext.HttpContext.Items[s_requestContextKey] == null);
requestContext.HttpContext.Items[s_requestContextKey] = requestContext;
// Get the dynamic route
var route = (DynamicDataRoute)requestContext.RouteData.Route;
// Get the Model from the route
MetaModel model = route.Model;
// Get the MetaTable and save it in the HttpContext
MetaTable table = route.GetTableFromRouteData(requestContext.RouteData);
requestContext.HttpContext.Items[s_metaTableKey] = table;
// Get the action from the request context
string action = route.GetActionFromRouteData(requestContext.RouteData);
return CreateHandler(route, table, action);
}
#endregion
}
}