GetControllerType和GetcontrollerInstance
GetControllerType
protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
if (String.IsNullOrEmpty(controllerName) &&
(requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch()))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
}
RouteData routeData = requestContext.RouteData;
if (routeData != null && routeData.HasDirectRouteMatch())
{
return GetControllerTypeFromDirectRoute(routeData);
}
// first search in the current route's namespace collection
object routeNamespacesObj;
Type match;
if (routeData.DataTokens.TryGetValue(RouteDataTokenKeys.Namespaces, out routeNamespacesObj))
{
IEnumerable<string> routeNamespaces = routeNamespacesObj as IEnumerable<string>;
if (routeNamespaces != null && routeNamespaces.Any())
{
HashSet<string> namespaceHash = new HashSet<string>(routeNamespaces, StringComparer.OrdinalIgnoreCase);
match = GetControllerTypeWithinNamespaces。
(routeData.Route, controllerName, namespaceHash);
// the UseNamespaceFallback key might not exist, in which case its value is implicitly "true"
if (match != null || false.Equals(routeData.DataTokens[RouteDataTokenKeys.UseNamespaceFallback]))
{
// got a match or the route requested we stop looking
return match;
}
}
}
// then search in the application's default namespace collection
if (ControllerBuilder.DefaultNamespaces.Count > 0)
{
HashSet<string> namespaceDefaults = new HashSet<string>(ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase);
match = GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaceDefaults);
if (match != null)
{
return match;
}
}
// if all else fails, search every namespace
return GetControllerTypeWithinNamespaces(routeData.Route, controllerName, null /* namespaces */);
}
首先进行了入口的检查，HasDirectRouteMatch这个方法是用来判断这个RouteData是不是特性路由？应该是这个作用。现在还没知道，以后说WebApi的时候可能会说到。所有默认情况是不会去执行GetControllerTypeFromDirectRoute的方法的。在Route中获取命名空间，如果设置了NameSpace的话便在这边取出，然后转化为List
private Type GetControllerTypeWithinNamespaces(RouteBase route, string controllerName, HashSet<string> namespaces)
{
// Once the master list of controllers has been created we can quickly index into it
ControllerTypeCache.EnsureInitialized(BuildManager);
ICollection<Type> matchingTypes = ControllerTypeCache.GetControllerTypes(controllerName, namespaces);
switch (matchingTypes.Count)
{
case 0:
// no matching types
return null;
case 1:
// single matching type
return matchingTypes.First();
default:
// multiple matching types
throw CreateAmbiguousControllerException(route, controllerName, matchingTypes);
}
}
GetControllerTypeWithinNamespaces里面就就两句，通过BuildManager初始化，ControllerTypeCache看这个名字也知道是控制器类型缓存，然后通过名字和namesapces获得Type，如果0个返回null，1个正确，2个便报错。
主要看一下EnsureInitialized和GetControllerTypes这两个方法。
EnsureInitialized
public void EnsureInitialized(IBuildManager buildManager)
{
if (_cache == null)
{
lock (_lockObj)
{
if (_cache == null)
{
//TypeCaheName='MVC-ControllerTypeCache.xml'
List<Type> controllerTypes = TypeCacheUtil.GetFilteredTypesFromAssemblies(TypeCacheName, IsControllerType, buildManager);
var groupedByName = controllerTypes.GroupBy(
t => t.Name.Substring(0, t.Name.Length - "Controller".Length),
StringComparer.OrdinalIgnoreCase);
_cache = groupedByName.ToDictionary(
g => g.Key,
g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase),
StringComparer.OrdinalIgnoreCase);
}
}
}
}
里面又调用了TypeCacheUtil的GetFilteredTypesFromAssemblies的方法。得到之后，对控制器的名字进行截取，取控制前的名字进行分组（GroupBy）。然后封装成一个字典_cache。然后我们看看GetFilteredTypesFromAssemblies这个方法里面发生了什么。
//predicate == IsControllerType
public static List<Type> GetFilteredTypesFromAssemblies(string cacheName, Predicate<Type> predicate, IBuildManager buildManager)
{
TypeCacheSerializer serializer = new TypeCacheSerializer();
// 首先从磁盘文件中读取数据 cacheName='MVC-ControllerTypeCache.xml'
List<Type> matchingTypes = ReadTypesFromCache(cacheName, predicate, buildManager, serializer);
if (matchingTypes != null)
{
return matchingTypes;
}
// 如果读到数据，将每个数据进行对比
matchingTypes = FilterTypesInAssemblies(buildManager, predicate).ToList();
// 最后保存会磁盘中
SaveTypesToCache(cacheName, matchingTypes, buildManager, serializer);
return matchingTypes;
}
在c盘应该可以找到和这个文件，这就是用来进行缓存mvc和Action的类型。里面的细节的逻辑就不看。主要看这个方法FilterTypesInAssemblies，方法的意思应该就是在程序集中过滤Type。
//predicate == IsControllerType
private static IEnumerable<Type> FilterTypesInAssemblies(IBuildManager buildManager, Predicate<Type> predicate)
{
// 浏览应用的所有程序集，并进行谓语匹配
IEnumerable<Type> typesSoFar = Type.EmptyTypes;
ICollection assemblies = buildManager.GetReferencedAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] typesInAsm;
try
{
typesInAsm = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
typesInAsm = ex.Types;
}
typesSoFar = typesSoFar.Concat(typesInAsm);
}
return typesSoFar.Where(type => TypeIsPublicClass(type) && predicate(type));
}
定义了一个空的类型，通过buildManager.GetReferencedAssemblies()获得引用的程序集。循环，获取每个程序集的type,在最后的时候进行条件过滤，在最前面标注了predicate的值是IsControllerType。这个值是定义在ControllerTypeCache中的。
internal static bool IsControllerType(Type t)
{
return
t != null &&
t.IsPublic &&
t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase) &&
!t.IsAbstract &&
typeof(IController).IsAssignableFrom(t);
}
就是说这个Type是不是public，是不是已Controller结尾，要不是抽象类,是不是继承IController。通过的Type放到typesSoFar。然后返回matchingTypes，然后赋给controllerTypes。然后赋值给_cache。 最后进行路由匹配。
public ICollection<Type> GetControllerTypes(string controllerName, HashSet<string> namespaces)
{
HashSet<Type> matchingTypes = new HashSet<Type>();
ILookup<string, Type> namespaceLookup;
if (_cache.TryGetValue(controllerName, out namespaceLookup))
{
// 如果命名空间不为空的话，循环Type比较Type的命名空间是否和设置的一致。
if (namespaces != null)
{
foreach (string requestedNamespace in namespaces)
{
foreach (var targetNamespaceGrouping in namespaceLookup)
{
if (IsNamespaceMatch(requestedNamespace, targetNamespaceGrouping.Key))
{
matchingTypes.UnionWith(targetNamespaceGrouping);
}
}
}
}
else
{
// 如果命名空间为空的话，搜索所有的namespace
foreach (var namespaceGroup in namespaceLookup)
{
matchingTypes.UnionWith(namespaceGroup);
}
}
}
return matchingTypes;
}
调用了GetController的方法。这里才是真正的比对控制器的。首先建立了一个HashSet 泛型 的对象。通过controllerName的值在_cache中获取，有值，判断命名空间又没有，有的话，循环每个命名空间。比对分完组的Controller集合。调用UnionWith的方法。这个是HashSet里面的方法。在集合中进行比较。如果没有重复就放进去。所以到最后返回的是一个Type的集合。
理一下上面的逻辑。
- GetControllerType 方法 通过不同的设置namespace的情况分别调用GetControllerTypeWithinNamespaces。
- GetControllerTypeWithinNamespaces 方法内的 EnsureInitialized
- 首先读取缓存文件
- 然后循环所有的引用程序集，通过IsControllerType过滤类型
- 保存会程序集中
- 将返回的符合的程序集通过名字分组，赋给_cache属性
- GetControllerTypeWithinNamespaces方法 GetControllerTypes 方法
- 如果有命名空间，通过比对_cache中的Type的命名空间比对，天玑道machtingType中
- 没有的话，比对所有的Type
- GetControllerTypeWithinNamespaces 方法内的 EnsureInitialized
GetControllerInstance
protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType)
{
if (controllerType == null)
{
throw new HttpException(404,
String.Format(
CultureInfo.CurrentCulture,
MvcResources.DefaultControllerFactory_NoControllerFound,
requestContext.HttpContext.Request.Path));
}
if (!typeof(IController).IsAssignableFrom(controllerType))
{
throw new ArgumentException(
String.Format(
CultureInfo.CurrentCulture,
MvcResources.DefaultControllerFactory_TypeDoesNotSubclassControllerBase,
controllerType),
"controllerType");
}
return ControllerActivator.Create(requestContext, controllerType);
}
再次判断一下Type。其实最后起作用的只有最后一句。首先要看一下ControllerActivator这个属性是什么样的。
internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
{
if (controllerActivator != null)
{
_controllerActivator = controllerActivator;
}
else
{
_activatorResolver = activatorResolver ?? new SingleServiceResolver<IControllerActivator>(
() => null,
new DefaultControllerActivator(dependencyResolver),
"DefaultControllerFactory constructor");
}
}
private IControllerActivator ControllerActivator
{
get
{
if (_controllerActivator != null)
{
return _controllerActivator;
}
_controllerActivator = _activatorResolver.Current;
return _controllerActivator;
}
}
可以看出是_activatorResolver.Current. _activatorResolver这个类型是什么时候初始化的呢？是在DefaultControllerFactory创建的时候，可以看到又是使用了SingleServiceResolver，这个是ControllerFactory的一样的套路，如果DependencyResolver中注册了对应的Resolver可以返回IControllerActivator就会首先返回这个。如果没有设置的话也就是默认状态的话会使用DefaultControllerActivator。
public IController Create(RequestContext requestContext, Type controllerType)
{
try
{
return (IController)(_resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
}
catch (Exception ex)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentCulture,
MvcResources.DefaultControllerFactory_ErrorCreatingController,
controllerType),
ex);
}
}
如果构造DefaultControllerActivator的参数dependencyResolver为空，那就通过反射进行构造返回就行了。