Come simulare Server.Transfer in ASP.NET MVC?

In ASP.NET MVC è possibile restituire un ActionResult di reindirizzamento abbastanza facilmente:

 return RedirectToAction("Index");

 or

 return RedirectToRoute(new { controller = "home", version = Math.Random() * 10 });

Questo effettivamente fornirà un reindirizzamento HTTP, che normalmente va bene. Tuttavia, quando si utilizza Google Analytics, ciò causa grossi problemi perché il referer originale viene perso, quindi Google non sa da dove vieni. Ciò perde informazioni utili come qualsiasi termine del motore di ricerca.

Come nota a margine, questo metodo ha il vantaggio di rimuovere tutti i parametri che potrebbero provenire dalle campagne ma mi consente ancora di acquisirli sul lato server. Lasciandoli nella stringa di query porta le persone ai segnalibri o Twitter o blog un link che non dovrebbero. L'ho visto diverse volte in cui le persone hanno twitterato link al nostro sito contenenti ID campagna.

In ogni caso, sto scrivendo un controller "gateway" per tutte le visite in arrivo sul sito che posso reindirizzare verso luoghi diversi o versioni alternative.

Per ora mi interessa di più di Google per ora (piuttosto che dei segnalibri accidentali) e voglio essere in grado di inviare qualcuno che visita /la pagina che otterrebbe se fosse andato a /home/7, che è la versione 7 di una homepage.

Come ho detto prima, se lo faccio perdo la capacità di google di analizzare il referer:

 return RedirectToAction(new { controller = "home", version = 7 });

Quello che voglio davvero è un

 return ServerTransferAction(new { controller = "home", version = 7 });

che mi porterà quella vista senza un reindirizzamento lato client. Non penso che esista una cosa del genere.

Attualmente la cosa migliore che posso inventare è duplicare l'intera logica del controller HomeController.Index(..)nella mia GatewayController.Indexazione. Ciò significa che ho dovuto trasferirmi 'Views/Home'in 'Shared'modo che fosse accessibile. Deve esserci un modo migliore ?? ..

Che ne dici di una classe TransferResult? (basato sulla risposta di Stans )

/// <summary>
/// Transfers execution to the supplied url.
/// </summary>
public class TransferResult : ActionResult
{
    public string Url { get; private set; }

    public TransferResult(string url)
    {
        this.Url = url;
    }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
            throw new ArgumentNullException("context");

        var httpContext = HttpContext.Current;

        // MVC 3 running on IIS 7+
        if (HttpRuntime.UsingIntegratedPipeline)
        {
            httpContext.Server.TransferRequest(this.Url, true);
        }
        else
        {
            // Pre MVC 3
            httpContext.RewritePath(this.Url, false);

            IHttpHandler httpHandler = new MvcHttpHandler();
            httpHandler.ProcessRequest(httpContext);
        }
    }
}

Aggiornato: ora funziona con MVC3 (usando il codice dal post di Simon ). Si dovrebbe (non sono stati in grado di provarlo) anche il lavoro in MVC2, cercando in se o non è in esecuzione all'interno della pipeline integrata di IIS7 +.

Per la massima trasparenza; Nel nostro ambiente di produzione non abbiamo mai usato direttamente TransferResult. Usiamo TransferToRouteResult che a sua volta chiama esegue TransferResult. Ecco cosa è effettivamente in esecuzione sui miei server di produzione.

public class TransferToRouteResult : ActionResult
{
    public string RouteName { get;set; }
    public RouteValueDictionary RouteValues { get; set; }

    public TransferToRouteResult(RouteValueDictionary routeValues)
        : this(null, routeValues)
    {
    }

    public TransferToRouteResult(string routeName, RouteValueDictionary routeValues)
    {
        this.RouteName = routeName ?? string.Empty;
        this.RouteValues = routeValues ?? new RouteValueDictionary();
    }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
            throw new ArgumentNullException("context");

        var urlHelper = new UrlHelper(context.RequestContext);
        var url = urlHelper.RouteUrl(this.RouteName, this.RouteValues);

        var actualResult = new TransferResult(url);
        actualResult.ExecuteResult(context);
    }
}

E se stai usando T4MVC (in caso contrario ... fallo!) Questa estensione potrebbe tornare utile.

public static class ControllerExtensions
{
    public static TransferToRouteResult TransferToAction(this Controller controller, ActionResult result)
    {
        return new TransferToRouteResult(result.GetRouteValueDictionary());
    }
}

Usando questo piccolo gioiello puoi farlo

// in an action method
TransferToAction(MVC.Error.Index());

Modifica: aggiornato per essere compatibile con ASP.NET MVC 3

Se si utilizza IIS7, la seguente modifica sembra funzionare per ASP.NET MVC 3. Grazie a @nitin e @andy per aver sottolineato il codice originale non ha funzionato.

Modifica 4/11/2011: TempData si rompe con Server.TransferRequest a partire da MVC 3 RTM

Modificato il codice seguente per generare un'eccezione, ma al momento non esiste altra soluzione.

Ecco la mia modifica basata sulla versione modificata di Markus del post originale di Stan. Ho aggiunto un costruttore aggiuntivo per prendere un dizionario del valore di route e l'ho rinominato MVCTransferResult per evitare confusione sul fatto che potrebbe essere solo un reindirizzamento.

Ora posso fare quanto segue per un reindirizzamento:

return new MVCTransferResult(new {controller = "home", action = "something" });

La mia classe modificata:

public class MVCTransferResult : RedirectResult
{
    public MVCTransferResult(string url)
        : base(url)
    {
    }

    public MVCTransferResult(object routeValues):base(GetRouteURL(routeValues))
    {
    }

    private static string GetRouteURL(object routeValues)
    {
        UrlHelper url = new UrlHelper(new RequestContext(new HttpContextWrapper(HttpContext.Current), new RouteData()), RouteTable.Routes);
        return url.RouteUrl(routeValues);
    }

    public override void ExecuteResult(ControllerContext context)
    {
        var httpContext = HttpContext.Current;

        // ASP.NET MVC 3.0
        if (context.Controller.TempData != null && 
            context.Controller.TempData.Count() > 0)
        {
            throw new ApplicationException("TempData won't work with Server.TransferRequest!");
        }

        httpContext.Server.TransferRequest(Url, true); // change to false to pass query string parameters if you have already processed them

        // ASP.NET MVC 2.0
        //httpContext.RewritePath(Url, false);
        //IHttpHandler httpHandler = new MvcHttpHandler();
        //httpHandler.ProcessRequest(HttpContext.Current);
    }
}

È invece possibile utilizzare Server.TransferRequest su IIS7 +.

Di recente ho scoperto che ASP.NET MVC non supporta Server.Transfer (), quindi ho creato un metodo stub (ispirato a Default.aspx.cs).

    private void Transfer(string url)
    {
        // Create URI builder
        var uriBuilder = new UriBuilder(Request.Url.Scheme, Request.Url.Host, Request.Url.Port, Request.ApplicationPath);
        // Add destination URI
        uriBuilder.Path += url;
        // Because UriBuilder escapes URI decode before passing as an argument
        string path = Server.UrlDecode(uriBuilder.Uri.PathAndQuery);
        // Rewrite path
        HttpContext.Current.RewritePath(path, false);
        IHttpHandler httpHandler = new MvcHttpHandler();
        // Process request
        httpHandler.ProcessRequest(HttpContext.Current);
    }

Non potresti semplicemente creare un'istanza del controller a cui desideri reindirizzare, invocare il metodo di azione desiderato, quindi restituire il risultato? Qualcosa di simile a:

 HomeController controller = new HomeController();
 return controller.Index();

Volevo reindirizzare la richiesta corrente a un altro controller / azione, mantenendo lo stesso percorso di esecuzione esattamente come se fosse richiesto quel secondo controller / azione. Nel mio caso, Server.Request non funzionava perché volevo aggiungere più dati. Questo in realtà equivale all'attuale gestore che esegue un altro HTTP GET / POST, quindi trasmette i risultati al client. Sono sicuro che ci saranno modi migliori per raggiungere questo obiettivo, ma ecco cosa funziona per me:

RouteData routeData = new RouteData();
routeData.Values.Add("controller", "Public");
routeData.Values.Add("action", "ErrorInternal");
routeData.Values.Add("Exception", filterContext.Exception);

var context = new HttpContextWrapper(System.Web.HttpContext.Current);
var request = new RequestContext(context, routeData);

IController controller = ControllerBuilder.Current.GetControllerFactory().CreateController(filterContext.RequestContext, "Public");
controller.Execute(request);

La tua ipotesi è corretta: ho inserito questo codice

public class RedirectOnErrorAttribute : ActionFilterAttribute, IExceptionFilter

e lo sto usando per mostrare errori agli sviluppatori, mentre utilizzerà un reindirizzamento regolare in produzione. Si noti che non volevo utilizzare la sessione ASP.NET, il database o altri modi per passare i dati delle eccezioni tra le richieste.

Invece di simulare un trasferimento del server, MVC è ancora in grado di eseguire effettivamente un Server.TransferRequest :

public ActionResult Whatever()
{
    string url = //...
    Request.RequestContext.HttpContext.Server.TransferRequest(url);
    return Content("success");//Doesn't actually get returned
}

Basta istanziare l'altro controller ed eseguire il suo metodo di azione.

È possibile riavviare l'altro controller e richiamare il metodo di azione che restituisce il risultato. Ciò richiederà tuttavia di posizionare la vista nella cartella condivisa.

Non sono sicuro se questo è ciò che intendevi per duplicato ma:

return new HomeController().Index();

modificare

Un'altra opzione potrebbe essere quella di creare la propria ControllerFactory, in questo modo è possibile determinare quale controller creare.

Il routing non si occupa solo di questo scenario per te? vale a dire per lo scenario sopra descritto, è possibile creare un gestore di route che implementa questa logica.

Per chiunque utilizzi il routing basato su espressioni, usando solo la classe TransferResult sopra, ecco un metodo di estensione del controller che fa il trucco e conserva TempData. Non è necessario TransferToRouteResult.

public static ActionResult TransferRequest<T>(this Controller controller, Expression<Action<T>> action)
    where T : Controller
{
     controller.TempData.Keep();
     controller.TempData.Save(controller.ControllerContext, controller.TempDataProvider);
     var url = LinkBuilder.BuildUrlFromExpression(controller.Request.RequestContext, RouteTable.Routes, action);
     return new TransferResult(url);
}

Server.TransferRequestè completamente inutile in MVC . Questa è una funzionalità obsoleta che era necessaria solo in ASP.NET perché la richiesta arrivava direttamente a una pagina e doveva esserci un modo per trasferire una richiesta in un'altra pagina. Le versioni moderne di ASP.NET (incluso MVC) dispongono di un'infrastruttura di routing che può essere personalizzata per instradare direttamente alla risorsa desiderata. Non ha senso lasciare che la richiesta raggiunga un controller solo per trasferirlo su un altro controller quando puoi semplicemente far passare la richiesta direttamente al controller e all'azione che desideri.

Inoltre, poiché stai rispondendo alla richiesta originale , non è necessario inserire nulla TempDatao altro spazio di archiviazione solo per il routing della richiesta nel posto giusto. Invece, si arriva all'azione del controller con la richiesta originale intatta. Puoi anche essere certo che Google approverà questo approccio poiché si verifica interamente sul lato server.

Sebbene sia possibile fare abbastanza da entrambi IRouteConstrainte IRouteHandler, il punto di estensione più potente per il routing è la RouteBasesottoclasse. Questa classe può essere estesa per fornire sia rotte in entrata che generazione di URL in uscita, il che la rende uno sportello unico per tutto ciò che ha a che fare con l'URL e l'azione che l'URL esegue.

Quindi, per seguire il tuo secondo esempio, per ottenere da /a /home/7, hai semplicemente bisogno di una rotta che aggiunga i valori di rotta appropriati.

public class RouteConfig
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        // Routes directy to `/home/7`
        routes.MapRoute(
            name: "Home7",
            url: "",
            defaults: new { controller = "Home", action = "Index", version = 7 }
        );

        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
        );
    }
}

Ma tornando all'esempio originale in cui hai una pagina casuale, è più complesso perché i parametri del percorso non possono cambiare in fase di esecuzione. Quindi, potrebbe essere fatto con una RouteBasesottoclasse come segue.

public class RandomHomePageRoute : RouteBase
{
    private Random random = new Random();

    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
        RouteData result = null;

        // Only handle the home page route
        if (httpContext.Request.Path == "/")
        {
            result = new RouteData(this, new MvcRouteHandler());

            result.Values["controller"] = "Home";
            result.Values["action"] = "Index";
            result.Values["version"] = random.Next(10) + 1; // Picks a random number from 1 to 10
        }

        // If this isn't the home page route, this should return null
        // which instructs routing to try the next route in the route table.
        return result;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        var controller = Convert.ToString(values["controller"]);
        var action = Convert.ToString(values["action"]);

        if (controller.Equals("Home", StringComparison.OrdinalIgnoreCase) &&
            action.Equals("Index", StringComparison.OrdinalIgnoreCase))
        {
            // Route to the Home page URL
            return new VirtualPathData(this, "");
        }

        return null;
    }
}

Che può essere registrato nel routing come:

public class RouteConfig
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        // Routes to /home/{version} where version is randomly from 1-10
        routes.Add(new RandomHomePageRoute());

        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
        );
    }
}

Nota nell'esempio sopra, potrebbe avere senso memorizzare anche un cookie che registra la versione della home page su cui l'utente è entrato, quindi quando ritornano ricevono la stessa versione della home page.

Si noti inoltre che utilizzando questo approccio è possibile personalizzare il routing per prendere in considerazione i parametri della stringa di query (li ignora completamente per impostazione predefinita) e instradare di conseguenza ad un'azione del controller appropriata.

Esempi aggiuntivi

• https://stackoverflow.com/a/31958586
• https://stackoverflow.com/a/36774498
• https://stackoverflow.com/a/36168395

Non una risposta di per sé, ma chiaramente il requisito sarebbe non solo che la navigazione effettiva "eseguisse" le funzionalità equivalenti di Webforms Server.Transfer (), ma anche che tutto ciò fosse pienamente supportato nell'ambito del test unitario.

Pertanto ServerTransferResult dovrebbe "apparire" come un RedirectToRouteResult ed essere il più simile possibile in termini di gerarchia di classi.

Sto pensando di farlo guardando Reflector e facendo qualunque cosa RedirectToRouteResult e anche i vari metodi della classe base del Controller, e poi "aggiungendo" quest'ultimo al Controller tramite metodi di estensione. Forse questi potrebbero essere metodi statici all'interno della stessa classe, per facilità / pigrizia di download?

Se riesco a farlo, lo pubblicherò, altrimenti forse qualcun altro potrebbe battermi!

Ho raggiunto questo obiettivo sfruttando l' Html.RenderActionhelper in una vista:

@{
    string action = ViewBag.ActionName;
    string controller = ViewBag.ControllerName;
    object routeValues = ViewBag.RouteValues;
    Html.RenderAction(action, controller, routeValues);
}

E nel mio controller:

public ActionResult MyAction(....)
{
    var routeValues = HttpContext.Request.RequestContext.RouteData.Values;    
    ViewBag.ActionName = "myaction";
    ViewBag.ControllerName = "mycontroller";
    ViewBag.RouteValues = routeValues;    
    return PartialView("_AjaxRedirect");
}