Asp.Net centre RouteData de la valeur à partir de l'url

Je suis wokring sur un nouveau Asp.Net core, mvc, app. J'ai défini une route avec une mesure de contrainte, qui définit application actuelle de la culture à partir de l'url. Je suis en train de gérer la localisation pour mon application, par la création d'une coutume IRequestCultureProvider qui ressemble à ceci :

public class MyCustomRequestCultureProvider : IRequestCultureProvider
    {
        public Task<ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
        {
            var language= httpContext.GetRouteValue("language");

            var result = new ProviderCultureResult(language, language);
            return Task.FromResult(result);
        }
    }

Mon MyCustomRequestCultureProvider est frappé à chaque requête, ce qui est ok. Mon problème est que dans le MVC pipeline, DetermineProviderCultureResult méthode de mon fournisseur est atteint avant que le processus de routage, de sorte httpContext.GetRouteValue("language") toujours retourner la valeur null.

Dans la version précédente de la MVC, j'ai eu la possibilité de traiter manuellement l'adresse de ma page à travers le processus de routage en faisant cela,

var wrapper = new HttpContextWrapper(HttpContext.Current);
var routeData = RouteTable.Routes.GetRouteData(wrapper);
var language = routeData.GetValue("language")

Je ne peux pas trouver un moyen de faire la même chose dans le nouveau framewrok droit maintenant. Aussi, je veux utiliser les données sur le parcours de découvrir ma langugae, l'analyse de ma chaîne d'url avec certaines fonctions de chaîne pour trouver la langue n'est pas une option.

Cette la question et sa réponse pourrait aider
Pourriez-vous résoudre ce problème?
voir ma réponse

InformationsquelleAutor Nicolas Boisvert | 2016-07-21

Il n'y a pas un moyen facile de faire cela, et les ASP.Net l'équipe n'a pas décidé de mettre en œuvre cette fonctionnalité. IRoutingFeature n'est disponible qu'après MVC a terminé la demande.

J'ai été en mesure de mettre ensemble une solution qui devrait fonctionner pour vous. Cela va de l'installation sur les itinéraires que vous êtes de passage dans UseMvc() ainsi que tous les attributs de routage afin de remplir IRoutingFeature. Après cela, vous pouvez accéder à cette classe via httpContext.GetRouteValue("language");.

De démarrage.cs

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    //setup routes
    app.UseGetRoutesMiddleware(GetRoutes);

    //add localization
    var requestLocalizationOptions = new RequestLocalizationOptions
    {
        DefaultRequestCulture = new RequestCulture("en-US")
    };
    requestLocalizationOptions.RequestCultureProviders.Clear();
    requestLocalizationOptions.RequestCultureProviders.Add(
        new MyCustomRequestCultureProvider()
    );
    app.UseRequestLocalization(requestLocalizationOptions);

    //add mvc
    app.UseMvc(GetRoutes);
}

Déplacé les routes à un délégué (pour la ré-utilisabilité), de même fichier/classe:

private readonly Action<IRouteBuilder> GetRoutes =
    routes =>
    {
        routes.MapRoute(
            name: "custom",
            template: "{language=fr-FR}/{controller=Home}/{action=Index}/{id?}");

        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    };

Ajouter un nouveau middleware:

public static class GetRoutesMiddlewareExtensions
{
    public static IApplicationBuilder UseGetRoutesMiddleware(this IApplicationBuilder app, Action<IRouteBuilder> configureRoutes)
    {
        if (app == null)
        {
            throw new ArgumentNullException(nameof(app));
        }

        var routes = new RouteBuilder(app)
        {
            DefaultHandler = app.ApplicationServices.GetRequiredService<MvcRouteHandler>(),
        };
        configureRoutes(routes);
        routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices));
        var router = routes.Build();

        return app.UseMiddleware<GetRoutesMiddleware>(router);
    }
}

public class GetRoutesMiddleware
{
    private readonly RequestDelegate next;
    private readonly IRouter _router;

    public GetRoutesMiddleware(RequestDelegate next, IRouter router)
    {
        this.next = next;
        _router = router;
    }

    public async Task Invoke(HttpContext httpContext)
    {
        var context = new RouteContext(httpContext);
        context.RouteData.Routers.Add(_router);

        await _router.RouteAsync(context);

        if (context.Handler != null)
        {
            httpContext.Features[typeof (IRoutingFeature)] = new RoutingFeature()
            {
                RouteData = context.RouteData,
            };
        }

        //proceed to next...
        await next(httpContext);
    }
}

Vous pouvez définir cette classe ainsi...

public class RoutingFeature : IRoutingFeature
{
    public RouteData RouteData { get; set; }
}

Cela a bien fonctionné pour moi, j'avais besoin de ge
wow seulement être en mesure de modifier les commentaires pendant 5 minutes est une douleur! c'est ce que je voulais dire: j'ai besoin d'accéder à un paramètre dans certains autres middleware et de ce fait le travail pour moi avec peu ou pas de modification! 5* d'utiliser à nouveau

InformationsquelleAutor Ashley Lee

Basé sur Ashley Lee réponse, ici est une approche optimisée qui empêche la double voie de la configuration.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
   //setup routes
   var mvcRouter = BuildMvcRouter(app, routes =>
   {
       routes.MapRoute(
           name: "custom",
           template: "{language=fr-FR}/{controller=Home}/{action=Index}/{id?}");
       routes.MapRoute(
           name: "default",
           template: "{controller=Home}/{action=Index}/{id?}");
    });

    //add route data initialization middleware
    app.Use(next => SetRouteData(next, mvcRouter));

    //add localization middleware
    var requestLocalizationOptions = new RequestLocalizationOptions
    {
        DefaultRequestCulture = new RequestCulture("en-US")
    };
    requestLocalizationOptions.RequestCultureProviders.Clear();
    requestLocalizationOptions.RequestCultureProviders.Add(
        new MyCustomRequestCultureProvider()
    );
    app.UseRequestLocalization(requestLocalizationOptions);

    //add mvc routing middleware
    app.UseRouter(mvcRouter);
}

Cela dépend de l'une des deux méthodes suivantes qui doivent être ajoutés au Démarrage de classe:

private static IRouter BuildMvcRouter(IApplicationBuilder app, Action<IRouteBuilder> configureRoutes)
{
    if (app == null) throw new ArgumentNullException(nameof(app));
    if (configureRoutes == null) throw new ArgumentNullException(nameof(configureRoutes));

    app.ApplicationServices.GetRequiredService<MiddlewareFilterBuilder>().ApplicationBuilder = app.New();
    var routeBuilder = new RouteBuilder(app)
    {
        DefaultHandler = app.ApplicationServices.GetRequiredService<MvcRouteHandler>()
    };
    configureRoutes(routeBuilder);
    routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices));

    return routeBuilder.Build();
}

private static RequestDelegate SetRouteData(RequestDelegate next, IRouter router)
{
    return async context =>
    {
        var routeContext = new RouteContext(context);
        await router.RouteAsync(routeContext);

        if (routeContext.Handler != null)
        {
            context.Features[typeof(IRoutingFeature)] = new RoutingFeature
            {
                RouteData = routeContext.RouteData
            };
        }

        await next(context);
    };
}

InformationsquelleAutor Gerke Geurts

Vous devez vous connecter pour publier un commentaire.