A smart way to handle Return URLs in an MVC environment

A problem I come up against again and again is handling redirection to the previous page after a user runs some action such as clicking a 'Back To ...' link or saving the record they are editing.

Previously whenever I have needed to know what page to return to, I would provide a returnURL parameter to my current view.

http://blah.com/account/edit/1?returnURL="account/index"

This isn't a very clean way of handling this situation, as sometimes the return URL contains parameters such as search strings, etc, which have to be included in the URL.

http://blah.com/account/edit/1?returnURL="account/index?search="searchTerm""

Also, this creates an issue when a user can go another page forward before coming back to the page with the returnURL because you have to pass the returnURL through all visited pages.

Simply calling the browser's Back functionality isn't really sufficient either, because you might want the page to refresh, e.g. to show the edits you just saved in the previous page.

So my que开发者_如何转开发stion is, has anyone found a smart way to handle this kind of situation, specifically in an MVC environment?

Note: I am using ASP .NET MVC so if possible I'd like answers to pertain to that, however any ideas are welcome.

What's wrong with setting a cookie, or using a session variable? The only reason you wouldn't is if you don't control the page that calls into you, in which case your only options are query strings, post values, or referrer.

I thought I might add my answer to the question to see if others think it's a good idea.

I'm simply passing it through to the controller using TempViewData:

@{
   TempData["returnURL"] = Request.Url.AbsoluteUri;
}

and then accessing it in a similar way to this (in my real version I check that the key is in TempData and that the returnURL is a real URL):

return Redirect(TempData["returnURL"].ToString());

If it needs to continue on past the first page change (i.e. Search page -> Edit page -> Edit Section page) I'm adding it again

TempData["returnURL"] = TempData["returnURL"];

Check my blog post on it: Using cookies to control return page after login on asp.net mvc 3

Just like @Mystere Man mentioned, you can just use a cookie or session for it. I went for cookies back when I had a similar situation a while ago.

Try register a new route of which the url is /{controller}/{action}/{id}/returnurl/{*url} and then use a RedirectToAction in the action that accepts url as a parameter

Request.UrlReferrer.AbsoluteUri

though i'd still argue that you shouldn't be creating your own "back" button.

Use an interceptor or an aspect:

1. Intercept each request in some fashion (e.g., a @Before aspect) and save the requested URL to the session, overwriting it each time
2. In your view layer, access that Session object as needed, in your case for the back link.

This kind of design allows you to always have the most recent request available if you want to use it. Here's an example to write an aspect / interceptor in .NET. Additionaly, PostSharp is a .NET aspect project.

At present, a quick and dirty method has eluded me... so I'm using a practical method.

On a conceptual level, the 'back-ability' of a page should be determined by the page that you're currently on. The View can infer this (in most cases) if the parameters captured in the Controller are passed to it via the ViewModel.

Example:

Having visited Foo, I'm going to Bar to view some stuff, and the back button should return to Foo.

Controller

public ActionResult Foo(string fooId) // using a string for your Id, good idea; Encryption, even better.
{
    FooModel model = new FooModel() { fooId = fooId }; // property is passed to the Model - important.
    model.Fill();
    return View("FooView", model);
}

public ActionResult Bar(string fooId, string barId)
{
    BarModel model = new BarModel() { fooId = fooId; barId = barId };
    model.Fill()
    return View("BarView", model)
}

ViewModels

public class FooModel
{
    public string fooId { get; set; }

    public void Fill()
    {
        // Get info from Repository.
    }
}

public class BarModel
{
    public string fooId { get; set; }
    public string barId { get; set; }

    public void Fill()
    {
        // Get info from Repository.
    }
}

View (Partial) // No pun intended... or maybe it was. :)

Your BarView can now interpret from its model where it needs to go back to (using fooId).

On your BarView (using MVC2 syntax):

<a href="<%= string.Format("/Foo?fooId={0}", Model.fooId) %>">Back</a>

You can use Html.ActionLink as well.

Alternatively:

You can inherit your ViewModels from a BaseViewModel, which can have a protected property returnURL. Set this where necessary.

Example:

On your ViewModel:

public class BarModel : BaseViewModel
{
    public string fooId { get; set; }
    public string barId { get; set; }

    public void Fill()
    {
        returnURL = string.Format("/Foo?fooId={0}", fooId)
        // Get info from Repository.
    }
}

On View:

<a href="<%=returnURL %>">Back</a>

Would this be better handled by partial actions that display without leaving the page and using JQuery to make a dialog/wizard workflow?

Then you only need to react to the 'Finish' button on the dialog to refresh the original view.

For the part of your question regarding "saving the record they are editing" I would think the post-redirect-get (PGR) pattern would apply to you.

This might be a good place to read about it if you are not familiar with it.

• http://en.wikipedia.org/wiki/Post/Redirect/Get
• http://blog.andreloker.de/post/2008/06/Post-Redirect-Get.aspx

1. Encode the returnUrl using Url.Encode(returnUrl) for inclusion in the URL.
2. When ready to redirect, use Url.Decode(returnUrl) and use the value for the actual redirect.