Dela via

Översikt över ASP.NET Core MVC

Av Steve Smith

ASP.NET Core MVC är ett omfattande ramverk för att skapa webbappar och API:er med hjälp av designmönstret ModellView-Controller.

MVC-mönster

Arkitekturmönstret Model-View-Controller (MVC) separerar ett program i tre huvudgrupper med komponenter: modeller, vyer och styrenheter. Det här mönstret hjälper till att uppnå separation av problem. Med det här mönstret dirigeras användarbegäranden till en kontrollant som ansvarar för att arbeta med modellen för att utföra användaråtgärder och/eller hämta resultat av frågor. Kontrollanten väljer den vy som ska visas för användaren och ger den alla modelldata som krävs.

Följande diagram visar de tre huvudkomponenterna och vilka som refererar till de andra:

MVC-mönster

Den här avgränsningen av ansvarsområden hjälper dig att skala programmet när det gäller komplexitet eftersom det är enklare att koda, felsöka och testa något (modell, vy eller kontrollant) som har ett enda jobb. Det är svårare att uppdatera, testa och felsöka kod som har beroenden spridda över två eller flera av dessa tre områden. Användargränssnittslogik tenderar till exempel att ändras oftare än affärslogik. Om presentationskod och affärslogik kombineras i ett enda objekt måste ett objekt som innehåller affärslogik ändras varje gång användargränssnittet ändras. Detta medför ofta fel och kräver omtestning av affärslogik efter varje minimal ändring av användargränssnittet.

Anmärkning

Både vyn och kontrollanten är beroende av modellen. Modellen är dock beroende av varken vyn eller kontrollanten. Detta är en av de viktigaste fördelarna med separationen. Den här separationen gör att modellen kan skapas och testas oberoende av den visuella presentationen.

Modellansvar

Modellen i ett MVC-program representerar programmets tillstånd och alla affärslogik eller åtgärder som ska utföras av det. Affärslogik bör kapslas in i modellen, tillsammans med all implementeringslogik för att bevara programmets tillstånd. Tydligt typade vyer använder vanligtvis ViewModel-typer som är utformade för att innehålla den data som ska visas i den vyn. Kontrollanten skapar och fyller i dessa ViewModel-instanser från modellen.

Visa ansvarsområden

Vyer ansvarar för att presentera innehåll via användargränssnittet. De använder Razor vymotorn för att bädda in .NET-kod i HTML-kod. Det bör finnas minimal logik i vyer, och all logik i dem bör relatera till att presentera innehåll. Om du upptäcker behovet av att utföra en hel del logik i visningsfiler för att visa data från en komplex modell kan du överväga att använda en vykomponent, ViewModel eller en vymall för att förenkla vyn.

Kontrollantens ansvarsområden

Styrenheter är de komponenter som hanterar användarinteraktion, arbetar med modellen och slutligen väljer en vy att återge. I ett MVC-program visar vyn endast information. styrenheten hanterar och svarar på användarindata och interaktion. I MVC-mönstret är kontrollanten den första startpunkten och ansvarar för att välja vilka modelltyper som ska användas och vilken vy som ska återges (därav namnet – den styr hur appen svarar på en viss begäran).

Anmärkning

Kontrollanter bör inte vara alltför komplicerade av för många ansvarsområden. Om du vill förhindra att kontrollantlogik blir alltför komplex kan du push-överföra affärslogik från kontrollanten och in i domänmodellen.

Tips/Råd

Om du upptäcker att dina kontrollantåtgärder ofta utför samma typer av åtgärder flyttar du dessa vanliga åtgärder till filter.

ASP.NET Core MVC

det ASP.NET Core MVC-ramverket är ett enkelt presentationsramverk med öppen källkod som är mycket testbart och optimerat för användning med ASP.NET Core.

ASP.NET Core MVC är ett mönsterbaserat sätt att skapa dynamiska webbplatser som möjliggör en ren separation av problem. Det ger dig fullständig kontroll över markup, stöder TDD-vänlig utveckling och använder de senaste webbstandarderna.

Routing

ASP.NET Core MVC bygger på ASP.NET Cores routning, en kraftfull URL-mappningskomponent som gör att du kan skapa program som har begripliga och sökbara URL:er. På så sätt kan du definiera ditt programs URL-namngivningsmönster som fungerar bra för sökmotoroptimering (SEO) och för länkgenerering, utan hänsyn till hur filerna på webbservern är ordnade. Du kan definiera dina vägar med hjälp av en praktisk routningsmallssyntax som stöder vägvärdebegränsningar, standardvärden och valfria värden.

Med konventionsbaserad routning kan du globalt definiera de URL-format som ditt program accepterar och hur vart och ett av dessa format mappar till en specifik åtgärdsmetod på en viss kontrollant. När en inkommande begäran tas emot parsar routningsmotorn URL:en och matchar den med något av de definierade URL-formaten och anropar sedan den associerade kontrollantens åtgärdsmetod.

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

Med attributroutning kan du ange routningsinformation genom att dekorera dina kontrollanter och åtgärder med attribut som definierar programmets vägar. Det innebär att routningsdefinitionerna placeras bredvid kontrollanten och åtgärden som de är associerade med.

[Route("api/[controller]")]
public class ProductsController : Controller
{
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id)
    {
      ...
    }
}

Modellbindning

ASP.NET Core MVC-modellbindning konverterar data för klientbegäran (formulärvärden, vägdata, frågesträngsparametrar, HTTP-huvuden) till objekt som kontrollanten kan hantera. Därför behöver inte din styrenhetslogik utföra arbetet med att räkna ut inkommande begärandedata. Den har helt enkelt data som parametrar för sina åtgärdsmetoder.

public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { ... }

Modellverifiering

ASP.NET Core MVC stöder validering genom att dekorera modellobjektet med valideringsattribut för dataanteckning. Verifieringsattributen kontrolleras på klientsidan innan värden publiceras på servern, samt på servern innan kontrollantåtgärden anropas.

using System.ComponentModel.DataAnnotations;
public class LoginViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [Display(Name = "Remember me?")]
    public bool RememberMe { get; set; }
}

En kontrollantåtgärd:

public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    if (ModelState.IsValid)
    {
      // work with the model
    }
    // At this point, something failed, redisplay form
    return View(model);
}

Ramverket hanterar validering av begärandedata både på klienten och på servern. Valideringslogik som anges för modelltyper läggs till i de renderade vyerna som diskreta anteckningar och framtvingas i webbläsaren med jQuery-validering.

Beroendeinsprutning

ASP.NET Core har inbyggt stöd för beroendeinmatning (DI). I ASP.NET Core MVC kan kontrollanter begära nödvändiga tjänster via sina konstruktorer, så att de kan följa principen explicita beroenden.

Din app kan också använda beroendeinmatning i visningsfiler med hjälp av @inject direktivet:

@inject SomeService ServiceName

<!DOCTYPE html>
<html lang="en">
<head>
    <title>@ServiceName.GetTitle</title>
</head>
<body>
    <h1>@ServiceName.GetTitle</h1>
</body>
</html>

Filterar

Filter hjälper utvecklare att kapsla in övergripande problem, till exempel undantagshantering eller auktorisering. Filter möjliggör körning av anpassad för- och efterbearbetningslogik för åtgärdsmetoder och kan konfigureras att köras på vissa platser i körningspipelinen för en viss begäran. Filter kan tillämpas på kontrollanter eller åtgärder som attribut (eller kan köras globalt). Flera filter (till exempel Authorize) ingår i ramverket. [Authorize] är attributet som används för att skapa MVC-auktoriseringsfilter.

[Authorize]
public class AccountController : Controller

Areas

Områden ger ett sätt att partitionera en stor ASP.NET Core MVC-webbapp i mindre funktionella grupper. Ett område är en MVC-struktur i ett program. I ett MVC-projekt lagras logiska komponenter som Modell, Styrenhet och Vy i olika mappar, och MVC använder namngivningskonventioner för att skapa relationen mellan dessa komponenter. För en stor app kan det vara fördelaktigt att partitionera appen i separata högnivåområden med funktioner. Till exempel en e-handelsapp med flera affärsenheter, till exempel kassa, fakturering och sökning osv. Var och en av dessa enheter har egna logiska komponentvyer, styrenheter och modeller.

Webb-API:er

Förutom att vara en bra plattform för att skapa webbplatser har ASP.NET Core MVC stort stöd för att skapa webb-API:er. Du kan skapa tjänster som når ett brett spektrum av klienter, inklusive webbläsare och mobila enheter.

Ramverket innehåller stöd för HTTP-innehållsförhandling med inbyggt stöd för att formatera data som JSON eller XML. Skriv anpassade formaterare för att lägga till stöd för dina egna format.

Använd länkgenerering för att aktivera stöd för hypermedia. Aktivera enkelt stöd för resursdelning mellan ursprung (CORS) så att dina webb-API :er kan delas mellan flera webbprogram.

Testbarhet

Ramverkets användning av gränssnitt och beroendeinmatning gör det väl lämpat för enhetstestning, och ramverket innehåller funktioner (t.ex. en TestHost- och InMemory-provider för Entity Framework) som också gör integreringstester snabba och enkla. Läs mer om hur du testar styrenhetslogik.

Razor visningsmotor

ASP.NET Core MVC-vyer använder vymotornRazor för att återge vyer. Razor är ett kompakt, uttrycksfullt och flytande mallpåläggsspråk för att definiera vyer med hjälp av inbäddad C#-kod. Razor används för att dynamiskt generera webbinnehåll på servern. Du kan smidigt blanda serverkod med innehåll och kod på klientsidan.

<ul>
    @for (int i = 0; i < 5; i++) {
        <li>List item @i</li>
    }
</ul>

Med hjälp av Razor vymotorn kan du definiera layouter, partiella vyer och utbytbara avsnitt.

Tydligt typade vyer

Razor vyer i MVC kan vara starkt typade med utgångspunkt i din modell. Kontrollanter kan skicka en starkt skriven modell till vyer som gör att dina vyer kan ha typkontroll och IntelliSense-stöd.

I följande vy återges till exempel en modell av typen IEnumerable<Product>:

@model IEnumerable<Product>
<ul>
    @foreach (Product p in Model)
    {
        <li>@p.Name</li>
    }
</ul>

Tag Helpers (hjälpmedel för taggar)

Tagghjälpare gör det möjligt för kod på serversidan att delta i skapandet och återgivningen av HTML-element i Razor filer. Du kan använda tag helpers för att definiera anpassade taggar (till exempel <environment>) eller för att ändra beteendet för befintliga taggar (till exempel <label>). Tag Helpers binder till specifika element baserat på elementnamnet och dess attribut. De ger fördelarna med rendering på serversidan samtidigt som en HTML-redigeringsupplevelse bevaras.

Det finns många inbyggda Tag Helpers för vanliga uppgifter – till exempel att skapa formulär, länkar, läsa in tillgångar med mera – och ännu mer tillgängligt i offentliga GitHub-lagringsplatser och som NuGet-paket. Tag Helpers har skapats i C#, och de riktar in sig på HTML-element baserat på elementnamn, attributnamn eller överordnad tagg. Till exempel kan den inbyggda LinkTagHelper användas för att skapa en länk till Login åtgärden för AccountsController:

<p>
    Thank you for confirming your email.
    Please <a asp-controller="Account" asp-action="Login">Click here to Log in</a>.
</p>

EnvironmentTagHelper Kan användas för att inkludera olika skript i dina vyer (till exempel råa eller minifierade) baserat på körningsmiljön, till exempel utveckling, mellanlagring eller produktion:

<environment names="Development">
    <script src="~/lib/jquery/dist/jquery.js"></script>
</environment>
<environment names="Staging,Production">
    <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.1.4.js"
            asp-fallback-src="~/lib/jquery/dist/jquery.js"
            asp-fallback-test="window.jQuery">
    </script>
</environment>

Tag Helpers tillhandahåller en HTML-vänlig utvecklingsupplevelse och en omfattande IntelliSense-miljö för att skapa HTML och Razor markering. De flesta inbyggda Tag Helpers riktar in sig på befintliga HTML-element och tillhandahåller attribut på serversidan för elementet.

Visa komponenter

Med Visa komponenter kan du paketera renderingslogik och återanvända den i hela programmet. De liknar partiella vyer, men med associerad logik.

Kompatibilitetsversion

Med SetCompatibilityVersion metoden kan en app välja eller välja bort potentiellt icke-bakåtkompatibla beteendeändringar som introduceras i ASP.NET Core MVC 2.1 eller senare.

Mer information finns i Kompatibilitetsversion för ASP.NET Core MVC.

Ytterligare resurser

  • Last updated on