Conventions de routes et d’applications pour les pages Razor dans ASP.NET CoreRazor Pages route and app conventions in ASP.NET Core

Par Luke LathamBy Luke Latham

Découvrez comment utiliser les conventions du fournisseur de modèles de routes et d’applications pour contrôler le routage, la découverte et le traitement des pages dans les applications à base de pages Razor.Learn how to use page route and app model provider conventions to control page routing, discovery, and processing in Razor Pages apps.

Quand vous devez configurer des routages de pages personnalisés pour des pages individuelles, configurez le routage vers les pages avec la convention AddPageRoute décrite plus loin dans cette rubrique.When you need to configure custom page routes for individual pages, configure routing to pages with the AddPageRoute convention described later in this topic.

Pour spécifier un itinéraire de page, ajouter des segments de routage ou ajouter des paramètres à un itinéraire, utilisez @page la directive de la page.To specify a page route, add route segments, or add parameters to a route, use the page's @page directive. Pour plus d’informations, consultez itinéraires personnalisés.For more information, see Custom routes.

Il existe des mots réservés qui ne peuvent pas être utilisés en tant que segments de routage ou noms de paramètres.There are reserved words that can't be used as route segments or parameter names. Pour plus d’informations, consultez routage: Nomsde routage réservés.For more information, see Routing: Reserved routing names.

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)View or download sample code (how to download)

ScénarioScenario L’exemple montre...The sample demonstrates ...
Conventions de modèleModel conventions

Conventions.AddConventions.Add
  • IPageRouteModelConventionIPageRouteModelConvention
  • IPageApplicationModelConventionIPageApplicationModelConvention
  • IPageHandlerModelConventionIPageHandlerModelConvention
Ajouter un modèle de route et un en-tête aux pages d’une application.Add a route template and header to an app's pages.
Conventions d’actions de routage de pagesPage route action conventions
  • AddFolderRouteModelConventionAddFolderRouteModelConvention
  • AddPageRouteModelConventionAddPageRouteModelConvention
  • AddPageRouteAddPageRoute
Ajouter un modèle de route aux pages d’un dossier et à une page unique.Add a route template to pages in a folder and to a single page.
Conventions d’actions de modèle de pagePage model action conventions
  • AddFolderApplicationModelConventionAddFolderApplicationModelConvention
  • AddPageApplicationModelConventionAddPageApplicationModelConvention
  • ConfigureFilter (classe de filtre, expression lambda ou fabrique de filtres)ConfigureFilter (filter class, lambda expression, or filter factory)
Ajouter un en-tête dans les pages d’un dossier, ajouter un en-tête dans une page unique et configurer une fabrique de filtres pour ajouter un en-tête dans les pages d’une application.Add a header to pages in a folder, add a header to a single page, and configure a filter factory to add a header to an app's pages.

Les conventions d’Razor pages sont ajoutées et configurées à l’aide de la AddRazorPagesOptions méthode d’extension Startup to AddMvc sur la collection de services dans la classe.Razor Pages conventions are added and configured using the AddRazorPagesOptions extension method to AddMvc on the service collection in the Startup class. Les exemples de convention suivants sont expliqués plus loin dans cette rubrique :The following convention examples are explained later in this topic:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc()
        .AddRazorPagesOptions(options =>
            {
                options.Conventions.Add( ... );
                options.Conventions.AddFolderRouteModelConvention(
                    "/OtherPages", model => { ... });
                options.Conventions.AddPageRouteModelConvention(
                    "/About", model => { ... });
                options.Conventions.AddPageRoute(
                    "/Contact", "TheContactPage/{text?}");
                options.Conventions.AddFolderApplicationModelConvention(
                    "/OtherPages", model => { ... });
                options.Conventions.AddPageApplicationModelConvention(
                    "/About", model => { ... });
                options.Conventions.ConfigureFilter(model => { ... });
                options.Conventions.ConfigureFilter( ... );
            });
}

Ordre de routageRoute order

Les itinéraires spécifient un Order pour le traitement (correspondance d’itinéraires).Routes specify an Order for processing (route matching).

TrierOrder ComportementBehavior
-1-1 L’itinéraire est traité avant le traitement des autres itinéraires.The route is processed before other routes are processed.
00 L’ordre n’est pas spécifié (valeur par défaut).Order isn't specified (default value). Si vous n' Order affectez pas (Order = null), Order l’itinéraire est défini par défaut sur 0 (zéro) pour le traitement.Not assigning Order (Order = null) defaults the route Order to 0 (zero) for processing.
1, 2, … n1, 2, … n Spécifie l’ordre de traitement des itinéraires.Specifies the route processing order.

Le traitement des itinéraires est établi par Convention:Route processing is established by convention:

  • Les itinéraires sont traités dans l’ordre séquentiel (-1, 0, 1, … 2, n).Routes are processed in sequential order (-1, 0, 1, 2, … n).
  • Lorsque les itinéraires ont le Ordermême, l’itinéraire le plus spécifique est mis en correspondance en premier, suivi d’itinéraires moins spécifiques.When routes have the same Order, the most specific route is matched first followed by less specific routes.
  • Lorsque des itinéraires avec le Order même nombre de paramètres correspondent à une URL de demande, les itinéraires sont traités dans l’ordre dans lequel ils sont ajoutés PageConventionCollectionau.When routes with the same Order and the same number of parameters match a request URL, routes are processed in the order that they're added to the PageConventionCollection.

Si possible, évitez de dépendre d’un ordre de traitement des itinéraires établi.If possible, avoid depending on an established route processing order. En règle générale, le routage sélectionne l’itinéraire correct avec la correspondance d’URL.Generally, routing selects the correct route with URL matching. Si vous devez définir Order des propriétés de routage pour acheminer les demandes correctement, le schéma de routage de l’application est sans doute confus pour les clients et fragiles à gérer.If you must set route Order properties to route requests correctly, the app's routing scheme is probably confusing to clients and fragile to maintain. Cherchez à simplifier le schéma de routage de l’application.Seek to simplify the app's routing scheme. L’exemple d’application requiert un ordre de traitement des itinéraires explicites pour illustrer plusieurs scénarios de routage à l’aide d’une seule application.The sample app requires an explicit route processing order to demonstrate several routing scenarios using a single app. Toutefois, vous devez tenter d’éviter d’avoir à définir l' Order itinéraire dans les applications de production.However, you should attempt to avoid the practice of setting route Order in production apps.

Le routage de Razor Pages et celui du contrôleur MVC partagent une implémentation.Razor Pages routing and MVC controller routing share an implementation. Pour plus d’informations sur l’ordre des itinéraires dans les rubriques MVC, consultez routage vers les actions du contrôleur: Classement des itinérairesdes attributs.Information on route order in the MVC topics is available at Routing to controller actions: Ordering attribute routes.

Conventions de modèleModel conventions

Ajoutez un délégué pour IPageConvention pour ajouter des conventions de modèle qui s’appliquent à Razor pages.Add a delegate for IPageConvention to add model conventions that apply to Razor Pages.

Ajouter une convention de modèle de routage à toutes les pagesAdd a route model convention to all pages

Utilisez Conventions pour créer et ajouter un IPageRouteModelConvention à la collection d' IPageConvention instances appliquées pendant la construction du modèle de routage de page.Use Conventions to create and add an IPageRouteModelConvention to the collection of IPageConvention instances that are applied during page route model construction.

L’exemple d’application ajoute un modèle de routage {globalTemplate?} à toutes les pages de l’application :The sample app adds a {globalTemplate?} route template to all of the pages in the app:

public class GlobalTemplatePageRouteModelConvention 
    : IPageRouteModelConvention
{
    public void Apply(PageRouteModel model)
    {
        var selectorCount = model.Selectors.Count;
        for (var i = 0; i < selectorCount; i++)
        {
            var selector = model.Selectors[i];
            model.Selectors.Add(new SelectorModel
            {
                AttributeRouteModel = new AttributeRouteModel
                {
                    Order = 1,
                    Template = AttributeRouteModel.CombineTemplates(
                        selector.AttributeRouteModel.Template, 
                        "{globalTemplate?}"),
                }
            });
        }
    }
}
public class GlobalTemplatePageRouteModelConvention 
    : IPageRouteModelConvention
{
    public void Apply(PageRouteModel model)
    {
        var selectorCount = model.Selectors.Count;
        for (var i = 0; i < selectorCount; i++)
        {
            var selector = model.Selectors[i];
            model.Selectors.Add(new SelectorModel
            {
                AttributeRouteModel = new AttributeRouteModel
                {
                    Order = 1,
                    Template = AttributeRouteModel.CombineTemplates(
                        selector.AttributeRouteModel.Template, 
                        "{globalTemplate?}"),
                }
            });
        }
    }
}

La propriété Order de AttributeRouteModel a la valeur 1.The Order property for the AttributeRouteModel is set to 1. Cela garantit le comportement de correspondance d’itinéraire suivant dans l’exemple d’application:This ensures the following route matching behavior in the sample app:

  • Un modèle de routage TheContactPage/{text?} pour est ajouté plus loin dans la rubrique.A route template for TheContactPage/{text?} is added later in the topic. L’itinéraire de la page de contact a un null ordreOrder = 0par défaut (), de sorte {globalTemplate?} qu’il corresponde avant le modèle de routage.The Contact Page route has a default order of null (Order = 0), so it matches before the {globalTemplate?} route template.
  • Un {aboutTemplate?} modèle de routage est ajouté plus loin dans la rubrique.An {aboutTemplate?} route template is added later in the topic. Le modèle {aboutTemplate?} reçoit l’ordre Order avec la valeur 2.The {aboutTemplate?} template is given an Order of 2. Quand la page About est demandée sur /About/RouteDataValue, « RouteDataValue » est chargé dans RouteData.Values["globalTemplate"] (Order = 1) et non RouteData.Values["aboutTemplate"] (Order = 2) en raison de la définition de la propriété Order.When the About page is requested at /About/RouteDataValue, "RouteDataValue" is loaded into RouteData.Values["globalTemplate"] (Order = 1) and not RouteData.Values["aboutTemplate"] (Order = 2) due to setting the Order property.
  • Un {otherPagesTemplate?} modèle de routage est ajouté plus loin dans la rubrique.An {otherPagesTemplate?} route template is added later in the topic. Le modèle {otherPagesTemplate?} reçoit l’ordre Order avec la valeur 2.The {otherPagesTemplate?} template is given an Order of 2. Quand une page du dossier pages/OtherPages est demandée avec un paramètre d’itinéraire (par exemple, /OtherPages/Page1/RouteDataValue), «RouteDataValue» est chargé dans RouteData.Values["globalTemplate"] (Order = 1) et non RouteData.Values["otherPagesTemplate"] (Order = 2) en raison de la définition de l' optionOrder propriété.When any page in the Pages/OtherPages folder is requested with a route parameter (for example, /OtherPages/Page1/RouteDataValue), "RouteDataValue" is loaded into RouteData.Values["globalTemplate"] (Order = 1) and not RouteData.Values["otherPagesTemplate"] (Order = 2) due to setting the Order property.

Order DansOrder = 0la mesure du possible, ne définissez pas, ce qui donne.Wherever possible, don't set the Order, which results in Order = 0. Utilisez le routage pour sélectionner l’itinéraire correct.Rely on routing to select the correct route.

Razor pages Options, telles que l' Conventionsajout, sont ajoutées lorsque MVC est ajouté à la collection de Startup.ConfigureServicesservices dans.Razor Pages options, such as adding Conventions, are added when MVC is added to the service collection in Startup.ConfigureServices. Pour obtenir un exemple, consultez l’exemple d’application.For an example, see the sample app.

options.Conventions.Add(new GlobalTemplatePageRouteModelConvention());
options.Conventions.Add(new GlobalTemplatePageRouteModelConvention());

Demandez la page About de l’exemple sur localhost:5000/About/GlobalRouteValue et examinez le résultat :Request the sample's About page at localhost:5000/About/GlobalRouteValue and inspect the result:

La page About est demandée avec un segment de routage pour GlobalRouteValue.

Ajouter une convention de modèle d’application à toutes les pagesAdd an app model convention to all pages

Utilisez Conventions pour créer et ajouter un IPageApplicationModelConvention à la collection d' IPageConvention instances appliquées pendant la construction du modèle d’application de la page.Use Conventions to create and add an IPageApplicationModelConvention to the collection of IPageConvention instances that are applied during page app model construction.

Pour illustrer cette convention et bien d’autres, plus loin dans cette rubrique, l’exemple d’application inclut une classe AddHeaderAttribute.To demonstrate this and other conventions later in the topic, the sample app includes an AddHeaderAttribute class. Le constructeur de classe accepte une chaîne name et un tableau de chaînes values.The class constructor accepts a name string and a values string array. Ces valeurs sont utilisées dans sa méthode OnResultExecuting pour définir un en-tête de réponse.These values are used in its OnResultExecuting method to set a response header. La classe complète est affichée dans la section Conventions d’actions de modèle de page, plus loin dans cette rubrique.The full class is shown in the Page model action conventions section later in the topic.

L’exemple d’application utilise la classe AddHeaderAttribute pour ajouter un en-tête, GlobalHeader, à toutes les pages de l’application :The sample app uses the AddHeaderAttribute class to add a header, GlobalHeader, to all of the pages in the app:

public class GlobalHeaderPageApplicationModelConvention 
    : IPageApplicationModelConvention
{
    public void Apply(PageApplicationModel model)
    {
        model.Filters.Add(new AddHeaderAttribute(
            "GlobalHeader", new string[] { "Global Header Value" }));
    }
}
public class GlobalHeaderPageApplicationModelConvention 
    : IPageApplicationModelConvention
{
    public void Apply(PageApplicationModel model)
    {
        model.Filters.Add(new AddHeaderAttribute(
            "GlobalHeader", new string[] { "Global Header Value" }));
    }
}

Startup.cs :Startup.cs:

options.Conventions.Add(new GlobalHeaderPageApplicationModelConvention());
options.Conventions.Add(new GlobalHeaderPageApplicationModelConvention());

Demandez la page About de l’exemple sur localhost:5000/About et examinez les en-têtes pour voir le résultat :Request the sample's About page at localhost:5000/About and inspect the headers to view the result:

Les en-têtes de réponse de la page About montrent que GlobalHeader a été ajouté.

Ajouter une convention de modèle de gestionnaire à toutes les pagesAdd a handler model convention to all pages

Utilisez Conventions pour créer et ajouter un IPageHandlerModelConvention à la collection d' IPageConvention instances appliquées pendant la construction du modèle de gestionnaire de page.Use Conventions to create and add an IPageHandlerModelConvention to the collection of IPageConvention instances that are applied during page handler model construction.

public class GlobalPageHandlerModelConvention
    : IPageHandlerModelConvention
{
    public void Apply(PageHandlerModel model)
    {
        // Access the PageHandlerModel
    }
}
public class GlobalPageHandlerModelConvention
    : IPageHandlerModelConvention
{
    public void Apply(PageHandlerModel model)
    {
        // Access the PageHandlerModel
    }
}

Startup.cs :Startup.cs:

options.Conventions.Add(new GlobalPageHandlerModelConvention());
options.Conventions.Add(new GlobalPageHandlerModelConvention());

Conventions d’actions de routage de pagesPage route action conventions

Le fournisseur de modèles de routage par défaut qui IPageRouteModelProvider dérive de appelle des conventions qui sont conçues pour fournir des points d’extensibilité pour la configuration des itinéraires de page.The default route model provider that derives from IPageRouteModelProvider invokes conventions which are designed to provide extensibility points for configuring page routes.

Convention de modèle de routage de dossierFolder route model convention

Utilisez AddFolderRouteModelConvention pour créer et ajouter un IPageRouteModelConvention objet qui appelle une action sur le PageRouteModel pour toutes les pages du dossier spécifié.Use AddFolderRouteModelConvention to create and add an IPageRouteModelConvention that invokes an action on the PageRouteModel for all of the pages under the specified folder.

L’exemple d’application utilise AddFolderRouteModelConvention pour ajouter un modèle de routage {otherPagesTemplate?} aux pages du dossier OtherPages :The sample app uses AddFolderRouteModelConvention to add an {otherPagesTemplate?} route template to the pages in the OtherPages folder:

options.Conventions.AddFolderRouteModelConvention("/OtherPages", model =>
{
    var selectorCount = model.Selectors.Count;
    for (var i = 0; i < selectorCount; i++)
    {
        var selector = model.Selectors[i];
        model.Selectors.Add(new SelectorModel
        {
            AttributeRouteModel = new AttributeRouteModel
            {
                Order = 2,
                Template = AttributeRouteModel.CombineTemplates(
                    selector.AttributeRouteModel.Template, 
                    "{otherPagesTemplate?}"),
            }
        });
    }
});
options.Conventions.AddFolderRouteModelConvention("/OtherPages", model =>
{
    var selectorCount = model.Selectors.Count;
    for (var i = 0; i < selectorCount; i++)
    {
        var selector = model.Selectors[i];
        model.Selectors.Add(new SelectorModel
        {
            AttributeRouteModel = new AttributeRouteModel
            {
                Order = 2,
                Template = AttributeRouteModel.CombineTemplates(
                    selector.AttributeRouteModel.Template, 
                    "{otherPagesTemplate?}"),
            }
        });
    }
});

La propriété Order de AttributeRouteModel a la valeur 2.The Order property for the AttributeRouteModel is set to 2. Cela permet de s’assurer que {globalTemplate?} le modèle pour (défini plus tôt 1dans la rubrique) est prioritaire pour la première position de valeur de données de routage lorsqu’une valeur de routage unique est fournie.This ensures that the template for {globalTemplate?} (set earlier in the topic to 1) is given priority for the first route data value position when a single route value is provided. Si une page du dossier pages/OtherPages est demandée avec une valeur de paramètre d’itinéraire (par exemple /OtherPages/Page1/RouteDataValue,), «RouteDataValue» est chargé RouteData.Values["globalTemplate"] dansOrder = 1() et RouteData.Values["otherPagesTemplate"] nonOrder = 2() en raison de la définition de l' optionOrder propriété.If a page in the Pages/OtherPages folder is requested with a route parameter value (for example, /OtherPages/Page1/RouteDataValue), "RouteDataValue" is loaded into RouteData.Values["globalTemplate"] (Order = 1) and not RouteData.Values["otherPagesTemplate"] (Order = 2) due to setting the Order property.

Order DansOrder = 0la mesure du possible, ne définissez pas, ce qui donne.Wherever possible, don't set the Order, which results in Order = 0. Utilisez le routage pour sélectionner l’itinéraire correct.Rely on routing to select the correct route.

Demandez la page Page1 de l’exemple sur localhost:5000/OtherPages/Page1/GlobalRouteValue/OtherPagesRouteValue et examinez le résultat :Request the sample's Page1 page at localhost:5000/OtherPages/Page1/GlobalRouteValue/OtherPagesRouteValue and inspect the result:

La page Page1 du dossier OtherPages est demandée avec un segment de routage pour GlobalRouteValue et OtherPagesRouteValue.

Convention de modèle de routage de pagePage route model convention

Utilisez AddPageRouteModelConvention pour créer et ajouter un IPageRouteModelConvention objet qui appelle une action sur le PageRouteModel pour la page avec le nom spécifié.Use AddPageRouteModelConvention to create and add an IPageRouteModelConvention that invokes an action on the PageRouteModel for the page with the specified name.

L’exemple d’application utilise AddPageRouteModelConvention pour ajouter un modèle de routage {aboutTemplate?} à la page About :The sample app uses AddPageRouteModelConvention to add an {aboutTemplate?} route template to the About page:

options.Conventions.AddPageRouteModelConvention("/About", model =>
{
    var selectorCount = model.Selectors.Count;
    for (var i = 0; i < selectorCount; i++)
    {
        var selector = model.Selectors[i];
        model.Selectors.Add(new SelectorModel
        {
            AttributeRouteModel = new AttributeRouteModel
            {
                Order = 2,
                Template = AttributeRouteModel.CombineTemplates(
                    selector.AttributeRouteModel.Template, 
                    "{aboutTemplate?}"),
            }
        });
    }
});
options.Conventions.AddPageRouteModelConvention("/About", model =>
{
    var selectorCount = model.Selectors.Count;
    for (var i = 0; i < selectorCount; i++)
    {
        var selector = model.Selectors[i];
        model.Selectors.Add(new SelectorModel
        {
            AttributeRouteModel = new AttributeRouteModel
            {
                Order = 2,
                Template = AttributeRouteModel.CombineTemplates(
                    selector.AttributeRouteModel.Template, 
                    "{aboutTemplate?}"),
            }
        });
    }
});

La propriété Order de AttributeRouteModel a la valeur 2.The Order property for the AttributeRouteModel is set to 2. Cela permet de s’assurer que {globalTemplate?} le modèle pour (défini plus tôt 1dans la rubrique) est prioritaire pour la première position de valeur de données de routage lorsqu’une valeur de routage unique est fournie.This ensures that the template for {globalTemplate?} (set earlier in the topic to 1) is given priority for the first route data value position when a single route value is provided. Si la page about est demandée avec une valeur de paramètre d' /About/RouteDataValueitinéraire à, «RouteDataValue» est RouteData.Values["globalTemplate"] chargéOrder = 1dans () RouteData.Values["aboutTemplate"] etOrder = 2non () en raison Order de la définition de la propriété.If the About page is requested with a route parameter value at /About/RouteDataValue, "RouteDataValue" is loaded into RouteData.Values["globalTemplate"] (Order = 1) and not RouteData.Values["aboutTemplate"] (Order = 2) due to setting the Order property.

Order DansOrder = 0la mesure du possible, ne définissez pas, ce qui donne.Wherever possible, don't set the Order, which results in Order = 0. Utilisez le routage pour sélectionner l’itinéraire correct.Rely on routing to select the correct route.

Demandez la page About de l’exemple sur localhost:5000/About/GlobalRouteValue/AboutRouteValue et examinez le résultat :Request the sample's About page at localhost:5000/About/GlobalRouteValue/AboutRouteValue and inspect the result:

La page About est demandée avec des segments de routage pour GlobalRouteValue et AboutRouteValue.

Utiliser un transformateur de paramètre pour personnaliser les itinéraires de pageUse a parameter transformer to customize page routes

Les itinéraires de page générés par ASP.NET Core peuvent être personnalisés à l’aide d’un transformateur de paramètres.Page routes generated by ASP.NET Core can be customized using a parameter transformer. Un transformateur de paramètre implémente IOutboundParameterTransformer et transforme la valeur des paramètres.A parameter transformer implements IOutboundParameterTransformer and transforms the value of parameters. Par exemple, un transformateur de paramètre SlugifyParameterTransformer personnalisé transforme la valeur de la route SubscriptionManagement en subscription-management.For example, a custom SlugifyParameterTransformer parameter transformer changes the SubscriptionManagement route value to subscription-management.

La PageRouteTransformerConvention Convention de modèle de routage de page applique un transformateur de paramètre aux segments de nom de dossier et de fichier des itinéraires de page générés automatiquement dans une application.The PageRouteTransformerConvention page route model convention applies a parameter transformer to the folder and file name segments of automatically generated page routes in an app. Par exemple, le fichier Razor pages sur /pages/SubscriptionManagement/viewall.cshtml aurait son itinéraire réécrit de /SubscriptionManagement/ViewAll à. /subscription-management/view-allFor example, the Razor Pages file at /Pages/SubscriptionManagement/ViewAll.cshtml would have its route rewritten from /SubscriptionManagement/ViewAll to /subscription-management/view-all.

PageRouteTransformerConventionconvertit uniquement les segments générés automatiquement d’un itinéraire de page provenant du dossier Razor Pages et du nom de fichier.PageRouteTransformerConvention only transforms the automatically generated segments of a page route that come from the Razor Pages folder and file name. Elle ne transforme pas les segments de @page routage ajoutés avec la directive.It doesn't transform route segments added with the @page directive. La Convention ne transforme pas non plus AddPageRouteles itinéraires ajoutés par.The convention also doesn't transform routes added by AddPageRoute.

Le PageRouteTransformerConvention est inscrit en tant qu’option Startup.ConfigureServicesdans:The PageRouteTransformerConvention is registered as an option in Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc()
        .AddRazorPagesOptions(options =>
            {
                options.Conventions.Add(
                    new PageRouteTransformerConvention(
                        new SlugifyParameterTransformer()));
            });
}

public class SlugifyParameterTransformer : IOutboundParameterTransformer
{
    public string TransformOutbound(object value)
    {
        if (value == null) { return null; }

        // Slugify value
        return Regex.Replace(value.ToString(), "([a-z])([A-Z])", "$1-$2").ToLower();
    }
}

Configurer un routage de pageConfigure a page route

Utilisez AddPageRoute pour configurer un itinéraire vers une page au niveau du chemin de page spécifié.Use AddPageRoute to configure a route to a page at the specified page path. Les liens générés qui pointent vers la page utilisent le routage que vous avez spécifié.Generated links to the page use your specified route. AddPageRoute utilise AddPageRouteModelConvention pour établir le routage.AddPageRoute uses AddPageRouteModelConvention to establish the route.

L’exemple d’application crée un routage vers /TheContactPage pour Contact.cshtml :The sample app creates a route to /TheContactPage for Contact.cshtml:

options.Conventions.AddPageRoute("/Contact", "TheContactPage/{text?}");
options.Conventions.AddPageRoute("/Contact", "TheContactPage/{text?}");

La page Contact est également accessible sur /Contact via son routage par défaut.The Contact page can also be reached at /Contact via its default route.

Le routage personnalisé de l’exemple d’application vers la page Contact permet un segment de routage text facultatif ({text?}).The sample app's custom route to the Contact page allows for an optional text route segment ({text?}). Cette page inclut également ce segment facultatif dans sa directive @page, au cas où le visiteur accèderait à la page via le routage /Contact :The page also includes this optional segment in its @page directive in case the visitor accesses the page at its /Contact route:

@page "{text?}"
@model ContactModel
@{
    ViewData["Title"] = "Contact";
}

<h1>@ViewData["Title"]</h1>
<h2>@Model.Message</h2>

<address>
    One Microsoft Way<br>
    Redmond, WA 98052-6399<br>
    <abbr title="Phone">P:</abbr>
    425.555.0100
</address>

<address>
    <strong>Support:</strong> <a href="mailto:Support@example.com">Support@example.com</a><br>
    <strong>Marketing:</strong> <a href="mailto:Marketing@example.com">Marketing@example.com</a>
</address>

<p>@Model.RouteDataTextTemplateValue</p>
@page "{text?}"
@model ContactModel
@{
    ViewData["Title"] = "Contact";
}

<h1>@ViewData["Title"]</h1>
<h2>@Model.Message</h2>

<address>
    One Microsoft Way<br>
    Redmond, WA 98052-6399<br>
    <abbr title="Phone">P:</abbr>
    425.555.0100
</address>

<address>
    <strong>Support:</strong> <a href="mailto:Support@example.com">Support@example.com</a><br>
    <strong>Marketing:</strong> <a href="mailto:Marketing@example.com">Marketing@example.com</a>
</address>

<p>@Model.RouteDataTextTemplateValue</p>

Notez que l’URL générée pour le lien Contact dans la page affichée reflète le routage mis à jour :Note that the URL generated for the Contact link in the rendered page reflects the updated route:

Lien Contact de l’exemple d’application dans la barre de navigation

Le lien Contact dans la page HTML affichée indique que l’attribut href a la valeur ’/TheContactPage’

Visitez la page Contact via son routage ordinaire, /Contact, ou via le routage personnalisé, /TheContactPage.Visit the Contact page at either its ordinary route, /Contact, or the custom route, /TheContactPage. Si vous indiquez un segment de routage text supplémentaire, la page affiche le segment HTML que vous fournissez :If you supply an additional text route segment, the page shows the HTML-encoded segment that you provide:

Exemple dans le navigateur Edge d’un segment de routage ‘text’ facultatif fourni pour ‘TextValue’ dans l’URL.

Conventions d’actions de modèle de pagePage model action conventions

Le fournisseur de modèles de page par défaut IPageApplicationModelProvider qui implémente appelle des conventions conçues pour fournir des points d’extensibilité pour la configuration des modèles de page.The default page model provider that implements IPageApplicationModelProvider invokes conventions which are designed to provide extensibility points for configuring page models. Ces conventions sont utiles durant la génération et la modification de scénarios de découverte et de traitement de pages.These conventions are useful when building and modifying page discovery and processing scenarios.

Pour les exemples de cette section, l’exemple d’application utilise AddHeaderAttribute une classe, qui est ResultFilterAttributeun, qui applique un en-tête de réponse:For the examples in this section, the sample app uses an AddHeaderAttribute class, which is a ResultFilterAttribute, that applies a response header:

public class AddHeaderAttribute : ResultFilterAttribute
{
    private readonly string _name;
    private readonly string[] _values;

    public AddHeaderAttribute(string name, string[] values)
    {
        _name = name;
        _values = values;
    }

    public override void OnResultExecuting(ResultExecutingContext context)
    {
        context.HttpContext.Response.Headers.Add(_name, _values);
        base.OnResultExecuting(context);
    }
}
public class AddHeaderAttribute : ResultFilterAttribute
{
    private readonly string _name;
    private readonly string[] _values;

    public AddHeaderAttribute(string name, string[] values)
    {
        _name = name;
        _values = values;
    }

    public override void OnResultExecuting(ResultExecutingContext context)
    {
        context.HttpContext.Response.Headers.Add(_name, _values);
        base.OnResultExecuting(context);
    }
}

À l’aide de conventions, l’exemple montre comment appliquer l’attribut à toutes les pages d’un dossier et à une seule page.Using conventions, the sample demonstrates how to apply the attribute to all of the pages in a folder and to a single page.

Convention de modèle d’application de dossierFolder app model convention

Utilisez AddFolderApplicationModelConvention pour créer et ajouter un IPageApplicationModelConvention objet qui appelle une action sur PageApplicationModel les instances de toutes les pages situées dans le dossier spécifié.Use AddFolderApplicationModelConvention to create and add an IPageApplicationModelConvention that invokes an action on PageApplicationModel instances for all pages under the specified folder.

L’exemple illustre l’utilisation de AddFolderApplicationModelConvention en ajoutant un en-tête, OtherPagesHeader, aux pages situées dans le dossier OtherPages de l’application :The sample demonstrates the use of AddFolderApplicationModelConvention by adding a header, OtherPagesHeader, to the pages inside the OtherPages folder of the app:

options.Conventions.AddFolderApplicationModelConvention("/OtherPages", model =>
{
    model.Filters.Add(new AddHeaderAttribute(
        "OtherPagesHeader", new string[] { "OtherPages Header Value" }));
});
options.Conventions.AddFolderApplicationModelConvention("/OtherPages", model =>
{
    model.Filters.Add(new AddHeaderAttribute(
        "OtherPagesHeader", new string[] { "OtherPages Header Value" }));
});

Demandez la page Page1 de l’exemple sur localhost:5000/OtherPages/Page1 et examinez les en-têtes pour voir le résultat :Request the sample's Page1 page at localhost:5000/OtherPages/Page1 and inspect the headers to view the result:

Les en-têtes de réponse de la page OtherPages/Page1 montrent que OtherPagesHeader a été ajouté.

Convention de modèle d’application de pagePage app model convention

Utilisez AddPageApplicationModelConvention pour créer et ajouter un IPageApplicationModelConvention objet qui appelle une action sur le PageApplicationModel pour la page avec le nom spécifié.Use AddPageApplicationModelConvention to create and add an IPageApplicationModelConvention that invokes an action on the PageApplicationModel for the page with the specified name.

L’exemple illustre l’utilisation de AddPageApplicationModelConvention en ajoutant un en-tête, AboutHeader, à la page About :The sample demonstrates the use of AddPageApplicationModelConvention by adding a header, AboutHeader, to the About page:

options.Conventions.AddPageApplicationModelConvention("/About", model =>
{
    model.Filters.Add(new AddHeaderAttribute(
        "AboutHeader", new string[] { "About Header Value" }));
});
options.Conventions.AddPageApplicationModelConvention("/About", model =>
{
    model.Filters.Add(new AddHeaderAttribute(
        "AboutHeader", new string[] { "About Header Value" }));
});

Demandez la page About de l’exemple sur localhost:5000/About et examinez les en-têtes pour voir le résultat :Request the sample's About page at localhost:5000/About and inspect the headers to view the result:

Les en-têtes de réponse de la page About montrent que AboutHeader a été ajouté.

Configurer un filtreConfigure a filter

ConfigureFilterconfigure le filtre spécifié à appliquer.ConfigureFilter configures the specified filter to apply. Vous pouvez implémenter une classe de filtre. Toutefois, l’exemple d’application montre comment implémenter un filtre dans une expression lambda, laquelle est implémentée en arrière-plan en tant que fabrique qui retourne un filtre :You can implement a filter class, but the sample app shows how to implement a filter in a lambda expression, which is implemented behind-the-scenes as a factory that returns a filter:

options.Conventions.ConfigureFilter(model =>
{
    if (model.RelativePath.Contains("OtherPages/Page2"))
    {
        return new AddHeaderAttribute(
            "OtherPagesPage2Header", 
            new string[] { "OtherPages/Page2 Header Value" });
    }
    return new EmptyFilter();
});
options.Conventions.ConfigureFilter(model =>
{
    if (model.RelativePath.Contains("OtherPages/Page2"))
    {
        return new AddHeaderAttribute(
            "OtherPagesPage2Header", 
            new string[] { "OtherPages/Page2 Header Value" });
    }
    return new EmptyFilter();
});

Le modèle d’application de page est utilisé pour vérifier le chemin relatif des segments qui mènent à la page Page2 dans le dossier OtherPages.The page app model is used to check the relative path for segments that lead to the Page2 page in the OtherPages folder. Si la condition est satisfaite, un en-tête est ajouté.If the condition passes, a header is added. Sinon, EmptyFilter est appliqué.If not, the EmptyFilter is applied.

EmptyFilter est un filtre d’action.EmptyFilter is an Action filter. Étant donné que les filtres d’action sont ignorés par Razor pages, le EmptyFilter n’a aucun effet comme prévu si le chemin d’accès ne contient OtherPages/Page2pas.Since Action filters are ignored by Razor Pages, the EmptyFilter has no effect as intended if the path doesn't contain OtherPages/Page2.

Demandez la page Page2 de l’exemple sur localhost:5000/OtherPages/Page2 et examinez les en-têtes pour voir le résultat :Request the sample's Page2 page at localhost:5000/OtherPages/Page2 and inspect the headers to view the result:

OtherPagesPage2Header est ajouté à la réponse pour Page2.

Configurer une fabrique de filtresConfigure a filter factory

ConfigureFilterconfigure la fabrique spécifiée pour appliquer des filtres à toutes les Razor pages.ConfigureFilter configures the specified factory to apply filters to all Razor Pages.

L’exemple d’application illustre l’utilisation d’une fabrique de filtres en ajoutant un en-tête, FilterFactoryHeader, et deux valeurs aux pages de l’application :The sample app provides an example of using a filter factory by adding a header, FilterFactoryHeader, with two values to the app's pages:

options.Conventions.ConfigureFilter(new AddHeaderWithFactory());
options.Conventions.ConfigureFilter(new AddHeaderWithFactory());

AddHeaderWithFactory.cs :AddHeaderWithFactory.cs:

public class AddHeaderWithFactory : IFilterFactory
{
    // Implement IFilterFactory
    public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
    {
        return new AddHeaderFilter();
    }

    private class AddHeaderFilter : IResultFilter
    {
        public void OnResultExecuting(ResultExecutingContext context)
        {
            context.HttpContext.Response.Headers.Add(
                "FilterFactoryHeader", 
                new string[] 
                { 
                    "Filter Factory Header Value 1",
                    "Filter Factory Header Value 2"
                });
        }

        public void OnResultExecuted(ResultExecutedContext context)
        {
        }
    }

    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}
public class AddHeaderWithFactory : IFilterFactory
{
    // Implement IFilterFactory
    public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
    {
        return new AddHeaderFilter();
    }

    private class AddHeaderFilter : IResultFilter
    {
        public void OnResultExecuting(ResultExecutingContext context)
        {
            context.HttpContext.Response.Headers.Add(
                "FilterFactoryHeader", 
                new string[] 
                { 
                    "Filter Factory Header Value 1",
                    "Filter Factory Header Value 2"
                });
        }

        public void OnResultExecuted(ResultExecutedContext context)
        {
        }
    }

    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}

Demandez la page About de l’exemple sur localhost:5000/About et examinez les en-têtes pour voir le résultat :Request the sample's About page at localhost:5000/About and inspect the headers to view the result:

Les en-têtes de réponse de la page About montrent que deux en-têtes FilterFactoryHeader ont été ajoutés.

Filtres MVC et filtre de page (IPageFilter)MVC Filters and the Page filter (IPageFilter)

Les filtres d’action MVC sont ignorés par les pages Razor, car les pages Razor utilisent des méthodes de gestionnaire.MVC Action filters are ignored by Razor Pages, since Razor Pages use handler methods. Vous pouvez utiliser d’autres types de filtres MVC: Autorisation, exception, ressourceet résultat.Other types of MVC filters are available for you to use: Authorization, Exception, Resource, and Result. Pour plus d’informations, consultez la rubrique Filtres.For more information, see the Filters topic.

Le filtre de pageIPageFilter() est un filtre qui s’applique à Razor pages.The Page filter (IPageFilter) is a filter that applies to Razor Pages. Pour plus d’informations, consultez Méthodes de filtre pour les pages Razor.For more information, see Filter methods for Razor Pages.

Ressources supplémentairesAdditional resources