白话学习MVC(十)View的呈现二

public abstract class ViewResultBase : ActionResult
{
    private DynamicViewDataDictionary _dynamicViewData;
    private TempDataDictionary _tempData;
    private ViewDataDictionary _viewData;
    private ViewEngineCollection _viewEngineCollection;
    private string _viewName;
 
    public object Model
    {
        get { return ViewData.Model; }
    }
 
    public TempDataDictionary TempData
    {
        get
        {
            if (_tempData == null)
            {
                _tempData = new TempDataDictionary();
            }
            return _tempData;
        }
        set { _tempData = value; }
    }
 
    public IView View { get; set; }
 
    public dynamic ViewBag
    {
        get
        {
            if (_dynamicViewData == null)
            {
                _dynamicViewData = new DynamicViewDataDictionary(() => ViewData);
            }
            return _dynamicViewData;
        }
    }
    public ViewDataDictionary ViewData
    {
        get
        {
            if (_viewData == null)
            {
                _viewData = new ViewDataDictionary();
            }
            return _viewData;
        }
        set { _viewData = value; }
    }
 
    //获取或设置视图引擎，ASP.NET有两个视图引擎，分别是：WebFormViewEngine、RazorViewEngine。
    public ViewEngineCollection ViewEngineCollection
    {
        get { return _viewEngineCollection ?? ViewEngines.Engines; }
        set { _viewEngineCollection = value; }
    }
 
    public string ViewName
    {
        get { return _viewName ?? String.Empty; }
        set { _viewName = value; }
    }
 
    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }
        //如果没有指定视图页名称将当前Action作为视图页的名称
        if (String.IsNullOrEmpty(ViewName))
        {
            ViewName = context.RouteData.GetRequiredString("action");
        }
 
        ViewEngineResult result = null;
 
        if (View == null)
        {
            //通过视图引擎去创建视图对象（实现了IView接口的类）
            result = FindView(context);
            View = result.View;
        }
 
        TextWriter writer = context.HttpContext.Response.Output;
        ViewContext viewContext = new ViewContext(context, View, ViewData, TempData, writer);
        //使用指定的编写器对象来呈现指定的视图上下文
        View.Render(viewContext, writer);
 
        if (result != null)
        {
            result.ViewEngine.ReleaseView(context, View);
        }
    }

public class ViewResult : ViewResultBase
{
    private string _masterName;
  
    public string MasterName
    {
        get { return _masterName ?? String.Empty; }
        set { _masterName = value; }
    }
  
    protected override ViewEngineResult FindView(ControllerContext context)
    {
          //遍历执行视图引擎集合中每个视图引擎的FindView方法，如果检查到存在指定的视图页(.cshtml)，则创建视图对象(实现IView接口)，否则不创建视图对象。
        //此处ViewEngineCollection是ViewResultBase类中的一个属性，表示视图引擎集合。
        ViewEngineResult result = ViewEngineCollection.FindView(context, ViewName, MasterName);
       //如果创建了视图对象，即：指定路径中存在相匹配的视图页（.cshtml文件）。
        if (result.View != null)
        {
            return result;
        }
       //没有创建视图对象，即：指定路径中不存在相匹配的视图页（.cshtml文件）。
        StringBuilder locationsText = new StringBuilder();
        foreach (string location in result.SearchedLocations)
        {
            locationsText.AppendLine();
            locationsText.Append(location);
        }
        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                          MvcResources.Common_ViewNotFound, ViewName, locationsText));
    }
}

public class ViewResult : ViewResultBase
{
    private string _masterName;
 
    public string MasterName
    {
        get { return _masterName ?? String.Empty; }
        set { _masterName = value; }
    }
 
    protected override ViewEngineResult FindView(ControllerContext context)
    {
        //遍历执行视图引擎集合中每个视图引擎的FindView方法，如果检查到存在指定的视图页(.cshtml)，则创建视图对象(实现IView接口)，否则不创建视图对象。
        //此处ViewEngineCollection是ViewResultBase类中的一个属性，表示视图引擎集合。
        ViewEngineResult result = ViewEngineCollection.FindView(context, ViewName, MasterName);
        //如果创建了视图对象，即：指定路径中存在相匹配的视图页（.cshtml文件）。
        if (result.View != null)
        {
            return result;
        }
        //没有创建视图对象，即：指定路径中不存在相匹配的视图页（.cshtml文件）。
        StringBuilder locationsText = new StringBuilder();
        foreach (string location in result.SearchedLocations)
        {
            locationsText.AppendLine();
            locationsText.Append(location);
        }
        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                          MvcResources.Common_ViewNotFound, ViewName, locationsText));
    }
}

public abstract class ViewResultBase : ActionResult
{
    private ViewEngineCollection _viewEngineCollection;
    
    //获取或设置视图引擎集合，默认情况下该集合两个视图引擎，分别是：WebFormViewEngine、RazorViewEngine。
    public ViewEngineCollection ViewEngineCollection
    {
        get { return _viewEngineCollection ?? ViewEngines.Engines; }
        set { _viewEngineCollection = value; }
    }
}

public static class ViewEngines
{
    //初始化Collection<T>，执行Collection<T>索引器将视图引擎实例放入集合中
    //同时执行ViewEngineCollection无参数的构造函数，将视图引擎也保存在其变量中，用于之后执行FineView方法遍历视图引擎去检查指定路径中否存在想匹配的视图页(.cshtml)
    private static readonly ViewEngineCollection _engines = new ViewEngineCollection
    {
        new WebFormViewEngine(),
        new RazorViewEngine(),
    };

    public static ViewEngineCollection Engines
    {
        get { return _engines; }
    }
}

public class ViewEngineCollection : Collection<IViewEngine>
{
    private IResolver<IEnumerable<IViewEngine>> _serviceResolver;

    public ViewEngineCollection()
    {
        //将所有视图引擎保存在变量_serviceResolver中，也是视图引擎进行缓存的处理！
        _serviceResolver = new MultiServiceResolver<IViewEngine>(() => Items);
    }
}

public class ViewEngineCollection : Collection<IViewEngine>
{
    private IResolver<IEnumerable<IViewEngine>> _serviceResolver;

    public ViewEngineCollection()
    {
        //将所有视图引擎保存在变量_serviceResolver中，也是视图引擎进行缓存的处理！
        _serviceResolver = new MultiServiceResolver<IViewEngine>(() => Items);
    }

    public ViewEngineCollection(IList<IViewEngine> list)
        : base(list)
    {
        _serviceResolver = new MultiServiceResolver<IViewEngine>(() => Items);
    }

    internal ViewEngineCollection(IResolver<IEnumerable<IViewEngine>> serviceResolver, params IViewEngine[] engines)
        : base(engines)
    {
        _serviceResolver = serviceResolver ?? new MultiServiceResolver<IViewEngine>(() => Items);
    }

    //视图引擎集合
    private IEnumerable<IViewEngine> CombinedItems
    {
        get { return _serviceResolver.Current; }
    }

    protected override void InsertItem(int index, IViewEngine item)
    {
        if (item == null)
        {
            throw new ArgumentNullException("item");
        }
        base.InsertItem(index, item);
    }

    protected override void SetItem(int index, IViewEngine item)
    {
        if (item == null)
        {
            throw new ArgumentNullException("item");
        }
        base.SetItem(index, item);
    }
    
    public virtual ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (String.IsNullOrEmpty(viewName))
        {
            throw new ArgumentException(MvcResources.Common_NullOrEmpty, "viewName");
        }
        //执行Find方法，该方法有两个委托类型的参数。
        //每个委托类型都是以 视图引擎 为参数，并执行视图引擎的FindView方法。
        return Find(e => e.FindView(controllerContext, viewName, masterName, true),
                    e => e.FindView(controllerContext, viewName, masterName, false));
    }
    //参数是泛型委托
    private ViewEngineResult Find(Func<IViewEngine, ViewEngineResult> cacheLocator, Func<IViewEngine, ViewEngineResult> locator)
    {
        return Find(cacheLocator, trackSearchedPaths: false)
               ?? Find(locator, trackSearchedPaths: true);
    }
    //trackSearchedPaths表示是否记录寻找路径
    private ViewEngineResult Find(Func<IViewEngine, ViewEngineResult> lookup, bool trackSearchedPaths)
    {
        // Returns
        //    1st result
        // OR list of searched paths (if trackSearchedPaths == true)
        // OR null
        ViewEngineResult result;

        List<string> searched = null;
        if (trackSearchedPaths)
        {
            searched = new List<string>();
        }
        //迭代视图引擎，执行委托也就是执行每个视图引擎的FindView方法去检查在指定的路径中是否存在想匹配的视图页（.cshtml文件）。
        //如果存在，则创建视图对象(实现IView接口)。
        foreach (IViewEngine engine in CombinedItems)
        {
            if (engine != null)
            {
                result = lookup(engine);

                if (result.View != null)
                {
                    return result;
                }

                if (trackSearchedPaths)
                {
                    searched.AddRange(result.SearchedLocations);
                }
            }
        }

        if (trackSearchedPaths)
        {
            // Remove duplicate search paths since multiple view engines could have potentially looked at the same path
            return new ViewEngineResult(searched.Distinct().ToList());
        }
        else
        {
            return null;
        }
    }

    public virtual ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (String.IsNullOrEmpty(partialViewName))
        {
            throw new ArgumentException(MvcResources.Common_NullOrEmpty, "partialViewName");
        }

        return Find(e => e.FindPartialView(controllerContext, partialViewName, true),
                    e => e.FindPartialView(controllerContext, partialViewName, false));
    }
}

public abstract class VirtualPathProviderViewEngine : IViewEngine
{
    // format is ":ViewCacheEntry:{cacheType}:{prefix}:{name}:{controllerName}:{areaName}:"
    private const string CacheKeyFormat = ":ViewCacheEntry:{0}:{1}:{2}:{3}:{4}:";
    private const string CacheKeyPrefixMaster = "Master";
    private const string CacheKeyPrefixPartial = "Partial";
    private const string CacheKeyPrefixView = "View";
    private static readonly string[] _emptyLocations = new string[0];
    private DisplayModeProvider _displayModeProvider;

    private VirtualPathProvider _vpp;
    internal Func<string, string> GetExtensionThunk = VirtualPathUtility.GetExtension;

    protected VirtualPathProviderViewEngine()
    {
        if (HttpContext.Current == null || HttpContext.Current.IsDebuggingEnabled)
        {
            ViewLocationCache = DefaultViewLocationCache.Null;
        }
        else
        {
            ViewLocationCache = new DefaultViewLocationCache();
        }
    }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] AreaMasterLocationFormats { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] AreaPartialViewLocationFormats { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] AreaViewLocationFormats { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] FileExtensions { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] MasterLocationFormats { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] PartialViewLocationFormats { get; set; }

    public IViewLocationCache ViewLocationCache { get; set; }

    [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
    public string[] ViewLocationFormats { get; set; }

    protected VirtualPathProvider VirtualPathProvider
    {
        get
        {
            if (_vpp == null)
            {
                _vpp = HostingEnvironment.VirtualPathProvider;
            }
            return _vpp;
        }
        set { _vpp = value; }
    }

    protected internal DisplayModeProvider DisplayModeProvider
    {
        get { return _displayModeProvider ?? DisplayModeProvider.Instance; }
        set { _displayModeProvider = value; }
    }

    private string CreateCacheKey(string prefix, string name, string controllerName, string areaName)
    {
        return String.Format(CultureInfo.InvariantCulture, CacheKeyFormat,
                             GetType().AssemblyQualifiedName, prefix, name, controllerName, areaName);
    }

    internal static string AppendDisplayModeToCacheKey(string cacheKey, string displayMode)
    {
        // key format is ":ViewCacheEntry:{cacheType}:{prefix}:{name}:{controllerName}:{areaName}:"
        // so append "{displayMode}:" to the key
        return cacheKey + displayMode + ":";
    }

    protected abstract IView CreatePartialView(ControllerContext controllerContext, string partialPath);

    protected abstract IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath);

    protected virtual bool FileExists(ControllerContext controllerContext, string virtualPath)
    {
        return VirtualPathProvider.FileExists(virtualPath);
    }

    public virtual ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (String.IsNullOrEmpty(partialViewName))
        {
            throw new ArgumentException(MvcResources.Common_NullOrEmpty, "partialViewName");
        }

        string[] searched;
        string controllerName = controllerContext.RouteData.GetRequiredString("controller");
        string partialPath = GetPath(controllerContext, PartialViewLocationFormats, AreaPartialViewLocationFormats, "PartialViewLocationFormats", partialViewName, controllerName, CacheKeyPrefixPartial, useCache, out searched);

        if (String.IsNullOrEmpty(partialPath))
        {
            return new ViewEngineResult(searched);
        }

        return new ViewEngineResult(CreatePartialView(controllerContext, partialPath), this);
    }
    
    public virtual ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (String.IsNullOrEmpty(viewName))
        {
            throw new ArgumentException(MvcResources.Common_NullOrEmpty, "viewName");
        }

        string[] viewLocationsSearched;
        string[] masterLocationsSearched;
        
        string controllerName = controllerContext.RouteData.GetRequiredString("controller");
        //根据定义的路径去检查是否存在想匹配的视图页(.cshtml)。
        string viewPath = GetPath(controllerContext, ViewLocationFormats, AreaViewLocationFormats, "ViewLocationFormats", viewName, controllerName, CacheKeyPrefixView, useCache, out viewLocationsSearched);
        string masterPath = GetPath(controllerContext, MasterLocationFormats, AreaMasterLocationFormats, "MasterLocationFormats", masterName, controllerName, CacheKeyPrefixMaster, useCache, out masterLocationsSearched);
        //检查到不存在相匹配的视图页(.cshtml文件)
        if (String.IsNullOrEmpty(viewPath) || (String.IsNullOrEmpty(masterPath) && !String.IsNullOrEmpty(masterName)))
        {
            //将检查过的所有路径封装到ViewEngineResult对象中，以便之后通过异常的方式输出。
            return new ViewEngineResult(viewLocationsSearched.Union(masterLocationsSearched));
        }
        //检测存在相匹配的视图页，创建视图对象(实现IView接口的类)。
        return new ViewEngineResult(CreateView(controllerContext, viewPath, masterPath), this);
    }

    private string GetPath(ControllerContext controllerContext, string[] locations, string[] areaLocations, string locationsPropertyName, string name, string controllerName, string cacheKeyPrefix, bool useCache, out string[] searchedLocations)
    {
        searchedLocations = _emptyLocations;

        if (String.IsNullOrEmpty(name))
        {
            return String.Empty;
        }

        string areaName = AreaHelpers.GetAreaName(controllerContext.RouteData);
        bool usingAreas = !String.IsNullOrEmpty(areaName);
        List<ViewLocation> viewLocations = GetViewLocations(locations, (usingAreas) ? areaLocations : null);

        if (viewLocations.Count == 0)
        {
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              MvcResources.Common_PropertyCannotBeNullOrEmpty, locationsPropertyName));
        }

        bool nameRepresentsPath = IsSpecificPath(name);
        string cacheKey = CreateCacheKey(cacheKeyPrefix, name, (nameRepresentsPath) ? String.Empty : controllerName, areaName);

        if (useCache)
        {
            // Only look at cached display modes that can handle the context.
            IEnumerable<IDisplayMode> possibleDisplayModes = DisplayModeProvider.GetAvailableDisplayModesForContext(controllerContext.HttpContext, controllerContext.DisplayMode);
            foreach (IDisplayMode displayMode in possibleDisplayModes)
            {
                string cachedLocation = ViewLocationCache.GetViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, displayMode.DisplayModeId));

                if (cachedLocation != null)
                {
                    if (controllerContext.DisplayMode == null)
                    {
                        controllerContext.DisplayMode = displayMode;
                    }

                    return cachedLocation;
                }
            }

            // GetPath is called again without using the cache.
            return null;
        }
        else
        {
            return nameRepresentsPath
                ? GetPathFromSpecificName(controllerContext, name, cacheKey, ref searchedLocations)
                : GetPathFromGeneralName(controllerContext, viewLocations, name, controllerName, areaName, cacheKey, ref searchedLocations);
        }
    }

    private string GetPathFromGeneralName(ControllerContext controllerContext, List<ViewLocation> locations, string name, string controllerName, string areaName, string cacheKey, ref string[] searchedLocations)
    {
        string result = String.Empty;
        searchedLocations = new string[locations.Count];

        for (int i = 0; i < locations.Count; i++)
        {
            ViewLocation location = locations[i];
            string virtualPath = location.Format(name, controllerName, areaName);
            DisplayInfo virtualPathDisplayInfo = DisplayModeProvider.GetDisplayInfoForVirtualPath(virtualPath, controllerContext.HttpContext, path => FileExists(controllerContext, path), controllerContext.DisplayMode);

            if (virtualPathDisplayInfo != null)
            {
                string resolvedVirtualPath = virtualPathDisplayInfo.FilePath;

                searchedLocations = _emptyLocations;
                result = resolvedVirtualPath;
                ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, virtualPathDisplayInfo.DisplayMode.DisplayModeId), result);

                if (controllerContext.DisplayMode == null)
                {
                    controllerContext.DisplayMode = virtualPathDisplayInfo.DisplayMode;
                }

                // Populate the cache with the existing paths returned by all display modes.
                // Since we currently don't keep track of cache misses, if we cache view.aspx on a request from a standard browser
                // we don't want a cache hit for view.aspx from a mobile browser so we populate the cache with view.Mobile.aspx.
                IEnumerable<IDisplayMode> allDisplayModes = DisplayModeProvider.Modes;
                foreach (IDisplayMode displayMode in allDisplayModes)
                {
                    if (displayMode.DisplayModeId != virtualPathDisplayInfo.DisplayMode.DisplayModeId)
                    {
                        DisplayInfo displayInfoToCache = displayMode.GetDisplayInfo(controllerContext.HttpContext, virtualPath, virtualPathExists: path => FileExists(controllerContext, path));

                        if (displayInfoToCache != null && displayInfoToCache.FilePath != null)
                        {
                            ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, displayInfoToCache.DisplayMode.DisplayModeId), displayInfoToCache.FilePath);
                        }
                    }
                }
                break;
            }

            searchedLocations[i] = virtualPath;
        }

        return result;
    }

    private string GetPathFromSpecificName(ControllerContext controllerContext, string name, string cacheKey, ref string[] searchedLocations)
    {
        string result = name;

        if (!(FilePathIsSupported(name) && FileExists(controllerContext, name)))
        {
            result = String.Empty;
            searchedLocations = new[] { name };
        }

        ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, cacheKey, result);
        return result;
    }

    private bool FilePathIsSupported(string virtualPath)
    {
        if (FileExtensions == null)
        {
            // legacy behavior for custom ViewEngine that might not set the FileExtensions property
            return true;
        }
        else
        {
            // get rid of the '.' because the FileExtensions property expects extensions withouth a dot.
            string extension = GetExtensionThunk(virtualPath).TrimStart('.');
            return FileExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);
        }
    }

    private static List<ViewLocation> GetViewLocations(string[] viewLocationFormats, string[] areaViewLocationFormats)
    {
        List<ViewLocation> allLocations = new List<ViewLocation>();

        if (areaViewLocationFormats != null)
        {
            foreach (string areaViewLocationFormat in areaViewLocationFormats)
            {
                allLocations.Add(new AreaAwareViewLocation(areaViewLocationFormat));
            }
        }

        if (viewLocationFormats != null)
        {
            foreach (string viewLocationFormat in viewLocationFormats)
            {
                allLocations.Add(new ViewLocation(viewLocationFormat));
            }
        }

        return allLocations;
    }

    private static bool IsSpecificPath(string name)
    {
        char c = name[0];
        return (c == '~' || c == '/');
    }

    public virtual void ReleaseView(ControllerContext controllerContext, IView view)
    {
        IDisposable disposable = view as IDisposable;
        if (disposable != null)
        {
            disposable.Dispose();
        }
    }

    private class AreaAwareViewLocation : ViewLocation
    {
        public AreaAwareViewLocation(string virtualPathFormatString)
            : base(virtualPathFormatString)
        {
        }

        public override string Format(string viewName, string controllerName, string areaName)
        {
            return String.Format(CultureInfo.InvariantCulture, _virtualPathFormatString, viewName, controllerName, areaName);
        }
    }

    private class ViewLocation
    {
        protected string _virtualPathFormatString;

        public ViewLocation(string virtualPathFormatString)
        {
            _virtualPathFormatString = virtualPathFormatString;
        }

        public virtual string Format(string viewName, string controllerName, string areaName)
        {
            return String.Format(CultureInfo.InvariantCulture, _virtualPathFormatString, viewName, controllerName);
        }
    }
}

VirtualPathProviderViewEngine

public abstract class BuildManagerViewEngine : VirtualPathProviderViewEngine
{
    private IViewPageActivator _viewPageActivator;
    private IResolver<IViewPageActivator> _activatorResolver;

    protected BuildManagerViewEngine()
        : this(null, null, null)
    {
    }

    protected BuildManagerViewEngine(IViewPageActivator viewPageActivator)
        : this(viewPageActivator, null, null)
    {
    }

    internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver, IDependencyResolver dependencyResolver)
    {
        if (viewPageActivator != null)
        {
            _viewPageActivator = viewPageActivator;
        }
        else
        {
            _activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
                                                          () => null,
                                                          new DefaultViewPageActivator(dependencyResolver),
                                                          "BuildManagerViewEngine constructor");
        }
    }
    protected IViewPageActivator ViewPageActivator
    {
        get
        {
            if (_viewPageActivator != null)
            {
                return _viewPageActivator;
            }
            _viewPageActivator = _activatorResolver.Current;
            return _viewPageActivator;
        }
    }

    //内部类
    internal class DefaultViewPageActivator : IViewPageActivator
    {
        private Func<IDependencyResolver> _resolverThunk;

        public DefaultViewPageActivator()
            : this(null)
        {
        }

        public DefaultViewPageActivator(IDependencyResolver resolver)
        {
            if (resolver == null)
            {
                _resolverThunk = () => DependencyResolver.Current;
            }
            else
            {
                _resolverThunk = () => resolver;
            }
        }

        public object Create(ControllerContext controllerContext, Type type)
        {
            return _resolverThunk().GetService(type) ?? Activator.CreateInstance(type);
        }
    }
}

internal class SingleServiceResolver<TService> : IResolver<TService>
    where TService : class
{
    private Lazy<TService> _currentValueFromResolver;
    private Func<TService> _currentValueThunk;
    private TService _defaultValue;
    private Func<IDependencyResolver> _resolverThunk;
    private string _callerMethodName;

    public SingleServiceResolver(Func<TService> currentValueThunk, TService defaultValue, string callerMethodName)
    {
        if (currentValueThunk == null)
        {
            throw new ArgumentNullException("currentValueThunk");
        }
        if (defaultValue == null)
        {
            throw new ArgumentNullException("defaultValue");
        }

        _resolverThunk = () => DependencyResolver.Current;
        _currentValueFromResolver = new Lazy<TService>(GetValueFromResolver);
        _currentValueThunk = currentValueThunk;
        _defaultValue = defaultValue;
        _callerMethodName = callerMethodName;
    }

    internal SingleServiceResolver(Func<TService> staticAccessor, TService defaultValue, IDependencyResolver resolver, string callerMethodName)
        : this(staticAccessor, defaultValue, callerMethodName)
    {
        if (resolver != null)
        {
            _resolverThunk = () => resolver;
        }
    }

    public TService Current
    {
        get { return _currentValueFromResolver.Value ?? _currentValueThunk() ?? _defaultValue; }
    }

    private TService GetValueFromResolver()
    {
        TService result = _resolverThunk().GetService<TService>();

        if (result != null && _currentValueThunk() != null)
        {
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, MvcResources.SingleServiceResolver_CannotRegisterTwoInstances, typeof(TService).Name.ToString(), _callerMethodName));
        }

        return result;
    }
}

public class DependencyResolver
{
    private static DependencyResolver _instance = new DependencyResolver();

    private IDependencyResolver _current;

    /// <summary>
    /// Cache should always be a new CacheDependencyResolver(_current).
    /// </summary>
    private CacheDependencyResolver _currentCache;

    public DependencyResolver()
    {
        InnerSetResolver(new DefaultDependencyResolver());
    }

    public static IDependencyResolver Current
    {
        get { return _instance.InnerCurrent; }
    }

    internal static IDependencyResolver CurrentCache
    {
        get { return _instance.InnerCurrentCache; }
    }

    public IDependencyResolver InnerCurrent
    {
        get { return _current; }
    }

    /// <summary>
    /// Provides caching over results returned by Current.
    /// </summary>
    internal IDependencyResolver InnerCurrentCache
    {
        get { return _currentCache; }
    }

    public static void SetResolver(IDependencyResolver resolver)
    {
        _instance.InnerSetResolver(resolver);
    }

    public static void SetResolver(object commonServiceLocator)
    {
        _instance.InnerSetResolver(commonServiceLocator);
    }

    [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types.")]
    public static void SetResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
    {
        _instance.InnerSetResolver(getService, getServices);
    }

    public void InnerSetResolver(IDependencyResolver resolver)
    {
        if (resolver == null)
        {
            throw new ArgumentNullException("resolver");
        }

        _current = resolver;
        _currentCache = new CacheDependencyResolver(_current);
    }

    public void InnerSetResolver(object commonServiceLocator)
    {
        if (commonServiceLocator == null)
        {
            throw new ArgumentNullException("commonServiceLocator");
        }

        Type locatorType = commonServiceLocator.GetType();
        MethodInfo getInstance = locatorType.GetMethod("GetInstance", new[] { typeof(Type) });
        MethodInfo getInstances = locatorType.GetMethod("GetAllInstances", new[] { typeof(Type) });

        if (getInstance == null ||
            getInstance.ReturnType != typeof(object) ||
            getInstances == null ||
            getInstances.ReturnType != typeof(IEnumerable<object>))
        {
            throw new ArgumentException(
                String.Format(
                    CultureInfo.CurrentCulture,
                    MvcResources.DependencyResolver_DoesNotImplementICommonServiceLocator,
                    locatorType.FullName),
                "commonServiceLocator");
        }

        var getService = (Func<Type, object>)Delegate.CreateDelegate(typeof(Func<Type, object>), commonServiceLocator, getInstance);
        var getServices = (Func<Type, IEnumerable<object>>)Delegate.CreateDelegate(typeof(Func<Type, IEnumerable<object>>), commonServiceLocator, getInstances);

        InnerSetResolver(new DelegateBasedDependencyResolver(getService, getServices));
    }

    [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types.")]
    public void InnerSetResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
    {
        if (getService == null)
        {
            throw new ArgumentNullException("getService");
        }
        if (getServices == null)
        {
            throw new ArgumentNullException("getServices");
        }

        InnerSetResolver(new DelegateBasedDependencyResolver(getService, getServices));
    }

    /// <summary>
    /// Wraps an IDependencyResolver and ensures single instance per-type.
    /// </summary>
    /// <remarks>
    /// Note it's possible for multiple threads to race and call the _resolver service multiple times.
    /// We'll pick one winner and ignore the others and still guarantee a unique instance.
    /// </remarks>
    private sealed class CacheDependencyResolver : IDependencyResolver
    {
        private readonly ConcurrentDictionary<Type, object> _cache = new ConcurrentDictionary<Type, object>();
        private readonly ConcurrentDictionary<Type, IEnumerable<object>> _cacheMultiple = new ConcurrentDictionary<Type, IEnumerable<object>>();

        private readonly IDependencyResolver _resolver;

        public CacheDependencyResolver(IDependencyResolver resolver)
        {
            _resolver = resolver;
        }

        public object GetService(Type serviceType)
        {
            return _cache.GetOrAdd(serviceType, _resolver.GetService);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _cacheMultiple.GetOrAdd(serviceType, _resolver.GetServices);
        }
    }

    private class DefaultDependencyResolver : IDependencyResolver
    {
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method might throw exceptions whose type we cannot strongly link against; namely, ActivationException from common service locator")]
        public object GetService(Type serviceType)
        {
            // Since attempting to create an instance of an interface or an abstract type results in an exception, immediately return null
            // to improve performance and the debugging experience with first-chance exceptions enabled.
            if (serviceType.IsInterface || serviceType.IsAbstract)
            {
                return null;
            }

            try
            {
                return Activator.CreateInstance(serviceType);
            }
            catch
            {
                return null;
            }
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return Enumerable.Empty<object>();
        }
    }

    private class DelegateBasedDependencyResolver : IDependencyResolver
    {
        private Func<Type, object> _getService;
        private Func<Type, IEnumerable<object>> _getServices;

        public DelegateBasedDependencyResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
        {
            _getService = getService;
            _getServices = getServices;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method might throw exceptions whose type we cannot strongly link against; namely, ActivationException from common service locator")]
        public object GetService(Type type)
        {
            try
            {
                return _getService.Invoke(type);
            }
            catch
            {
                return null;
            }
        }

        public IEnumerable<object> GetServices(Type type)
        {
            return _getServices(type);
        }
    }
}

public abstract class VirtualPathProviderViewEngine : IViewEngine
{
    //省略其他代码
    private DisplayModeProvider _displayModeProvider;
    protected internal DisplayModeProvider DisplayModeProvider
    {
        get { return _displayModeProvider ?? DisplayModeProvider.Instance; }
        set { _displayModeProvider = value; }
    }
}

public sealed class DisplayModeProvider
{
    public static readonly string MobileDisplayModeId = "Mobile";
    public static readonly string DefaultDisplayModeId = string.Empty;
    private static readonly object _displayModeKey = new object();
    private static readonly DisplayModeProvider _instance = new DisplayModeProvider();
    private readonly List<IDisplayMode> _displayModes;
    public bool RequireConsistentDisplayMode
    {
        get;
        set;
    }
    public static DisplayModeProvider Instance
    {
        get
        {
            return DisplayModeProvider._instance;
        }
    }
    public IList<IDisplayMode> Modes
    {
        get
        {
            return this._displayModes;
        }
    }
    internal DisplayModeProvider()
    {
        List<IDisplayMode> list = new List<IDisplayMode>();
        List<IDisplayMode> arg_37_0 = list;
        DefaultDisplayMode defaultDisplayMode = new DefaultDisplayMode(DisplayModeProvider.MobileDisplayModeId);
        defaultDisplayMode.ContextCondition = ((HttpContextBase context) => context.GetOverriddenBrowser().IsMobileDevice);
        arg_37_0.Add(defaultDisplayMode);
        list.Add(new DefaultDisplayMode());
        this._displayModes = list;
        base..ctor();
    }
    public IEnumerable<IDisplayMode> GetAvailableDisplayModesForContext(HttpContextBase httpContext, IDisplayMode currentDisplayMode)
    {
        return this.GetAvailableDisplayModesForContext(httpContext, currentDisplayMode, this.RequireConsistentDisplayMode).ToList<IDisplayMode>();
    }
    internal IEnumerable<IDisplayMode> GetAvailableDisplayModesForContext(HttpContextBase httpContext, IDisplayMode currentDisplayMode, bool requireConsistentDisplayMode)
    {
        IEnumerable<IDisplayMode> source = (requireConsistentDisplayMode && currentDisplayMode != null) ? this.Modes.SkipWhile((IDisplayMode mode) => mode != currentDisplayMode) : this.Modes;
        return 
            from mode in source
            where mode.CanHandleContext(httpContext)
            select mode;
    }
    public DisplayInfo GetDisplayInfoForVirtualPath(string virtualPath, HttpContextBase httpContext, Func<string, bool> virtualPathExists, IDisplayMode currentDisplayMode)
    {
        return this.GetDisplayInfoForVirtualPath(virtualPath, httpContext, virtualPathExists, currentDisplayMode, this.RequireConsistentDisplayMode);
    }
    internal DisplayInfo GetDisplayInfoForVirtualPath(string virtualPath, HttpContextBase httpContext, Func<string, bool> virtualPathExists, IDisplayMode currentDisplayMode, bool requireConsistentDisplayMode)
    {
        IEnumerable<IDisplayMode> availableDisplayModesForContext = this.GetAvailableDisplayModesForContext(httpContext, currentDisplayMode, requireConsistentDisplayMode);
        return (
            from mode in availableDisplayModesForContext
            select mode.GetDisplayInfo(httpContext, virtualPath, virtualPathExists)).FirstOrDefault((DisplayInfo info) => info != null);
    }
    internal static IDisplayMode GetDisplayMode(HttpContextBase context)
    {
        if (context == null)
        {
            return null;
        }
        return context.Items[DisplayModeProvider._displayModeKey] as IDisplayMode;
    }
    internal static void SetDisplayMode(HttpContextBase context, IDisplayMode displayMode)
    {
        if (context != null)
        {
            context.Items[DisplayModeProvider._displayModeKey] = displayMode;
        }
    }
}

public abstract class StartPage : WebPageRenderingBase
{
    //page:被请求的视图页对象；fileName：“_ViewStart”；supportedExtensions：数组“cshtml”和“vbhtml”
    public static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, string fileName, IEnumerable<string> supportedExtensions)
    {
        if (page == null)
        {
            throw new ArgumentNullException("page");
        }
        if (string.IsNullOrEmpty(fileName))
        {
            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, new object[]
            {
                "fileName"
            }), "fileName");
        }
        if (supportedExtensions == null)
        {
            throw new ArgumentNullException("supportedExtensions");
        }
        return StartPage.GetStartPage(page, page.VirtualPathFactory ?? VirtualPathFactoryManager.Instance, HttpRuntime.AppDomainAppVirtualPath, fileName, supportedExtensions);
    }
    internal static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, IVirtualPathFactory virtualPathFactory, string appDomainAppVirtualPath, string fileName, IEnumerable<string> supportedExtensions)
    {
        WebPageRenderingBase webPageRenderingBase = page;
        //得到视图路径的目录，page.VirtualPath是被请求的视图页的路径。
        string directory = VirtualPathUtility.GetDirectory(page.VirtualPath);
        while (!string.IsNullOrEmpty(directory) && directory != "/" && PathUtil.IsWithinAppRoot(appDomainAppVirtualPath, directory))
        {
            //循环“cshtml”和“vbhtml”
            foreach (string current in supportedExtensions)
            {
                string virtualPath = VirtualPathUtility.Combine(directory, fileName + "." + current);
                if (virtualPathFactory.Exists(virtualPath))
                {
                    //创建“_ViewStart.cshtml”的实例。
                    StartPage startPage = virtualPathFactory.CreateInstance(virtualPath);
                    startPage.VirtualPath = virtualPath;
                    //将被请求的视图页对象保存到StartPage对象的ChildPage属性
                    startPage.ChildPage = webPageRenderingBase;
                    startPage.VirtualPathFactory = virtualPathFactory;
                    //将webPageRenderingBase的值设置为当前StartPage对象。
                    webPageRenderingBase = startPage;
                    break;
                }
            }
            directory = webPageRenderingBase.GetDirectory(directory);
        }
        return webPageRenderingBase;
    }
}