Informations de référence sur la syntaxe Razor pour ASP.NET CoreRazor syntax reference for ASP.NET Core

Par Rick Anderson, Luke Latham, Taylor Mullen et Dan VicarelBy Rick Anderson, Luke Latham, Taylor Mullen, and Dan Vicarel

Razor est une syntaxe de balisage qui permet d’incorporer du code serveur dans des pages web.Razor is a markup syntax for embedding server-based code into webpages. La syntaxe Razor est constituée de balises Razor, ainsi que de code C# et HTML.The Razor syntax consists of Razor markup, C#, and HTML. Les fichiers contenant de la syntaxe Razor ont généralement l’extension de fichier .cshtml.Files containing Razor generally have a .cshtml file extension.

Rendu HTMLRendering HTML

Razor utilise par défaut le langage HTML.The default Razor language is HTML. Le rendu HTML d’un balisage Razor n’est pas différent du rendu HTML d’un fichier en HTML.Rendering HTML from Razor markup is no different than rendering HTML from an HTML file. Le balisage HTML dans les fichiers Razor .cshtml est affiché tel quel par le serveur.HTML markup in .cshtml Razor files is rendered by the server unchanged.

Syntaxe RazorRazor syntax

Razor prend en charge le langage C# et utilise le symbole @ pour convertir du code HTML en C#.Razor supports C# and uses the @ symbol to transition from HTML to C#. Razor évalue les expressions C# et les affiche dans la sortie HTML.Razor evaluates C# expressions and renders them in the HTML output.

Quand un symbole @ est suivi d’un mot clé réservé Razor, il est converti en balise Razor.When an @ symbol is followed by a Razor reserved keyword, it transitions into Razor-specific markup. Sinon, il est converti en code C# brut.Otherwise, it transitions into plain C#.

Pour mettre un symbole @ en échappement dans le balisage Razor, ajoutez un deuxième symbole @ :To escape an @ symbol in Razor markup, use a second @ symbol:

<p>@@Username</p>

Le code est affiché en HTML avec un seul symbole @ :The code is rendered in HTML with a single @ symbol:

<p>@Username</p>

Les attributs et le code HTML contenant des adresses e-mail ne traitent pas le symbole @ comme un caractère de conversion.HTML attributes and content containing email addresses don't treat the @ symbol as a transition character. Dans l’exemple suivant, les adresses e-mail ne sont pas modifiées par l’analyse Razor :The email addresses in the following example are untouched by Razor parsing:

<a href="mailto:Support@contoso.com">Support@contoso.com</a>

Expressions Razor implicitesImplicit Razor expressions

Les expressions Razor implicites commencent par @ suivi de code C# :Implicit Razor expressions start with @ followed by C# code:

<p>@DateTime.Now</p>
<p>@DateTime.IsLeapYear(2016)</p>

À l’exception du mot clé await C#, les expressions implicites ne doivent pas contenir d’espaces.With the exception of the C# await keyword, implicit expressions must not contain spaces. Si l’instruction C# se termine de façon non ambigüe, il est possible d’insérer des espaces n’importe où dans la chaîne :If the C# statement has a clear ending, spaces can be intermingled:

<p>@await DoSomething("hello", "world")</p>

Les expressions implicites ne doivent pas contenir de caractères génériques C#, car les caractères entre crochets (<>) sont interprétés comme une balise HTML.Implicit expressions cannot contain C# generics, as the characters inside the brackets (<>) are interpreted as an HTML tag. Le code suivant n’est pas valide :The following code is not valid:

<p>@GenericMethod<int>()</p>

Le code précédent génère l’un des types d’erreur de compilateur suivants :The preceding code generates a compiler error similar to one of the following:

  • L’élément « int » n’a pas été fermé.The "int" element wasn't closed. Tous les éléments doivent se fermer automatiquement ou contenir une balise de fin correspondante.All elements must be either self-closing or have a matching end tag.
  • Impossible de convertir le groupe de méthodes 'GenericMethod' en type non-délégué 'object'.Cannot convert method group 'GenericMethod' to non-delegate type 'object'. Souhaitiez-vous appeler la méthode ?Did you intend to invoke the method?`

Les appels de méthode générique doivent être inclus dans un wrapper dans une expression Razor explicite ou dans un bloc de code Razor.Generic method calls must be wrapped in an explicit Razor expression or a Razor code block.

Expressions Razor explicitesExplicit Razor expressions

Les expressions Razor explicites se composent d’un symbole @ suivi d’un contenu entre parenthèses.Explicit Razor expressions consist of an @ symbol with balanced parenthesis. Pour afficher l’heure de la semaine précédente, utilisez le balisage Razor suivant :To render last week's time, the following Razor markup is used:

<p>Last week this time: @(DateTime.Now - TimeSpan.FromDays(7))</p>

Le contenu situé entre les parenthèses @() est évalué et affiché dans la sortie.Any content within the @() parenthesis is evaluated and rendered to the output.

Les expressions implicites, décrites dans la section précédente, ne doivent généralement pas contenir d’espaces.Implicit expressions, described in the previous section, generally can't contain spaces. Dans le code suivant, une semaine n’est pas déduite de l’heure actuelle :In the following code, one week isn't subtracted from the current time:

<p>Last week: @DateTime.Now - TimeSpan.FromDays(7)</p>

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

<p>Last week: 7/7/2016 4:39:52 PM - TimeSpan.FromDays(7)</p>

Les expressions explicites peuvent servir à concaténer du texte avec un résultat d’expression :Explicit expressions can be used to concatenate text with an expression result:

@{
    var joe = new Person("Joe", 33);
}

<p>Age@(joe.Age)</p>

Sans l’expression explicite, <p>Age@joe.Age</p> est traité comme une adresse e-mail, et <p>Age@joe.Age</p> est affiché.Without the explicit expression, <p>Age@joe.Age</p> is treated as an email address, and <p>Age@joe.Age</p> is rendered. Avec une expression explicite, <p>Age33</p> est affiché.When written as an explicit expression, <p>Age33</p> is rendered.

Les expressions explicites peuvent être utilisées pour afficher la sortie de méthodes génériques dans les fichiers .cshtml.Explicit expressions can be used to render output from generic methods in .cshtml files. Le balisage suivant montre comment corriger l’erreur affichée précédemment provoquée par les crochets d’un générique C#.The following markup shows how to correct the error shown earlier caused by the brackets of a C# generic. Le code est écrit sous forme d’expression explicite :The code is written as an explicit expression:

<p>@(GenericMethod<int>())</p>

Encodage des expressionsExpression encoding

Les expressions C# évaluées qui correspondent à une chaîne sont encodées en HTML.C# expressions that evaluate to a string are HTML encoded. Les expressions C# évaluées qui correspondent à IHtmlContent sont affichées directement par IHtmlContent.WriteTo.C# expressions that evaluate to IHtmlContent are rendered directly through IHtmlContent.WriteTo. Les expressions C# évaluées qui ne correspondent pas à IHtmlContent sont converties en chaîne par ToString et sont encodées avant d’être affichées.C# expressions that don't evaluate to IHtmlContent are converted to a string by ToString and encoded before they're rendered.

@("<span>Hello World</span>")

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

&lt;span&gt;Hello World&lt;/span&gt;

Le code HTML s’affiche dans le navigateur de cette façon :The HTML is shown in the browser as:

<span>Hello World</span>

La sortie HtmlHelper.Raw n’est pas encodée, mais elle est affichée sous forme de balisage HTML.HtmlHelper.Raw output isn't encoded but rendered as HTML markup.

Avertissement

Utiliser HtmlHelper.Raw sur des entrées utilisateur non nettoyées présente un risque pour la sécurité.Using HtmlHelper.Raw on unsanitized user input is a security risk. Les entrées utilisateur peuvent contenir du code malveillant JavaScript ou d’un autre type.User input might contain malicious JavaScript or other exploits. Le nettoyage des entrées utilisateur est difficile.Sanitizing user input is difficult. C’est pourquoi il est préférable de ne pas utiliser HtmlHelper.Raw sur des entrées utilisateur.Avoid using HtmlHelper.Raw with user input.

@Html.Raw("<span>Hello World</span>")

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

<span>Hello World</span>

Blocs de code RazorRazor code blocks

Les blocs de code Razor commencent par @ et sont délimités par deux {}.Razor code blocks start with @ and are enclosed by {}. Contrairement aux expressions, le code C# figurant dans des blocs de code n’est pas affiché.Unlike expressions, C# code inside code blocks isn't rendered. Les blocs de code et les expressions dans une vue ont la même étendue et sont définis dans l’ordre :Code blocks and expressions in a view share the same scope and are defined in order:

@{
    var quote = "The future depends on what you do today. - Mahatma Gandhi";
}

<p>@quote</p>

@{
    quote = "Hate cannot drive out hate, only love can do that. - Martin Luther King, Jr.";
}

<p>@quote</p>

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

<p>The future depends on what you do today. - Mahatma Gandhi</p>
<p>Hate cannot drive out hate, only love can do that. - Martin Luther King, Jr.</p>

Transitions implicitesImplicit transitions

Un bloc de code utilise le langage C# par défaut, mais la page Razor peut le reconvertir en HTML :The default language in a code block is C#, but the Razor Page can transition back to HTML:

@{
    var inCSharp = true;
    <p>Now in HTML, was in C# @inCSharp</p>
}

Conversion délimitée expliciteExplicit delimited transition

Pour définir une sous-section d’un bloc de code qui doit s’afficher en HTML, placez les caractères à afficher dans la balise <text> Razor suivante :To define a subsection of a code block that should render HTML, surround the characters for rendering with the Razor <text> tag:

@for (var i = 0; i < people.Length; i++)
{
    var person = people[i];
    <text>Name: @person.Name</text>
}

Utilisez cette approche pour afficher du code HTML qui n’est pas entouré d’une balise HTML.Use this approach to render HTML that isn't surrounded by an HTML tag. Sans la balise HTML ou Razor, une erreur d’exécution Razor se produit.Without an HTML or Razor tag, a Razor runtime error occurs.

La balise <text> est utile pour contrôler les espaces blancs dans le contenu affiché :The <text> tag is useful to control whitespace when rendering content:

  • Seul le contenu situé dans la balise <text> est affiché.Only the content between the <text> tag is rendered.
  • Aucun espace blanc avant ou après la balise <text> ne s’affiche dans la sortie HTML.No whitespace before or after the <text> tag appears in the HTML output.

Conversion de ligne explicite avec @ :Explicit Line Transition with @:

Pour afficher le reste d’une ligne entière en HTML à l’intérieur d’un bloc de code, utilisez la syntaxe @: :To render the rest of an entire line as HTML inside a code block, use the @: syntax:

@for (var i = 0; i < people.Length; i++)
{
    var person = people[i];
    @:Name: @person.Name
}

Sans la balise @: dans le code, une erreur d’exécution Razor se produit.Without the @: in the code, a Razor runtime error is generated.

Avertissement : La présence de caractères @ en trop dans un fichier Razor risque de provoquer des erreurs du compilateur au niveau des instructions suivantes dans le bloc.Warning: Extra @ characters in a Razor file can cause compiler errors at statements later in the block. Ces erreurs du compilateur peuvent être difficiles à comprendre, car elles se produisent en réalité avant les erreurs signalées.These compiler errors can be difficult to understand because the actual error occurs before the reported error. Ce type d’erreur est courant après la combinaison de plusieurs expressions implicites ou explicites dans un même bloc de code.This error is common after combining multiple implicit/explicit expressions into a single code block.

Structures de contrôleControl structures

Les structures de contrôle sont une extension des blocs de code.Control structures are an extension of code blocks. Toutes les caractéristiques des blocs de code (conversion de balisage, Inline C#) valent aussi pour les structures suivantes :All aspects of code blocks (transitioning to markup, inline C#) also apply to the following structures:

Conditions @if, else if, else et @switchConditionals @if, else if, else, and @switch

@if contrôle l’exécution du code :@if controls when code runs:

@if (value % 2 == 0)
{
    <p>The value was even.</p>
}

else et else if ne nécessitent pas le symbole @ :else and else if don't require the @ symbol:

@if (value % 2 == 0)
{
    <p>The value was even.</p>
}
else if (value >= 1337)
{
    <p>The value is large.</p>
}
else
{
    <p>The value is odd and small.</p>
}

Le balisage suivant montre comment utiliser une instruction switch :The following markup shows how to use a switch statement:

@switch (value)
{
    case 1:
        <p>The value is 1!</p>
        break;
    case 1337:
        <p>Your number is 1337!</p>
        break;
    default:
        <p>Your number wasn't 1 or 1337.</p>
        break;
}

Boucles @for, @foreach, @while et @do whileLooping @for, @foreach, @while, and @do while

Le rendu HTML peut être réalisé à partir d'instructions de contrôle de boucle.Templated HTML can be rendered with looping control statements. Pour afficher une liste de personnes :To render a list of people:

@{
    var people = new Person[]
    {
          new Person("Weston", 33),
          new Person("Johnathon", 41),
          ...
    };
}

Les instructions de boucle suivantes sont prises en charge :The following looping statements are supported:

@for

@for (var i = 0; i < people.Length; i++)
{
    var person = people[i];
    <p>Name: @person.Name</p>
    <p>Age: @person.Age</p>
}

@foreach

@foreach (var person in people)
{
    <p>Name: @person.Name</p>
    <p>Age: @person.Age</p>
}

@while

@{ var i = 0; }
@while (i < people.Length)
{
    var person = people[i];
    <p>Name: @person.Name</p>
    <p>Age: @person.Age</p>

    i++;
}

@do while

@{ var i = 0; }
@do
{
    var person = people[i];
    <p>Name: @person.Name</p>
    <p>Age: @person.Age</p>

    i++;
} while (i < people.Length);

Instruction composée @usingCompound @using

En C#, une instruction using est utilisée pour garantir la dispose d’un objet.In C#, a using statement is used to ensure an object is disposed. Dans Razor, le même mécanisme permet de créer des HTML Helpers avec du contenu supplémentaire.In Razor, the same mechanism is used to create HTML Helpers that contain additional content. Dans le code suivant, les HTML Helpers affichent une balise Form à l’aide de l’instruction @using :In the following code, HTML Helpers render a form tag with the @using statement:

@using (Html.BeginForm())
{
    <div>
        email:
        <input type="email" id="Email" value="">
        <button>Register</button>
    </div>
}

Des actions au niveau de l’étendue peuvent être effectuées avec des Tag Helpers.Scope-level actions can be performed with Tag Helpers.

@try, catch, finally@try, catch, finally

La gestion des exceptions est similaire à C# :Exception handling is similar to C#:

@try
{
    throw new InvalidOperationException("You did something invalid.");
}
catch (Exception ex)
{
    <p>The exception message: @ex.Message</p>
}
finally
{
    <p>The finally statement.</p>
}

@lock

Razor permet de verrouiller les sections critiques par des instructions lock :Razor has the capability to protect critical sections with lock statements:

@lock (SomeLock)
{
    // Do critical section work
}

CommentairesComments

Razor prend en charge les commentaires HTML et C# :Razor supports C# and HTML comments:

@{
    /* C# comment */
    // Another C# comment
}
<!-- HTML comment -->

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

<!-- HTML comment -->

Le serveur supprime les commentaires Razor avant d’afficher la page web.Razor comments are removed by the server before the webpage is rendered. Razor délimite les commentaires avec @* *@.Razor uses @* *@ to delimit comments. Le code suivant est commenté pour indiquer au serveur de ne pas afficher le balisage :The following code is commented out, so the server doesn't render any markup:

@*
    @{
        /* C# comment */
        // Another C# comment
    }
    <!-- HTML comment -->
*@

DirectivesDirectives

Les directives Razor sont représentées par des expressions implicites constituées du symbole @ suivi de mots clés réservés.Razor directives are represented by implicit expressions with reserved keywords following the @ symbol. En règle générale, une directive change la manière dont une vue est analysée ou active une fonctionnalité différente.A directive typically changes the way a view is parsed or enables different functionality.

Pour mieux comprendre le fonctionnement des directives, vous devez bien comprendre comment Razor génère le code pour une vue.Understanding how Razor generates code for a view makes it easier to understand how directives work.

@{
    var quote = "Getting old ain't for wimps! - Anonymous";
}

<div>Quote of the Day: @quote</div>

Le code génère une classe semblable à celle-ci :The code generates a class similar to the following:

public class _Views_Something_cshtml : RazorPage<dynamic>
{
    public override async Task ExecuteAsync()
    {
        var output = "Getting old ain't for wimps! - Anonymous";

        WriteLiteral("/r/n<div>Quote of the Day: ");
        Write(output);
        WriteLiteral("</div>");
    }
}

Plus loin dans cet article, la section Inspecter la classe C# Razor générée pour une vue explique comment afficher cette classe générée.Later in this article, the section Inspect the Razor C# class generated for a view explains how to view this generated class.

@using

La directive @using ajoute la directive using C# à la vue générée :The @using directive adds the C# using directive to the generated view:

@using System.IO
@{
    var dir = Directory.GetCurrentDirectory();
}
<p>@dir</p>

@model

La directive @model spécifie le type du modèle passé à une vue :The @model directive specifies the type of the model passed to a view:

@model TypeNameOfModel

Dans une application ASP.NET Core MVC créée avec des comptes d’utilisateur individuels, la vue Views/Account/Login.cshtml contient la déclaration de modèle suivante :In an ASP.NET Core MVC app created with individual user accounts, the Views/Account/Login.cshtml view contains the following model declaration:

@model LoginViewModel

La classe générée hérite de RazorPage<dynamic> :The class generated inherits from RazorPage<dynamic>:

public class _Views_Account_Login_cshtml : RazorPage<LoginViewModel>

Razor expose une propriété Model pour accéder au modèle passé à la vue :Razor exposes a Model property for accessing the model passed to the view:

<div>The Login Email: @Model.Email</div>

La directive @model spécifie le type de cette propriété.The @model directive specifies the type of this property. La directive spécifie le type T dans RazorPage<T> pour la classe générée dont dérive la vue.The directive specifies the T in RazorPage<T> that the generated class that the view derives from. Si la directive @model n’est pas spécifiée, la propriété Model est de type dynamic.If the @model directive isn't specified, the Model property is of type dynamic. La valeur du modèle est passée à la vue par le contrôleur.The value of the model is passed from the controller to the view. Pour plus d’informations, consultez Modèles fortement typés et le mot clé @model.For more information, see Strongly typed models and the @model keyword.

@inherits

La directive @inherits fournit un contrôle complet de la classe héritée par la vue :The @inherits directive provides full control of the class the view inherits:

@inherits TypeNameOfClassToInheritFrom

Le code suivant est un type de page Razor personnalisé :The following code is a custom Razor page type:

using Microsoft.AspNetCore.Mvc.Razor;

public abstract class CustomRazorPage<TModel> : RazorPage<TModel>
{
    public string CustomText { get; } = "Gardyloo! - A Scottish warning yelled from a window before dumping a slop bucket on the street below.";
}

Le CustomText s’affiche dans une vue :The CustomText is displayed in a view:

@inherits CustomRazorPage<TModel>

<div>Custom text: @CustomText</div>

Le code s’affiche en HTML de la façon suivante :The code renders the following HTML:

<div>Custom text: Gardyloo! - A Scottish warning yelled from a window before dumping a slop bucket on the street below.</div>

@model et @inherits peuvent s’utiliser dans la même vue.@model and @inherits can be used in the same view. @inherits peut être dans un fichier _ViewImports.cshtml importé par la vue :@inherits can be in a _ViewImports.cshtml file that the view imports:

@inherits CustomRazorPage<TModel>

Le code suivant est un exemple de vue fortement typée :The following code is an example of a strongly-typed view:

@inherits CustomRazorPage<TModel>

<div>The Login Email: @Model.Email</div>
<div>Custom text: @CustomText</div>

Si « rick@contoso.com » est passé au modèle, la vue génère le balisage HTML suivant :If "rick@contoso.com" is passed in the model, the view generates the following HTML markup:

<div>The Login Email: rick@contoso.com</div>
<div>Custom text: Gardyloo! - A Scottish warning yelled from a window before dumping a slop bucket on the street below.</div>

@inject

La directive @inject permet à la page Razor d’injecter un service dans une vue à partir du conteneur de services.The @inject directive enables the Razor Page to inject a service from the service container into a view. Pour plus d’informations, consultez Injection de dépendances dans les vues.For more information, see Dependency injection into views.

@functions

La directive @functions permet à une page Razor d’ajouter un bloc de code C# à une vue :The @functions directive enables a Razor Page to add a C# code block to a view:

@functions { // C# Code }

Exemple :For example:

@functions {
    public string GetHello()
    {
        return "Hello";
    }
}

<div>From method: @GetHello()</div> 

Le code génère le balisage HTML suivant :The code generates the following HTML markup:

<div>From method: Hello</div>

Le code suivant correspond à la classe C# Razor générée :The following code is the generated Razor C# class:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Razor;

public class _Views_Home_Test_cshtml : RazorPage<dynamic>
{
    // Functions placed between here 
    public string GetHello()
    {
        return "Hello";
    }
    // And here.
#pragma warning disable 1998
    public override async Task ExecuteAsync()
    {
        WriteLiteral("\r\n<div>From method: ");
        Write(GetHello());
        WriteLiteral("</div>\r\n");
    }
#pragma warning restore 1998

@section

La directive @section est utilisée conjointement avec une disposition pour permettre aux vues d’afficher le contenu dans différentes parties de la page HTML.The @section directive is used in conjunction with the layout to enable views to render content in different parts of the HTML page. Pour plus d’informations, consultez Sections.For more information, see Sections.

Tag HelpersTag Helpers

Il existe trois directives spécifiques aux Tag Helpers.There are three directives that pertain to Tag Helpers.

DirectiveDirective FonctionFunction
@addTagHelper@addTagHelper Rend les Tag Helpers disponibles dans une vue.Makes Tag Helpers available to a view.
@removeTagHelper@removeTagHelper Supprime les Tag Helpers précédemment ajoutés à une vue.Removes Tag Helpers previously added from a view.
@tagHelperPrefix@tagHelperPrefix Spécifie un préfixe de balise pour activer la prise en charge des Tag Helpers et rendre leur usage explicite.Specifies a tag prefix to enable Tag Helper support and to make Tag Helper usage explicit.

Mots clés réservés RazorRazor reserved keywords

Mots clés RazorRazor keywords

  • page (nécessite ASP.NET Core 2.0 ou version ultérieure)page (Requires ASP.NET Core 2.0 and later)
  • namespacenamespace
  • fonctionsfunctions
  • hériteinherits
  • modèlemodel
  • sectionsection
  • helper (non pris en charge par ASP.NET Core)helper (Not currently supported by ASP.NET Core)

Les mots clés Razor sont précédés d’une séquence d’échappement @(Razor Keyword) (par exemple, @(functions)).Razor keywords are escaped with @(Razor Keyword) (for example, @(functions)).

Mots clés Razor C#C# Razor keywords

  • cassecase
  • dodo
  • defaultdefault
  • forfor
  • foreachforeach
  • ifif
  • elseelse
  • locklock
  • switchswitch
  • trytry
  • catchcatch
  • finallyfinally
  • usingusing
  • whilewhile

Les mots clés Razor C# doivent être précédés d’une double séquence d’échappement @(@C# Razor Keyword) (par exemple, @(@case)).C# Razor keywords must be double-escaped with @(@C# Razor Keyword) (for example, @(@case)). La première séquence d’échappement @ est pour l’analyseur Razor.The first @ escapes the Razor parser. La seconde séquence d’échappement @ est pour l’analyseur C#.The second @ escapes the C# parser.

Mots clés réservés non utilisés par RazorReserved keywords not used by Razor

  • classclass

Inspecter la classe C# Razor générée pour une vueInspect the Razor C# class generated for a view

Avec le SDK .NET Core 2.1 ou ultérieur, le SDK Razor gère la compilation des fichiers Razor.With .NET Core SDK 2.1 or later, the Razor SDK handles compilation of Razor files. Quand vous créez un projet, le SDK Razor génère un répertoire obj/<configuration_build>/<moniker_framework_cible>/Razor dans la racine du projet.When building a project, the Razor SDK generates an obj/<build_configuration>/<target_framework_moniker>/Razor directory in the project root. La structure de répertoires dans le répertoire Razor reflète la structure de répertoires du projet.The directory structure within the Razor directory mirrors the project's directory structure.

Considérez la structure de répertoires suivante dans un projet Razor Pages ASP.NET Core 2.1 ciblant .NET Core 2.1 :Consider the following directory structure in an ASP.NET Core 2.1 Razor Pages project targeting .NET Core 2.1:

  • Areas/Areas/
    • Admin/Admin/
      • Pages/Pages/
        • Index.cshtmlIndex.cshtml
        • Index.cshtml.csIndex.cshtml.cs
  • Pages/Pages/
    • Shared/Shared/
      • _Layout.cshtml_Layout.cshtml
    • _ViewImports.cshtml_ViewImports.cshtml
    • _ViewStart.cshtml_ViewStart.cshtml
    • Index.cshtmlIndex.cshtml
    • Index.cshtml.csIndex.cshtml.cs

La création du projet dans la configuration Debug génère le répertoire obj suivant :Building the project in Debug configuration yields the following obj directory:

  • obj/obj/
    • Debug/Debug/
      • netcoreapp2.1/netcoreapp2.1/
        • Razor/Razor/
          • Areas/Areas/
            • Admin/Admin/
              • Pages/Pages/
                • Index.g.cshtml.csIndex.g.cshtml.cs
          • Pages/Pages/
            • Shared/Shared/
              • _Layout.g.cshtml.cs_Layout.g.cshtml.cs
            • _ViewImports.g.cshtml.cs_ViewImports.g.cshtml.cs
            • _ViewStart.g.cshtml.cs_ViewStart.g.cshtml.cs
            • Index.g.cshtml.csIndex.g.cshtml.cs

Pour afficher la classe générée pour Pages/Index.cshtml, ouvrez obj/Debug/netcoreapp2.1/Razor/Pages/Index.g.cshtml.cs.To view the generated class for Pages/Index.cshtml, open obj/Debug/netcoreapp2.1/Razor/Pages/Index.g.cshtml.cs.

Ajoutez la classe suivante au projet ASP.NET Core MVC :Add the following class to the ASP.NET Core MVC project:

using Microsoft.AspNetCore.Mvc.Razor.Extensions;
using Microsoft.AspNetCore.Razor.Language;

public class CustomTemplateEngine : MvcRazorTemplateEngine
{
    public CustomTemplateEngine(RazorEngine engine, RazorProject project) 
        : base(engine, project)
    {
    }
        
    public override RazorCSharpDocument GenerateCode(RazorCodeDocument codeDocument)
    {
        var csharpDocument = base.GenerateCode(codeDocument);
        var generatedCode = csharpDocument.GeneratedCode;

        // Look at generatedCode

        return csharpDocument;
    }
}

Dans Startup.ConfigureServices, remplacez la classe RazorTemplateEngine ajoutée par MVC par la classe CustomTemplateEngine :In Startup.ConfigureServices, override the RazorTemplateEngine added by MVC with the CustomTemplateEngine class:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddSingleton<RazorTemplateEngine, CustomTemplateEngine>();
}

Définissez un point d’arrêt sur l’instruction return csharpDocument; de CustomTemplateEngine.Set a breakpoint on the return csharpDocument; statement of CustomTemplateEngine. Quand l’exécution du programme s’arrête au point d’arrêt, affichez la valeur de generatedCode.When program execution stops at the breakpoint, view the value of generatedCode.

Vue Visualiseur de texte du code généré

Recherches de vues et respect de la casseView lookups and case sensitivity

Le moteur de vue Razor effectue des recherches de vues en respectant la casse.The Razor view engine performs case-sensitive lookups for views. Toutefois, la recherche réellement effectuée est déterminée par le système de fichiers sous-jacent :However, the actual lookup is determined by the underlying file system:

  • Source basé sur un fichier :File based source:
    • Sur les systèmes d’exploitation avec des systèmes de fichiers qui ne respectent pas la casse (par exemple, Windows), les recherches de fournisseurs de fichiers physiques ne respectent pas la casse.On operating systems with case insensitive file systems (for example, Windows), physical file provider lookups are case insensitive. Par exemple, return View("Test") trouve les correspondances /Views/Home/Test.cshtml, /Views/home/test.cshtml et toutes les autres variantes de casse.For example, return View("Test") results in matches for /Views/Home/Test.cshtml, /Views/home/test.cshtml, and any other casing variant.
    • Sur des systèmes de fichiers respectant la casse (par exemple, Linux, OSX, et avec EmbeddedFileProvider), les recherches respectent la casse.On case-sensitive file systems (for example, Linux, OSX, and with EmbeddedFileProvider), lookups are case-sensitive. Par exemple, return View("Test") trouve uniquement la correspondance /Views/Home/Test.cshtml.For example, return View("Test") specifically matches /Views/Home/Test.cshtml.
  • Vues précompilées : Avec ASP.NET Core 2.0 et les versions ultérieures, les recherches de vues précompilées ne respectent pas la casse, quels que soient les systèmes d’exploitation.Precompiled views: With ASP.NET Core 2.0 and later, looking up precompiled views is case insensitive on all operating systems. Le comportement est le même que celui du fournisseur de fichiers physiques sur Windows.The behavior is identical to physical file provider's behavior on Windows. Si deux vues précompilées diffèrent seulement par leur casse, le résultat de la recherche est non déterministe.If two precompiled views differ only in case, the result of lookup is non-deterministic.

Les développeurs doivent s’efforcer d’utiliser la même casse pour les noms de fichiers et de répertoires que pour les noms des éléments suivants :Developers are encouraged to match the casing of file and directory names to the casing of:

* <span data-ttu-id="3940d-325">Zone, contrôleur et action</span><span class="sxs-lookup"><span data-stu-id="3940d-325">Area, controller, and action names.</span></span>
* <span data-ttu-id="3940d-326">Pages Razor</span><span class="sxs-lookup"><span data-stu-id="3940d-326">Razor Pages.</span></span>

L’utilisation d’une casse identique garantit que les déploiements trouvent toujours les vues associées, indépendamment du système de fichiers sous-jacent.Matching case ensures the deployments find their views regardless of the underlying file system.