Utiliser le routage ASP.NET pour servir des fichiers statiques

Question

Le routage ASP.Net (pas MVC) peut-il être utilisé pour servir des fichiers statiques ?

Disons que je veux acheminer

http://domain.tld/static/picture.jpg

à

http://domain.tld/a/b/c/picture.jpg

et je veux le faire de manière dynamique, c'est-à-dire que l'URL réécrite est calculée à la volée. Je ne peux pas mettre en place une route statique une fois pour toutes.

Quoi qu'il en soit, je peux créer un itinéraire comme celui-ci :

routes.Add(
  "StaticRoute", new Route("static/{file}", new FileRouteHandler())
);

Dans le cadre de la FileRouteHandler.ProcessRequest je peux réécrire le chemin de /static/picture.jpg à /a/b/c/picture.jpg . Je souhaite ensuite créer un gestionnaire pour les fichiers statiques. ASP.NET utilise la fonction StaticFileHandler à cette fin. Malheureusement, cette classe est interne. J'ai essayé de créer le gestionnaire en utilisant la réflexion et cela fonctionne :

Assembly assembly = Assembly.GetAssembly(typeof(IHttpHandler));
Type staticFileHandlerType = assembly.GetType("System.Web.StaticFileHandler");
ConstructorInfo constructorInfo = staticFileHandlerType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
return (IHttpHandler) constructorInfo.Invoke(null);

Mais l'utilisation de types internes ne semble pas être la bonne solution. Une autre option est d'implémenter mon propre StaticFileHandler mais le faire correctement (en prenant en charge les éléments HTTP tels que les plages et les balises) n'est pas une tâche triviale.

Comment dois-je aborder le routage des fichiers statiques en ASP.NET ?

Answer 1

Pourquoi ne pas utiliser IIS pour ce faire ? Vous pourriez créer une règle de redirection pour diriger toutes les demandes provenant de la première route vers la seconde avant même qu'elles n'atteignent votre application. Il s'agit donc d'une méthode plus rapide pour rediriger les demandes.

En supposant que vous ayez IIS7+, vous feriez quelque chose comme...

<rule name="Redirect Static Images" stopProcessing="true">
  <match url="^static/?(.*)$" />
  <action type="Redirect" url="/a/b/c/{R:1}" redirectType="Permanent" />
</rule>

Ou si vous n'avez pas besoin de rediriger, comme le suggère @ni5ni6 :

<rule name="Rewrite Static Images" stopProcessing="true">
  <match url="^static/?(.*)$" />
  <action type="Rewrite" url="/a/b/c/{R:1}" />
</rule>

Modifier 2015-06-17 pour @RyanDawkins :

Et si vous vous demandez où se trouve la règle de réécriture, voici une carte de son emplacement dans le fichier web.config fichier.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.webServer>
    <rewrite>
      <rules>
        <!-- rules go below -->
        <rule name="Redirect Static Images" stopProcessing="true">
          <match url="^static/?(.*)$" />
          <action type="Redirect" url="/a/b/c/{R:1}" redirectType="Permanent" />
        </rule>
      </rules>
    </rewrite>
  </system.webServer>
</configuration>

Answer 2

Après avoir creusé ce problème pendant quelques heures, j'ai découvert qu'il suffisait d'ajouter des règles d'ignorance pour que vos fichiers statiques soient servis.

Dans RegisterRoutes(RouteCollection routes), ajoutez les règles d'ignorance suivantes :

routes.IgnoreRoute("{file}.js");
routes.IgnoreRoute("{file}.html");

Answer 3

J'ai eu un problème similaire. J'ai fini par utiliser HttpContext.RewritePath :

public class MyApplication : HttpApplication
{
    private readonly Regex r = new Regex("^/static/(.*)$", RegexOptions.IgnoreCase);

    public override void Init()
    {
        BeginRequest += OnBeginRequest;
    }

    protected void OnBeginRequest(object sender, EventArgs e)
    {
        var match = r.Match(Request.Url.AbsolutePath);
        if (match.Success)
        {
            var fileName = match.Groups[1].Value;
            Context.RewritePath(string.Format("/a/b/c/{0}", fileName));
        }
    }
}

Answer 4

J'ai trouvé une alternative à l'utilisation de l'outil interne StaticFileHandler . Dans le IRouteHandler J'appelle HttpServerUtility.Transfer :

public class FileRouteHandler : IRouteHandler {

  public IHttpHandler GetHttpHandler(RequestContext requestContext) {
    String fileName = (String) requestContext.RouteData.Values["file"];
    // Contrived example of mapping.
    String routedPath = String.Format("/a/b/c/{0}", fileName);
    HttpContext.Current.Server.Transfer(routedPath);
    return null; // Never reached.
  }

}

Il s'agit d'un piratage. Les IRouteHandler est censé renvoyer un IHttpHandler et non d'abandonner et de transférer la demande en cours. Cependant, cela permet d'obtenir ce que je veux.

L'utilisation de l'interface interne StaticFileHandler est aussi un peu un hack puisque j'ai besoin d'une réflexion pour y accéder, mais au moins il y a un peu de la documentation sur StaticFileHandler sur MSDN ce qui en fait une classe un peu plus "officielle". Malheureusement, je ne pense pas qu'il soit possible de réfléchir aux classes internes dans un environnement de confiance partielle.

Je m'en tiendrai à l'utilisation de StaticFileHandler car je ne pense pas qu'il sera retiré d'ASP.NET dans un avenir proche.

Answer 5

Vous devez ajouter un TransferRequestHandler pour gérer vos fichiers statiques, voir la réponse suivante https://stackoverflow.com/a/21724783/22858