modifier la convention de nom de contrôleur dans ASP.NET MVC

Question

Existe-t-il un moyen de modifier la convention de dénomination pour les contrôleurs dans ASP.NET MVC?

Ce que je veux est de nommer mes contrôleurs InicioControlador au lieu de InicioController, ou mieux encore, utiliser un préfixe au lieu d'un suffixe, et ont ControladorInicio comme mon nom du contrôleur. D'après ce que j'ai lu jusqu'à présent, je pense que je dois implémenter ma propre Controller Factory. Je serais très reconnaissant si l'un de vous pourrait me diriger dans la bonne direction.

Answer 1

Oui, ControllerFactory est la meilleure solution à votre problème.

public IController CreateController(RequestContext requestContext, string controllerName) 
    {    
     BaseController controller; 

     switch (controllerName.ToLower()) 
     { 
      case "product": case "products": controller = new MyProductController(); break; 
      case "home": controller = new MyHomeController(); break; 
      case "account": controller = new MyAccountController(); break; 
      default: controller = null; break; 
     } 

     return controller; 
    } 

Ceci est mon premier ControllerFactory - mais il est très stupide :) Vous devez utiliser la réflexion et éviter ce commutateur laid.

Answer 2

J'ai décidé de creuser un peu plus loin et j'ai trouvé exactement ce que je cherchais après avoir cherché dans le code source du MVC. La convention pour les noms de contrôleur est profondément dans les racines de la MVC Framework, en particulier dans deux classes ControllerDescriptor et ControllerTypeCache.

En ControllerDescriptor il est donné par l'attribut suivant:

public virtual string ControllerName { 
    get { 
    string typeName = ControllerType.Name; 
    if (typeName.EndsWith("Controller", StringComparison.OrdinalIgnoreCase)) { 
     return typeName.Substring(0, typeName.Length - "Controller".Length); 
    } 
    return typeName; 
    } 
} 

En ControllerTypeCache il est donné par les méthodes suivantes:

internal static bool IsControllerType(Type t) { 
    return 
    t != null && 
    t.IsPublic && 
    t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase) && 
    !t.IsAbstract && 
    typeof(IController).IsAssignableFrom(t); 
} 

public void EnsureInitialized(IBuildManager buildManager) 
{ 
    if (_cache == null) 
    { 
    lock (_lockObj) 
    { 
     if (_cache == null) 
     { 
     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); 
     } 
    } 
    }