Redirecting from area to a controller/view not in an area

Question

I am trying to do an error redirection from inside my admin area to my error view which is shared and outside all areas.

I created a method on my Lobby controller called error:

    public ViewResult Error()
    {
         return View("Views/Shared/Error");
    }

The view exists in the Views/Shared directory and is called Error.

From my User controller in the Admin area, I am attempting to do:

    return RedirectToAction("Error", "Lobby", new {area = ""});

However, the application is trying to redirect to "/Admin/Lobby/Error" despite my having area="" in the routevalues. When I try to step through the code there is no line executed between the previous line and the 404 error in the browser.

What am I missing here?

Edited to add: There may be a problem with my routes actually. I tried changing the default behavior after login to direct to a controller not in an area, and it is automatically trying to send me to my Admin area.

What I'm trying to accomplish: I want routes that have an area to be interpreted as needing to go to that area, and routes that do not have an area to use the default. Currently I have only one area (admin) though there will be more.

Here are my routes:

routes.MapRoute("ErrorPage", "Error", new { controller="Error", action="Error"  },    new[] { "WebUI.Controllers" }); //Error Route

        routes.MapRoute(
            "", // Route name
            "Admin/{controller}/{action}/{id}", // URL with parameters
            new { area ="Admin", controller = "Client", action = "ManageClients", id = UrlParameter.Optional } // Parameter defaults
            , new[] { "WebUI.Areas.Admin.Controllers" } //prioritize admin
        );

        routes.MapRoute(
            "Default", // Route name
            "{controller}/{action}/{id}", // URL with parameters
            new { controller = "Lobby", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            , new[] {"WebUI.Controllers"} //prioritize main
        );

IIRC when I tried having a route that didn't 'hardcode' "Admin" as the area name, the routing engine tried to stuff routes w/o an area into the area route, resulting in the controller being mistaken for the area and the action for the controller.

However I suspect what it is doing now is somehow appending "/Admin" to all my routes! For example, the app goes to Account/Login first upon startup (not in an area). When I changed the login behavior to go to:

        return RedirectToAction("Summary", "Logging");

It is forming a url /Admin/Logging/Summary instead of /Logging/Summary. Even if I manually change this to

  return RedirectToAction("Summary", "Logging", new {area=""});

It must be taking the 'default' Admin area from the route. But, if I remove the default area from the route, then my Admin links all break.

This is what my area registration looks like:

    public override void RegisterArea(AreaRegistrationContext context)
    {
        context.MapRoute(
            "Admin_default",
            "Admin/{controller}/{action}/{id}",
            new { action = "Index", id = UrlParameter.Optional },
         new [] { "WebUI.Areas.Admin.Controllers" }
        );
    }

So I guess I need to rephrase my question to: how do I configure the areas and the routes so that routes & links both inside and outside the areas function properly?

Answer 1

I ended up solving the problem by modifying Phil Haack's AreaRouteHelper extensions somewhat:

public static class AreaRouteHelper
{
    public static void MapAreas(this RouteCollection routes, string url, string rootNamespace, string[] areas)
    {
        Array.ForEach(areas, area =>
        {
            Route route = new Route("{area}/" + url, new MvcRouteHandler());
            route.Constraints = new RouteValueDictionary(new { area });
            string areaNamespace = rootNamespace + ".Areas." + area + ".Controllers";
            route.DataTokens = new RouteValueDictionary(new { namespaces = new string[] { areaNamespace } });
            route.Defaults = new RouteValueDictionary(new { action = "Index", controller = "Landing", id = "" });
            routes.Add(route);
        });
    }

    public static void MapRootArea(this RouteCollection routes, string url, string rootNamespace, object defaults)
    {
        Route route = new Route(url, new MvcRouteHandler());
        route.DataTokens = new RouteValueDictionary(new { namespaces = new string[] { rootNamespace + ".Controllers" } });
        route.Defaults = new RouteValueDictionary(new { area = "", action = "Index", controller = "Lobby", id = "" });
        routes.Add(route);
    }
}

(basically I had to remove the word "root" from the default RootArea default and change the defaults to 'Lobby' and 'Landing' which are our standards rather than Home. When I left his default "root" in there, it added "root" to the folder structure which did not work)

Then I removed the second two routes from my RegisterRoutes and replaced with:

 routes.MapAreas("{controller}/{action}/{id}", "WebUI", new[] { "Admin", "Analysis" });

        routes.MapRootArea("{controller}/{action}/{id}",
            "WebUI",
            new { controller = "Lobby", action = "Index", id = "" });

This fix requires an area-aware view engine. The one in Haack's project is a 1.0 webform view engine, I already had an area-aware razor view engine I'd scraped from another post somewhere and this one worked. I honestly don't remember what post I found it in or I'd link directly to it to credit the author. But this is what it looks like (if anyone here knows who wrote it I'll happily attribute it to that person). Please note that the mappings here match my project and probably will not match anyone else's without some adjustment!

 public class RazorAreaAwareViewEngine :RazorViewEngine
{
    private static readonly string[] EmptyLocations = { };

    public RazorAreaAwareViewEngine()
    {
        MasterLocationFormats = new string[]
                                    {
                                        "~/Views/{1}/{0}.master",
                                        "~/Views/Shared/{0}.master"
                                    };
        ViewLocationFormats = new string[]
                                  {
                                      "~/Areas/{2}/Views/{1}/{0}.cshtml",
                                      "~/Areas/{2}/Views/Shared/{0}.cshtml",
                                      "~/{2}/{0}.cshtml",
                                      "~/Views/{1}/{0}.cshtml",
                                      "~/Views/Shared/{0}.cshtml",
                                  };
        PartialViewLocationFormats = ViewLocationFormats;
    }
    public override ViewEngineResult FindView(ControllerContext controllerContext, string viewName,string masterName, bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(viewName))
        {
            throw new ArgumentNullException(viewName,
                "Value cannot be null or empty.");
        }
        string area = GetArea(controllerContext);

        return FindAreaView(controllerContext, area, viewName,
            masterName, useCache);
    }

    public override ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName,bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(partialViewName))
        {
            throw new ArgumentNullException(partialViewName,
                "Value cannot be null or empty.");
        }
        string area = GetArea(controllerContext);

        return FindAreaPartialView(controllerContext, area,
            partialViewName, useCache);
    }

    protected string GetArea(ControllerContext controllerContext)
    {
        object area = null;
        if (controllerContext.RouteData.DataTokens.ContainsKey("area"))
        {
            area = controllerContext.RouteData.DataTokens["area"];
        }
        if (area == null)
        {
            controllerContext.RouteData.Values.TryGetValue("area", out area);
        }
        if(area !=null)
        {
            return area.ToString();
        }
        return null;
    }

    protected virtual ViewEngineResult FindAreaView(ControllerContext controllerContext, string areaName, string viewName,string masterName, bool useCache)
    {
        string controllerName =
            controllerContext.RouteData.GetRequiredString("controller");
        string[] searchedViewPaths;
        string viewPath = GetPath(controllerContext, ViewLocationFormats,
            "ViewLocationFormats", viewName, controllerName, areaName, "View",
            useCache, out searchedViewPaths);
        string[] searchedMasterPaths;
        string masterPath = GetPath(controllerContext, MasterLocationFormats,
            "MasterLocationFormats", masterName, controllerName, areaName,
            "Master", useCache, out searchedMasterPaths);
        if (!string.IsNullOrEmpty(viewPath) &&
            (!string.IsNullOrEmpty(masterPath) ||
              string.IsNullOrEmpty(masterName)))
        {
            return new ViewEngineResult(CreateView(controllerContext, viewPath,
                masterPath), this);
        }
        return new ViewEngineResult(
            searchedViewPaths.Union<string>(searchedMasterPaths));
    }

    protected virtual ViewEngineResult FindAreaPartialView(ControllerContext controllerContext, string areaName,string viewName, bool useCache)
    {
        string controllerName =
            controllerContext.RouteData.GetRequiredString("controller");
        string[] searchedViewPaths;
        string partialViewPath = GetPath(controllerContext,
            ViewLocationFormats, "PartialViewLocationFormats", viewName,
            controllerName, areaName, "Partial", useCache,
            out searchedViewPaths);
        if (!string.IsNullOrEmpty(partialViewPath))
        {
            return new ViewEngineResult(CreatePartialView(controllerContext,
                partialViewPath), this);
        }
        return new ViewEngineResult(searchedViewPaths);
    }

    protected string CreateCacheKey(string prefix, string name,
        string controller, string area)
    {
        return string.Format(CultureInfo.InvariantCulture,
            ":ViewCacheEntry:{0}:{1}:{2}:{3}:{4}:",
            base.GetType().AssemblyQualifiedName,
            prefix, name, controller, area);
    }

    protected string GetPath(ControllerContext controllerContext,string[] locations, string locationsPropertyName, string name,
        string controllerName, string areaName, string cacheKeyPrefix,bool useCache, out string[] searchedLocations)
    {
        searchedLocations = EmptyLocations;
        if (string.IsNullOrEmpty(name))
        {
            return string.Empty;
        }
        if ((locations == null) || (locations.Length == 0))
        {
            throw new InvalidOperationException(string.Format("The property " +
                "'{0}' cannot be null or empty.", locationsPropertyName));
        }
        bool isSpecificPath = IsSpecificPath(name);
        string key = CreateCacheKey(cacheKeyPrefix, name,
            isSpecificPath ? string.Empty : controllerName,
            isSpecificPath ? string.Empty : areaName);
        if (useCache)
        {
            string viewLocation = ViewLocationCache.GetViewLocation(
                controllerContext.HttpContext, key);
            if (viewLocation != null)
            {
                return viewLocation;
            }
        }
        if (!isSpecificPath)
        {
            return GetPathFromGeneralName(controllerContext, locations, name,
                controllerName, areaName, key, ref searchedLocations);
        }
        return GetPathFromSpecificName(controllerContext, name, key,
            ref searchedLocations);
    }

    protected string GetPathFromGeneralName(ControllerContext controllerContext,string[] locations, string name, string controllerName,
        string areaName, string cacheKey, ref string[] searchedLocations)
    {
        string virtualPath = string.Empty;
        searchedLocations = new string[locations.Length];
        for (int i = 0; i < locations.Length; i++)
        {
            if (string.IsNullOrEmpty(areaName) && locations[i].Contains("{2}"))
            {
                continue;
            }
            string testPath = string.Format(CultureInfo.InvariantCulture,
                locations[i], name, controllerName, areaName);
            if (FileExists(controllerContext, testPath))
            {
                searchedLocations = EmptyLocations;
                virtualPath = testPath;
                ViewLocationCache.InsertViewLocation(
                    controllerContext.HttpContext, cacheKey, virtualPath);
                return virtualPath;
            }
            searchedLocations[i] = testPath;
        }
        return virtualPath;
    }

    protected string GetPathFromSpecificName(ControllerContext controllerContext, string name, string cacheKey,ref string[] searchedLocations)
    {
        string virtualPath = name;
        if (!FileExists(controllerContext, name))
        {
            virtualPath = string.Empty;
            searchedLocations = new string[] { name };
        }
        ViewLocationCache.InsertViewLocation(controllerContext.HttpContext,
            cacheKey, virtualPath);
        return virtualPath;
    }

    protected static bool IsSpecificPath(string name)
    {
        char ch = name[0];
        if (ch != '~')
        {
            return (ch == '/');
        }
        return true;
    }


}

After making these changes, action links both inside and outside areas were generated properly and I could route both inside & outside areas.