Guida di riferimento della sintassi Razor per ASP.NET CoreRazor syntax reference for ASP.NET Core

Di Rick Anderson, Luke Latham, Taylor Mullen e Dan VicarelBy Rick Anderson, Luke Latham, Taylor Mullen, and Dan Vicarel

Razor è una sintassi di markup per l'incorporamento di codice basato su server in pagine Web.Razor is a markup syntax for embedding server-based code into webpages. La sintassi Razor è costituita da markup Razor, C# e HTML.The Razor syntax consists of Razor markup, C#, and HTML. I file contenenti Razor in genere presentano l'estensione cshtml.Files containing Razor generally have a .cshtml file extension. Razor è presente anche nei file dei componenti di Razor (con estensione razor).Razor is also found in Razor components files (.razor).

Rendering di HTMLRendering HTML

Il linguaggio Razor predefinito è HTML.The default Razor language is HTML. Il rendering HTML dal markup Razor non è diverso dal rendering HTML da un file HTML.Rendering HTML from Razor markup is no different than rendering HTML from an HTML file. Il rendering del markup HTML nei file Razor con estensione cshtml viene eseguito dal server senza modifiche.HTML markup in .cshtml Razor files is rendered by the server unchanged.

Sintassi RazorRazor syntax

Razor supporta C# e usa il simbolo @ per la transizione da HTML a C#.Razor supports C# and uses the @ symbol to transition from HTML to C#. Razor valuta le espressioni C# e ne esegue il rendering nell'output HTML.Razor evaluates C# expressions and renders them in the HTML output.

Quando un simbolo @ è seguito da una parola chiave riservata Razor, la transizione avviene in un markup specifico per Razor,When an @ symbol is followed by a Razor reserved keyword, it transitions into Razor-specific markup. in caso contrario in C# semplice.Otherwise, it transitions into plain C#.

Per usare un simbolo @ come carattere di escape nel markup Razor, usare un secondo simbolo @:To escape an @ symbol in Razor markup, use a second @ symbol:

<p>@@Username</p>

Il rendering del codice viene eseguito in HTML con un solo simbolo @:The code is rendered in HTML with a single @ symbol:

<p>@Username</p>

Gli attributi e il contenuto HTML contenenti indirizzi di posta elettronica non considerano il simbolo @ come un carattere di transizione.HTML attributes and content containing email addresses don't treat the @ symbol as a transition character. Gli indirizzi di posta elettronica nell'esempio seguente non vengono modificati dall'analisi Razor:The email addresses in the following example are untouched by Razor parsing:

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

Espressioni implicite RazorImplicit Razor expressions

Le espressioni implicite Razor iniziano con @ seguito dal codice C#:Implicit Razor expressions start with @ followed by C# code:

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

Fatta eccezione per la parola chiave await di C#, le espressioni implicite non devono contenere spazi.With the exception of the C# await keyword, implicit expressions must not contain spaces. Se l'istruzione C# ha una fine chiaramente definita, possono coesistere spazi:If the C# statement has a clear ending, spaces can be intermingled:

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

Le espressioni implicite non possono contenere generics C#, poiché i caratteri all'interno delle parentesi (<>) vengono interpretati come un tag HTML.Implicit expressions cannot contain C# generics, as the characters inside the brackets (<>) are interpreted as an HTML tag. Il codice seguente non è valido:The following code is not valid:

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

Il codice precedente genera un errore del compilatore simile a uno dei seguenti:The preceding code generates a compiler error similar to one of the following:

  • L'elemento "int" non è stato chiuso.The "int" element wasn't closed. Tutti gli elementi devono essere a chiusura automatica o avere un tag di fine corrispondente.All elements must be either self-closing or have a matching end tag.
  • Non è possibile convertire il gruppo di metodi 'GenericMethod' nel tipo non delegato 'object'.Cannot convert method group 'GenericMethod' to non-delegate type 'object'. Si intendeva chiamare il metodo?'Did you intend to invoke the method?`

Le chiamate di metodo generiche devono essere racchiuse in un'espressione esplicita Razor o in un blocco di codice Razor.Generic method calls must be wrapped in an explicit Razor expression or a Razor code block.

Espressioni esplicite RazorExplicit Razor expressions

Le espressioni esplicite Razor sono costituite da un simbolo @ con parentesi bilanciate.Explicit Razor expressions consist of an @ symbol with balanced parenthesis. Per eseguire il rendering dell'ora dell'ultima settimana, viene usato il markup Razor seguente:To render last week's time, the following Razor markup is used:

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

Qualsiasi contenuto all'interno delle parentesi @() viene valutato e sottoposto a rendering nell'output.Any content within the @() parenthesis is evaluated and rendered to the output.

Le espressioni implicite, descritte nella sezione precedente, in genere non possono contenere spazi.Implicit expressions, described in the previous section, generally can't contain spaces. Nel codice seguente, una settimana non viene sottratta dall'ora corrente:In the following code, one week isn't subtracted from the current time:

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

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

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

È possibile usare le espressioni esplicite per concatenare testo con un risultato dell'espressione:Explicit expressions can be used to concatenate text with an expression result:

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

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

Senza l'espressione esplicita, <p>Age@joe.Age</p> viene considerato come un indirizzo di posta elettronica e <p>Age@joe.Age</p> viene sottoposto a rendering.Without the explicit expression, <p>Age@joe.Age</p> is treated as an email address, and <p>Age@joe.Age</p> is rendered. Se viene scritto come espressione esplicita, <p>Age33</p> viene sottoposto a rendering.When written as an explicit expression, <p>Age33</p> is rendered.

È possibile usare le espressioni esplicite per eseguire il rendering dell'output da metodi generici in file con estensione cshtml.Explicit expressions can be used to render output from generic methods in .cshtml files. Il markup seguente illustra come correggere l'errore riportato in precedenza, causato dalle parentesi quadre di un oggetto generico C#.The following markup shows how to correct the error shown earlier caused by the brackets of a C# generic. Il codice viene scritto come un'espressione esplicita:The code is written as an explicit expression:

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

Codifica di espressioniExpression encoding

Le espressioni C# che restituiscono una stringa sono codificate in HTML.C# expressions that evaluate to a string are HTML encoded. Le espressioni C# che restituiscono IHtmlContent vengono sottoposte a rendering direttamente tramite IHtmlContent.WriteTo.C# expressions that evaluate to IHtmlContent are rendered directly through IHtmlContent.WriteTo. Le espressioni C# che non restituiscono IHtmlContent vengono convertite in una stringa da ToString e codificate prima di essere sottoposte a rendering.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>")

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

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

Il codice HTML viene visualizzato nel browser come:The HTML is shown in the browser as:

<span>Hello World</span>

L'output HtmlHelper.Raw non è codificato ma viene sottoposto a rendering come markup HTML.HtmlHelper.Raw output isn't encoded but rendered as HTML markup.

Avviso

L'uso di HtmlHelper.Raw su input utente non purificato costituisce un rischio per la sicurezza.Using HtmlHelper.Raw on unsanitized user input is a security risk. L'input utente potrebbe contenere JavaScript dannoso o altri attacchi.User input might contain malicious JavaScript or other exploits. La purificazione degli input utente è difficile.Sanitizing user input is difficult. Evitare l'uso di HtmlHelper.Raw con l'input utente.Avoid using HtmlHelper.Raw with user input.

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

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

<span>Hello World</span>

Blocchi di codice RazorRazor code blocks

I blocchi di codice Razor iniziano con @ e sono racchiusi tra {}.Razor code blocks start with @ and are enclosed by {}. A differenza delle espressioni, il codice C# all'interno di blocchi di codice non viene sottoposto a rendering.Unlike expressions, C# code inside code blocks isn't rendered. I blocchi di codice e le espressioni in una visualizzazione condividono lo stesso ambito e vengono definiti in ordine: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>

Il codice esegue il rendering dell'HTML seguente: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>

Nei blocchi di codice dichiarare funzioni locali con markup da usare come metodi per la creazione di modelli:In code blocks, declare local functions with markup to serve as templating methods:

@{
    void RenderName(string name)
    {
        <p>Name: <strong>@name</strong></p>
    }

    RenderName("Mahatma Gandhi");
    RenderName("Martin Luther King, Jr.");
}

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

<p>Name: <strong>Mahatma Gandhi</strong></p>
<p>Name: <strong>Martin Luther King, Jr.</strong></p>

Transizioni impliciteImplicit transitions

Il linguaggio predefinito in un blocco di codice è C#, ma la pagina Razor può eseguire la transizione a 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>
}

Transizione esplicita delimitataExplicit delimited transition

Per definire una sottosezione di un blocco di codice che deve eseguire il rendering HTML, racchiudere i caratteri per il rendering all'interno del tag Razor <text>: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>
}

Usare questo approccio per eseguire il rendering di HTML che non è racchiuso tra tag HTML.Use this approach to render HTML that isn't surrounded by an HTML tag. Senza un tag HTML o Razor, si verifica un errore di runtime Razor.Without an HTML or Razor tag, a Razor runtime error occurs.

Il tag <text> è utile per controllare gli spazi vuoti durante il rendering del contenuto:The <text> tag is useful to control whitespace when rendering content:

  • Solo il contenuto all'interno del tag <text> viene sottoposto a rendering.Only the content between the <text> tag is rendered.
  • Non vengono visualizzati spazi vuoti prima o dopo il tag <text> nell'output HTML.No whitespace before or after the <text> tag appears in the HTML output.

Transizione riga esplicita con @:Explicit line transition with @:

Per eseguire il rendering del resto di un'intera riga come HTML all'interno di un blocco di codice, usare la sintassi @::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
}

Senza il simbolo @: nel codice, viene generato un errore di runtime Razor.Without the @: in the code, a Razor runtime error is generated.

La presenza di caratteri @ aggiuntivi in un file Razor può causare errori del compilatore nelle istruzioni successive del blocco.Extra @ characters in a Razor file can cause compiler errors at statements later in the block. Questi errori del compilatore possono essere difficili da comprendere perché l'errore effettivo si verifica prima dell'errore segnalato.These compiler errors can be difficult to understand because the actual error occurs before the reported error. Questo errore è comune dopo la combinazione di più espressioni implicite/esplicite in un singolo blocco di codice.This error is common after combining multiple implicit/explicit expressions into a single code block.

Strutture di controlloControl structures

Le strutture di controllo sono un'estensione dei blocchi di codice.Control structures are an extension of code blocks. Tutti gli aspetti dei blocchi di codice (transizione al markup, C# inline) sono validi anche per le strutture seguenti:All aspects of code blocks (transitioning to markup, inline C#) also apply to the following structures:

Istruzioni condizionali @if, else if, else e @switchConditionals @if, else if, else, and @switch

@if controlla quando viene eseguito il codice:@if controls when code runs:

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

else e else if non richiedono il simbolo @: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>
}

Nel markup seguente viene illustrato come usare un'istruzione 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;
}

Esecuzione del ciclo @for, @foreach, @while e @do whileLooping @for, @foreach, @while, and @do while

È possibile eseguire il rendering di HTML basato su modelli con le istruzioni di controllo ciclo.Templated HTML can be rendered with looping control statements. Per eseguire il rendering di un elenco di persone:To render a list of people:

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

Sono supportate le seguenti istruzioni di ciclo: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);

@using compostaCompound @using

In C# viene usata un'istruzione using per verificare che un oggetto sia stato eliminato.In C#, a using statement is used to ensure an object is disposed. In Razor lo stesso meccanismo viene usato per creare gli helper HTML che includono contenuto aggiuntivo.In Razor, the same mechanism is used to create HTML Helpers that contain additional content. Nel codice seguente gli helper HTML eseguono il rendering di un tag <form> con l'istruzione @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>
}

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

La gestione delle eccezioni è simile a 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@lock

Razor è in grado di proteggere le sezioni critiche con le istruzioni di lock:Razor has the capability to protect critical sections with lock statements:

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

CommentiComments

Razor supporta i commenti in C# e HTML:Razor supports C# and HTML comments:

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

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

<!-- HTML comment -->

I commenti Razor vengono rimossi dal server prima che la pagina Web venga sottoposta a rendering.Razor comments are removed by the server before the webpage is rendered. Razor usa @* *@ per delimitare i commenti.Razor uses @* *@ to delimit comments. Il codice seguente è commentato, pertanto il server non esegue il rendering di alcun markup:The following code is commented out, so the server doesn't render any markup:

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

DirettiveDirectives

Le direttive Razor sono rappresentate da espressioni implicite con parole chiave riservate dopo il simbolo @.Razor directives are represented by implicit expressions with reserved keywords following the @ symbol. Una direttiva cambia in genere il modo in cui viene analizzata una visualizzazione o abilita funzionalità diverse.A directive typically changes the way a view is parsed or enables different functionality.

Comprendere come Razor genera il codice per una visualizzazione facilita la comprensione del funzionamento delle direttive.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>

Il codice genera una classe simile alla seguente: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>");
    }
}

La sezione Ispezionare la classe C# Razor generata per una visualizzazione più avanti in questo articolo illustra come visualizzare la classe generata.Later in this article, the section Inspect the Razor C# class generated for a view explains how to view this generated class.

@attribute@attribute

La direttiva @attribute aggiunge l'attributo specificato alla classe della pagina o della visualizzazione generata.The @attribute directive adds the given attribute to the class of the generated page or view. L'esempio seguente aggiunge l'attributo [Authorize]:The following example adds the [Authorize] attribute:

@attribute [Authorize]

@code@code

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

Il blocco @code consente a un componente di Razor di aggiungere membri C# (campi, proprietà e metodi) a un componente:The @code block enables a Razor component to add C# members (fields, properties, and methods) to a component:

@code {
    // C# members (fields, properties, and methods)
}

Per i componenti di Razor, @code è un alias di @functions ed è consigliato in @functions.For Razor components, @code is an alias of @functions and recommended over @functions. È consentito più di un blocco @code.More than one @code block is permissible.

@functions@functions

La direttiva @functions consente di aggiungere membri C# (campi, proprietà e metodi) alla classe generata:The @functions directive enables adding C# members (fields, properties, and methods) to the generated class:

@functions {
    // C# members (fields, properties, and methods)
}

Nei componenti di Razor usare @code in @functions per aggiungere membri C#.In Razor components, use @code over @functions to add C# members.

Ad esempio:For example:

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

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

Il codice genera il markup HTML seguente:The code generates the following HTML markup:

<div>From method: Hello</div>

Il codice seguente è la classe C# Razor generata: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

I metodi @functions fungono da metodi per la creazione di modelli quando includono markup:@functions methods serve as templating methods when they have markup:

@{
    RenderName("Mahatma Gandhi");
    RenderName("Martin Luther King, Jr.");
}

@functions {
    private void RenderName(string name)
    {
        <p>Name: <strong>@name</strong></p>
    }
}

Il codice esegue il rendering dell'HTML seguente:The code renders the following HTML:

<p>Name: <strong>Mahatma Gandhi</strong></p>
<p>Name: <strong>Martin Luther King, Jr.</strong></p>

@implements@implements

La direttiva @implements implementa un'interfaccia per la classe generata.The @implements directive implements an interface for the generated class.

L'esempio seguente implementa System.IDisposable in modo che sia possibile chiamare il metodo Dispose:The following example implements System.IDisposable so that the Dispose method can be called:

@implements IDisposable

<h1>Example</h1>

@functions {
    private bool _isDisposed;

    ...

    public void Dispose() => _isDisposed = true;
}

@inherits@inherits

La direttiva @inherits offre il controllo completo della classe che viene ereditata dalla visualizzazione:The @inherits directive provides full control of the class the view inherits:

@inherits TypeNameOfClassToInheritFrom

Il codice seguente è un tipo di pagina Razor personalizzato: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.";
}

L'elemento CustomText viene inserito in una visualizzazione:The CustomText is displayed in a view:

@inherits CustomRazorPage<TModel>

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

Il codice esegue il rendering dell'HTML seguente: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>

È possibile usare @model e @inherits nella stessa visualizzazione.@model and @inherits can be used in the same view. @inherits può trovarsi in un file _ViewImports.cshtml che viene importato dalla visualizzazione:@inherits can be in a _ViewImports.cshtml file that the view imports:

@inherits CustomRazorPage<TModel>

Il codice seguente è un esempio di visualizzazione fortemente tipizzata: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>

Se "rick@contoso.com" viene passato nel modello, la visualizzazione genera il markup HTML seguente: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@inject

La direttiva @inject consente alla pagina Razor di inserire un servizio dal contenitore di servizi in una visualizzazione.The @inject directive enables the Razor Page to inject a service from the service container into a view. Per altre informazioni, vedere Inserimento di dipendenze in visualizzazioni.For more information, see Dependency injection into views.

@layout@layout

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

La direttiva @layout specifica un layout per un componente di Razor.The @layout directive specifies a layout for a Razor component. I componenti di layout vengono usati per evitare la duplicazione e l'incoerenza del codice.Layout components are used to avoid code duplication and inconsistency. Per altre informazioni, vedere Layout di ASP.NET Core Blazer.For more information, see Layout di ASP.NET Core Blazer.

@model@model

Questo scenario si applica solo alle viste MVC e a Razor Pages (con estensione cshtml).This scenario only applies to MVC views and Razor Pages (.cshtml).

La direttiva @model specifica il tipo del modello passato a una vista o a una pagina:The @model directive specifies the type of the model passed to a view or page:

@model TypeNameOfModel

In un'app ASP.NET Core MVC o Razor Pages creata con account utente individuali, Views/Account/Login.cshtml contiene la dichiarazione di modello seguente:In an ASP.NET Core MVC or Razor Pages app created with individual user accounts, Views/Account/Login.cshtml contains the following model declaration:

@model LoginViewModel

La classe generata eredita da RazorPage<dynamic>:The class generated inherits from RazorPage<dynamic>:

public class _Views_Account_Login_cshtml : RazorPage<LoginViewModel>

Razor espone una proprietà Model per l'accesso al modello passato alla visualizzazione:Razor exposes a Model property for accessing the model passed to the view:

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

La direttiva @model specifica il tipo della proprietà Model.The @model directive specifies the type of the Model property. La direttiva specifica l'elemento T in RazorPage<T> che ha generato la classe da cui deriva la visualizzazione.The directive specifies the T in RazorPage<T> that the generated class that the view derives from. Se la direttiva @model non è specificata, la proprietà Model è di tipo dynamic.If the @model directive isn't specified, the Model property is of type dynamic. Per altre informazioni, vedere Modelli fortemente tipizzati e parola chiave @model.For more information, see Strongly typed models and the @model keyword.

@namespace@namespace

La direttiva @namespace:The @namespace directive:

  • Imposta lo spazio dei nomi della classe della pagina Razor generata, della vista MVC o del componente di Razor.Sets the namespace of the class of the generated Razor page, MVC view, or Razor component.
  • Imposta gli spazi dei nomi derivati dalla radice di pagine, viste o classi di componenti dal file di importazioni più vicino nell'albero di directory, _ViewImports.cshtml (viste o pagine) oppure _Imports.razor (componenti di Razor).Sets the root derived namespaces of a pages, views, or components classes from the closest imports file in the directory tree, _ViewImports.cshtml (views or pages) or _Imports.razor (Razor components).
@namespace Your.Namespace.Here

Per l'esempio di Razor Pages illustrato nella tabella seguente:For the Razor Pages example shown in the following table:

  • Ogni pagina importa Pages/_ViewImports.cshtml.Each page imports Pages/_ViewImports.cshtml.
  • Pages/_ViewImports.cshtml contiene @namespace Hello.World.Pages/_ViewImports.cshtml contains @namespace Hello.World.
  • Ogni pagina ha Hello.World come radice dello spazio dei nomi.Each page has Hello.World as the root of it's namespace.
PaginaPage Spazio dei nomiNamespace
Pages/Index.cshtmlPages/Index.cshtml Hello.World
Pages/MorePages/Page.cshtmlPages/MorePages/Page.cshtml Hello.World.MorePages
Pages/MorePages/EvenMorePages/Page.cshtmlPages/MorePages/EvenMorePages/Page.cshtml Hello.World.MorePages.EvenMorePages

Le relazioni precedenti si applicano ai file di importazione usati con le viste MVC e i componenti di Razor.The preceding relationships apply to import files used with MVC views and Razor components.

Quando più file di importazione hanno una direttiva @namespace, per impostare lo spazio dei nomi radice, viene usato il file più vicino alla pagina, alla vista o al componente nell'albero di directory.When multiple import files have a @namespace directive, the file closest to the page, view, or component in the directory tree is used to set the root namespace.

Se la cartella EvenMorePages nell'esempio precedente ha un file di importazione con @namespace Another.Planet (oppure il file Pages/MorePages/EvenMorePages/Page.cshtml contiene @namespace Another.Planet), il risultato è illustrato nella tabella seguente.If the EvenMorePages folder in the preceding example has an imports file with @namespace Another.Planet (or the Pages/MorePages/EvenMorePages/Page.cshtml file contains @namespace Another.Planet), the result is shown in the following table.

PaginaPage Spazio dei nomiNamespace
Pages/Index.cshtmlPages/Index.cshtml Hello.World
Pages/MorePages/Page.cshtmlPages/MorePages/Page.cshtml Hello.World.MorePages
Pages/MorePages/EvenMorePages/Page.cshtmlPages/MorePages/EvenMorePages/Page.cshtml Another.Planet

@page@page

La direttiva @page ha effetti diversi a seconda del tipo del file in cui viene visualizzata.The @page directive has different effects depending on the type of the file where it appears. La direttiva:The directive:

La direttiva @page nella prima riga di un file con estensione cshtml indica che il file è una pagina Razor.The @page directive on the first line of a .cshtml file indicates that the file is a Razor Page. Per altre informazioni, vedere Introduzione a Razor Pages in ASP.NET Core.For more information, see Introduzione a Razor Pages in ASP.NET Core.

@section@section

Questo scenario si applica solo alle viste MVC e a Razor Pages (con estensione cshtml).This scenario only applies to MVC views and Razor Pages (.cshtml).

La direttiva @section viene usata in combinazione con i layout di MVC e Razor Pages per abilitare le viste o le pagine per il rendering del contenuto in diverse parti della pagina HTML.The @section directive is used in conjunction with MVC and Razor Pages layouts to enable views or pages to render content in different parts of the HTML page. Per altre informazioni, vedere Layout in ASP.NET Core.For more information, see Layout in ASP.NET Core.

@using@using

La direttiva @using aggiunge la direttiva C# using alla visualizzazione generata:The @using directive adds the C# using directive to the generated view:

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

Nei componenti di Razor @using controlla anche quali componenti sono inclusi nell'ambito.In Razor components, @using also controls which components are in scope.

Attributi delle direttiveDirective attributes

@attributes@attributes

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

@attributes consente a un componente di eseguire il rendering di attributi non dichiarati.@attributes allows a component to render non-declared attributes. Per altre informazioni, vedere Creare e usare ASP.NET Core componenti Razor.For more information, see Creare e usare ASP.NET Core componenti Razor.

@bind@bind

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

Il data binding nei componenti viene eseguito con l'attributo @bind.Data binding in components is accomplished with the @bind attribute. Per altre informazioni, vedere Creare e usare ASP.NET Core componenti Razor.For more information, see Creare e usare ASP.NET Core componenti Razor.

@on{evento}@on{event}

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

Razor fornisce funzionalità di gestione degli eventi per i componenti.Razor provides event handling features for components. Per altre informazioni, vedere Creare e usare ASP.NET Core componenti Razor.For more information, see Creare e usare ASP.NET Core componenti Razor.

@key@key

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

L'attributo della direttiva @key fa in modo che l'algoritmo di controllo delle differenze tra componenti garantisca la conservazione degli elementi o dei componenti in base al valore della chiave.The @key directive attribute causes the components diffing algorithm to guarantee preservation of elements or components based on the key's value. Per altre informazioni, vedere Creare e usare ASP.NET Core componenti Razor.For more information, see Creare e usare ASP.NET Core componenti Razor.

@ref@ref

Questo scenario si applica solo ai componenti di Razor (con estensione razor).This scenario only applies to Razor components (.razor).

I riferimenti ai componenti (@ref) consentono di fare riferimento a un'istanza di un componente in modo che sia possibile eseguire comandi su tale istanza.Component references (@ref) provide a way to reference a component instance so that you can issue commands to that instance. Per altre informazioni, vedere Creare e usare ASP.NET Core componenti Razor.For more information, see Creare e usare ASP.NET Core componenti Razor.

Delegati Razor basati su modelliTemplated Razor delegates

I modelli Razor consentono di definire un frammento di codice dell'interfaccia utente con il formato seguente:Razor templates allow you to define a UI snippet with the following format:

@<tag>...</tag>

L'esempio seguente illustra come specificare un delegato Razor basato su modelli come Func<T,TResult>.The following example illustrates how to specify a templated Razor delegate as a Func<T,TResult>. Per il parametro del metodo incapsulato dal delegato viene specificato il tipo dinamico.The dynamic type is specified for the parameter of the method that the delegate encapsulates. Come valore restituito del delegato viene specificato un tipo di oggetto.An object type is specified as the return value of the delegate. Il modello viene usato con un oggetto List<T> di Pet dotato della proprietà Name.The template is used with a List<T> of Pet that has a Name property.

public class Pet
{
    public string Name { get; set; }
}
@{
    Func<dynamic, object> petTemplate = @<p>You have a pet named <strong>@item.Name</strong>.</p>;

    var pets = new List<Pet>
    {
        new Pet { Name = "Rin Tin Tin" },
        new Pet { Name = "Mr. Bigglesworth" },
        new Pet { Name = "K-9" }
    };
}

Il rendering del modello viene eseguito con pets in un'istruzione foreach:The template is rendered with pets supplied by a foreach statement:

@foreach (var pet in pets)
{
    @petTemplate(pet)
}

Output sottoposto a rendering:Rendered output:

<p>You have a pet named <strong>Rin Tin Tin</strong>.</p>
<p>You have a pet named <strong>Mr. Bigglesworth</strong>.</p>
<p>You have a pet named <strong>K-9</strong>.</p>

È anche possibile specificare un modello Razor inline come argomento di un metodo.You can also supply an inline Razor template as an argument to a method. Nell'esempio seguente, il metodo Repeat riceve un modello Razor.In the following example, the Repeat method receives a Razor template. Il metodo usa il modello per generare contenuto HTML tramite ripetizioni di elementi (item) ricavati da un elenco:The method uses the template to produce HTML content with repeats of items supplied from a list:

@using Microsoft.AspNetCore.Html

@functions {
    public static IHtmlContent Repeat(IEnumerable<dynamic> items, int times,
        Func<dynamic, IHtmlContent> template)
    {
        var html = new HtmlContentBuilder();

        foreach (var item in items)
        {
            for (var i = 0; i < times; i++)
            {
                html.AppendHtml(template(item));
            }
        }

        return html;
    }
}

Usando l'elenco di animali domestici (pets) dell'esempio precedente, il metodo Repeat viene chiamato con:Using the list of pets from the prior example, the Repeat method is called with:

  • List<T> di Pet.List<T> of Pet.
  • Numero di ripetizioni di ogni animale domestico.Number of times to repeat each pet.
  • Modello inline da usare per gli elementi elenco di un elenco non ordinato.Inline template to use for the list items of an unordered list.
<ul>
    @Repeat(pets, 3, @<li>@item.Name</li>)
</ul>

Output sottoposto a rendering:Rendered output:

<ul>
    <li>Rin Tin Tin</li>
    <li>Rin Tin Tin</li>
    <li>Rin Tin Tin</li>
    <li>Mr. Bigglesworth</li>
    <li>Mr. Bigglesworth</li>
    <li>Mr. Bigglesworth</li>
    <li>K-9</li>
    <li>K-9</li>
    <li>K-9</li>
</ul>

Helper tagTag Helpers

Questo scenario si applica solo alle viste MVC e a Razor Pages (con estensione cshtml).This scenario only applies to MVC views and Razor Pages (.cshtml).

Esistono tre direttive che riguardano gli helper tag.There are three directives that pertain to Tag Helpers.

DirettivaDirective FunzioneFunction
@addTagHelper Rende gli helper tag disponibili per una visualizzazione.Makes Tag Helpers available to a view.
@removeTagHelper Rimuove gli helper tag aggiunti in precedenza da una visualizzazione.Removes Tag Helpers previously added from a view.
@tagHelperPrefix Specifica un prefisso del tag per abilitare il supporto dell'helper tag e renderne esplicito l'uso.Specifies a tag prefix to enable Tag Helper support and to make Tag Helper usage explicit.

Parole chiave riservate RazorRazor reserved keywords

Parole chiave RazorRazor keywords

  • page (richiede ASP.NET Core 2.1 o versione successiva)page (Requires ASP.NET Core 2.1 or later)
  • namespacenamespace
  • functionsfunctions
  • inheritsinherits
  • modelmodel
  • sectionsection
  • helper (attualmente non supportata da ASP.NET Core)helper (Not currently supported by ASP.NET Core)

Le parole chiave Razor sono precedute dal carattere di escape @(Razor Keyword) (ad esempio, @(functions)).Razor keywords are escaped with @(Razor Keyword) (for example, @(functions)).

Parole chiave Razor C#C# Razor keywords

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

Le parole chiave Razor C# devono essere precedute dal doppio carattere di escape @(@C# Razor Keyword) (ad esempio, @(@case)).C# Razor keywords must be double-escaped with @(@C# Razor Keyword) (for example, @(@case)). Il primo @ è il carattere di escape del parser Razor.The first @ escapes the Razor parser. Il secondo @ è il carattere di escape del parser C#.The second @ escapes the C# parser.

Parole chiave riservate non usate da RazorReserved keywords not used by Razor

  • classeclass

Ispezionare la classe C# Razor generata per una visualizzazioneInspect the Razor C# class generated for a view

Con .NET Core SDK 2.1 o versioni successive, il SDK Razor gestisce la compilazione dei file Razor.With .NET Core SDK 2.1 or later, the Razor SDK handles compilation of Razor files. Quando si compila un progetto, il SDK Razor genera una directory obj/<build_configuration>/<target_framework_moniker>/Razor nella radice del progetto.When building a project, the Razor SDK generates an obj/<build_configuration>/<target_framework_moniker>/Razor directory in the project root. La struttura di directory all'interno della directory Razor rispecchia la struttura di directory del progetto.The directory structure within the Razor directory mirrors the project's directory structure.

Si consideri la seguente struttura di directory in un progetto Razor Pages ASP.NET Core 2.1 destinato a .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 compilazione del progetto nella configurazione Debug produce la seguente directory obj: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

Per visualizzare la classe generata per Pages/Index.cshtml aprire 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.

Aggiungere la classe seguente al progetto 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;
    }
}

In Startup.ConfigureServices eseguire l'override dell'elemento RazorTemplateEngine aggiunto da MVC con 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>();
}

Impostare un punto di interruzione per l'istruzione return csharpDocument; di CustomTemplateEngine.Set a breakpoint on the return csharpDocument; statement of CustomTemplateEngine. Quando l'esecuzione del programma si interrompe nel punto di interruzione, visualizzare il valore di generatedCode.When program execution stops at the breakpoint, view the value of generatedCode.

Visualizzazione nel visualizzatore testo del codice generato

Visualizzazione di ricerche e distinzione tra maiuscole e minuscoleView lookups and case sensitivity

Il motore di visualizzazione Razor esegue ricerche con distinzione tra maiuscole e minuscole per le visualizzazioni.The Razor view engine performs case-sensitive lookups for views. La ricerca effettiva è tuttavia determinata dal file system sottostante:However, the actual lookup is determined by the underlying file system:

  • Origine basata su file:File based source:
    • Nei sistemi operativi con file system che non fanno distinzione tra maiuscole e minuscole (ad esempio, Windows), le ricerche del provider di file fisici non eseguono la distinzione tra maiuscole e minuscole.On operating systems with case insensitive file systems (for example, Windows), physical file provider lookups are case insensitive. Ad esempio, return View("Test") comporta corrispondenze per /Views/Home/Test.cshtml, /Views/home/test.cshtml e qualsiasi altra variante di maiuscole e minuscole.For example, return View("Test") results in matches for /Views/Home/Test.cshtml, /Views/home/test.cshtml, and any other casing variant.
    • Nei file system che fanno distinzione tra maiuscole e minuscole (ad esempio Linux, OS x e con EmbeddedFileProvider), le ricerche eseguono la distinzione tra maiuscole e minuscole.On case-sensitive file systems (for example, Linux, OSX, and with EmbeddedFileProvider), lookups are case-sensitive. Ad esempio, return View("Test") trova specificamente le corrispondenze per /Views/Home/Test.cshtml.For example, return View("Test") specifically matches /Views/Home/Test.cshtml.
  • Visualizzazioni precompilate: Con ASP.NET Core 2.0 e versioni successive, la ricerca di visualizzazioni precompilate non esegue la distinzione tra maiuscole e minuscole in tutti i sistemi operativi.Precompiled views: With ASP.NET Core 2.0 and later, looking up precompiled views is case insensitive on all operating systems. Questo comportamento è identico al comportamento del provider di file fisici in Windows.The behavior is identical to physical file provider's behavior on Windows. Se due visualizzazioni precompilate differiscono solo nelle lettere maiuscole e minuscole, il risultato di ricerca è non deterministico.If two precompiled views differ only in case, the result of lookup is non-deterministic.

Gli sviluppatori sono invitati a far corrispondere le maiuscole e minuscole dei nomi di file e directory per quanto riguarda le maiuscole e minuscole di:Developers are encouraged to match the casing of file and directory names to the casing of:

  • Nomi di area, controller e azione.Area, controller, and action names.
  • Pagine Razor.Razor Pages.

La distinzione tra maiuscole e minuscole assicura che le distribuzioni trovino le proprie visualizzazioni indipendentemente dal file system sottostante.Matching case ensures the deployments find their views regardless of the underlying file system.