ASP.NET MVC Chemins Relatifs

Tout en un vieux post, de nouveaux lecteurs doivent savoir que le Rasoir 2 et ultérieur (par défaut dans MVC4+) complètement résout ce problème.

Vieux MVC3 avec Rasoir 1:

<a href="@Url.Content("~/Home")">Application home page</a>

Nouveau MVC4 avec Rasoir 2 et plus tard:

<a href="~/Home">Application home page</a>

Pas maladroit de Rasoir fonction de syntaxe.
Aucune non-standard des balises de formatage.

Préfixant un chemin dans tout les attributs HTML avec un tilde ('~') dit Rasoir 2 à "faire fonctionner" en substituant le chemin d'accès correct. C'est génial.

Dans ASP.NET j'ai l'habitude d'utiliser <img src='<%= VirtualPathUtility.ToAbsolute("~/images/logo.gif") %>' alt="Our Company Logo"/>.
Je ne vois pas pourquoi une solution similaire ne devrait pas travailler dans ASP.NET MVC.

Pour ce que ça vaut, je déteste vraiment l'idée de l'abandon de détritus mon application avec les balises de serveur seulement pour régler des chemins, j'ai donc fait une recherche un peu plus et opté pour l'utilisation de quelque chose que j'avais essayé avant de réécriture de liens - un filtre de réponse. De cette façon, je peux préfixe tous les chemins d'accès absolus avec un préfixe et de le remplacer lors de l'exécution à l'aide de la Réponse.L'objet de filtre et ne pas avoir à s'inquiéter inutilement les balises de serveur. Le code est affiché ci-dessous dans le cas où il aidera quelqu'un d'autre.

using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
namespace Demo
{
public class PathRewriter : Stream
{
Stream filter;
HttpContext context;
object writeLock = new object();
StringBuilder sb = new StringBuilder();
Regex eofTag = new Regex("</html>", RegexOptions.IgnoreCase | RegexOptions.Compiled);
Regex rootTag = new Regex("/_AppRoot_", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public PathRewriter(Stream filter, HttpContext context)
{
this.filter = filter;
this.context = context;
}
public override void Write(byte[] buffer, int offset, int count)
{
string temp;
lock (writeLock)
{
temp = Encoding.UTF8.GetString(buffer, offset, count);
sb.Append(temp);
if (eofTag.IsMatch(temp))
RewritePaths();
}
}
public void RewritePaths()
{
byte[] buffer;
string temp;
string root;
temp = sb.ToString();
root = context.Request.ApplicationPath;
if (root == "/") root = "";
temp = rootTag.Replace(temp, root);
buffer = Encoding.UTF8.GetBytes(temp);
filter.Write(buffer, 0, buffer.Length);
}
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return filter.CanSeek; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
return;
}
public override long Length
{
get { return Encoding.UTF8.GetBytes(sb.ToString()).Length; }
}
public override long Position
{
get { return filter.Position; }
set { filter.Position = value; }
}
public override int Read(byte[] buffer, int offset, int count)
{
return filter.Read(buffer, offset, count);
}
public override long Seek(long offset, SeekOrigin origin)
{
return filter.Seek(offset, origin);
}
public override void SetLength(long value)
{
throw new NotImplementedException();
}
}
public class PathFilterModule : IHttpModule
{
public void Dispose()
{
return;
}
public void Init(HttpApplication context)
{
context.ReleaseRequestState += new EventHandler(context_ReleaseRequestState);
}
void context_ReleaseRequestState(object sender, EventArgs e)
{
HttpApplication app = sender as HttpApplication;
if (app.Response.ContentType == "text/html")
app.Response.Filter = new PathRewriter(app.Response.Filter, app.Context);
}
}
}

Comme Chris, je ne peux vraiment pas supporter d'avoir à mettre de ballonnement côté serveur balises à l'intérieur de mon propre balisage seulement de dire la chose stupide de chercher à partir de la racine vers le haut. Qui devrait être très simple, raisonnable chose à demander. Mais je déteste l'idée d'avoir à aller à l'effort de l'écriture personnalisée de classes C# pour faire une chose si simple, pourquoi devrais-je? Quel gaspillage de temps.

Pour moi, j'ai tout simplement compromis sur la "perfection" et codée en dur dans le répertoire virtuel de la racine du nom du chemin d'accès à l'intérieur de mon chemin de références. Donc comme ceci:

<script type="text/javascript" src="/MyProject/Scripts/jquery-1.2.6.js"></script>

Pas de traitement côté serveur ou C# code nécessaire à la résolution des URL, ce qui est le mieux pour le rendement, même si je sais qu'il serait négligeable, peu importe. Et pas de ballonnement laid côté serveur chaos dans mon propre bien balisage.

Je vais devoir vivre avec, sachant que c'est codé en dur et aura besoin d'être enlevé lorsque la chose migre vers un domaine approprié au lieu de http://MyDevServer/MyProject/

Acclamations

J'utilise une simple méthode d'assistance. Vous pouvez facilement l'utiliser dans les Vues et les Contrôleurs.

Balisage:

<a href=@Helper.Root()/about">About Us</a>

Méthode d'assistance:

public static string Root()
{
if (HttpContext.Current.Request.Url.Host == "localhost")
{
return "";
}
else
{
return "/productionroot";
}
}