Az alkalmazásmodell működése a ASP.NET Core-ban

Készítette: Steve Smith

ASP.NET Core MVC egy MVC-alkalmazás összetevőit képviselő alkalmazásmodellt határoz meg. Olvassa el és módosítsa ezt a modellt az MVC-elemek viselkedésének módosításához. Alapértelmezés szerint az MVC bizonyos konvenciókat követ annak meghatározására, hogy mely osztályok minősülnek vezérlőnek, mely metódusok műveletek, és hogyan viselkednek a paraméterek és az útválasztás. Egyéni konvenciók létrehozásával és globálisan vagy attribútumként való alkalmazásával testre szabhatja ezt a viselkedést az alkalmazás igényeinek megfelelően.

Modellek és szolgáltatók (`IApplicationModelProvider`)

A ASP.NET Core MVC-alkalmazásmodell absztrakt interfészeket és konkrét implementációs osztályokat is tartalmaz, amelyek egy MVC-alkalmazást írnak le. Ez a modell annak az eredménye, hogy az MVC felderíti az alkalmazás vezérlőit, műveleteit, műveleti paramétereit, útvonalait és szűrőit az alapértelmezett konvenciók szerint. Az alkalmazásmodell használatával módosítsa az alkalmazást úgy, hogy az az alapértelmezett MVC-viselkedéstől eltérő konvenciók szerint működjön. A paraméterek, nevek, útvonalak és szűrők mind a műveletek és vezérlők konfigurációs adataiként használatosak.

A ASP.NET Core MVC-alkalmazásmodell a következő struktúrával rendelkezik:

ApplicationModel
- Vezérlők (ControllerModel)
  - Műveletek (ActionModel)
    - Paraméterek (ParameterModel)

A modell minden szintje rendelkezik hozzáféréssel egy közös Properties gyűjteményhez, az alacsonyabb szintek pedig a hierarchia magasabb szintjei által beállított tulajdonságértékeket érhetik el és írhatják felül. A tulajdonságok megmaradnak a ActionDescriptor.Properties műveletek létrehozásakor. Ezután a kérések kezelésekor a konvenció által hozzáadott vagy módosított tulajdonságok a következőn keresztül ActionContext.ActionDescriptorérhetők el: A tulajdonságok használatával műveletek alapján konfigurálhat szűrőket, modellkötőket és más alkalmazásmodell-szempontokat.

Megjegyzés:

A ActionDescriptor.Properties gyűjtemény nem biztonságos a szálon (íráshoz) az alkalmazás indítása után. A konvenciók a legjobb módja annak, hogy biztonságosan adja hozzá az adatokat ehhez a gyűjteményhez.

ASP.NET Core MVC az alkalmazásmodellt az interfész által IApplicationModelProvider meghatározott szolgáltatói mintával tölti be. Ez a szakasz a szolgáltató működésének néhány belső implementálási részletét ismerteti. A szolgáltatói minta használata speciális téma, elsősorban a keretrendszerek használatához. A legtöbb alkalmazásnak konvenciókat kell használnia, nem pedig a szolgáltatói mintát.

A IApplicationModelProvider interfész implementációi egymást "becsomagolják", ahol az egyes implementációk a OnProvidersExecuting tulajdonságuk szerinti növekvő sorrendben hívják meg a Order függvényt. A OnProvidersExecuted metódus ezután fordított sorrendben lesz meghívva. A keretrendszer több szolgáltatót határoz meg:

Első (Order=-1000):

DefaultApplicationModelProvider

Ezután (Order=-990):

AuthorizationApplicationModelProvider
CorsApplicationModelProvider

Megjegyzés:

A két azonos értékű Order szolgáltató meghívásának sorrendje nem definiált, és nem szabad támaszkodni rá.

Megjegyzés:

IApplicationModelProvider egy előrehaladott koncepció, amit a keretrendszer szerzői bővíthetnek. Az alkalmazásoknak általában konvenciókat kell használniuk, a keretrendszereknek pedig szolgáltatókat kell használniuk. A legfontosabb különbség az, hogy a szolgáltatók mindig a konvenciók előtt futnak.

Ez DefaultApplicationModelProvider az ASP.NET Core MVC által használt alapértelmezett viselkedések közül számosat meghatározza. Feladatai a következők:

Globális szűrők hozzáadása a környezethez
Vezérlők hozzáadása a környezethez
Nyilvános vezérlő metódusok hozzáadása műveletekként
Műveletmetódus paramétereinek hozzáadása a környezethez
Útvonal és egyéb attribútumok alkalmazása

Néhány beépített viselkedés a DefaultApplicationModelProvider által vannak megvalósítva. Ez a szolgáltató felelős a ControllerModel megépítéséért, amely a ActionModel, PropertyModel, és ParameterModel példányokra hivatkozik. Az DefaultApplicationModelProvider osztály egy belső keretrendszer implementálási részlete, amely a jövőben változhat.

Az AuthorizationApplicationModelProvider attribútumokhoz társított viselkedés alkalmazásáért a AuthorizeFilter AllowAnonymousFilter felelős. További információ: Egyszerű engedélyezés a ASP.NET Core-ban.

A CorsApplicationModelProvider a IEnableCorsAttribute és a IDisableCorsAttribute viselkedését valósítja meg. További információt a ASP.NET Core Keresztirányú kérelmek engedélyezése (CORS) című témakörben talál.

A keretrendszer ebben a szakaszban ismertetett belső szolgáltatóival kapcsolatos információk nem érhetők el a .NET API böngészőn keresztül. A szolgáltatókat azonban megvizsgálhatja a ASP.NET Core referenciaforrásban (dotnet/aspnetcore GitHub-adattár) is. A GitHub-kereséssel név szerint keresheti meg a szolgáltatókat, és kiválaszthatja a forrás verzióját az Ágak/címkék váltása legördülő listával.

Egyezmények

Az alkalmazásmodell konvenciós absztrakciókat határoz meg, amelyek egyszerűbben szabják testre a modellek viselkedését, mint a teljes modell vagy szolgáltató felülbírálása. Ezek az absztrakciók az alkalmazások viselkedésének módosításához ajánlottak. A konvenciók lehetővé teszik olyan kód írását, amely dinamikusan alkalmazza a testreszabásokat. Bár a szűrők lehetővé teszik a keretrendszer viselkedésének módosítását, a testreszabásokkal szabályozható, hogy az egész alkalmazás hogyan működik együtt.

A következő konvenciók érhetők el:

A konvenciók az MVC-beállításokhoz való hozzáadásával vagy attribútumok implementálásával és vezérlőkre, műveletekre vagy műveleti paraméterekre (a szűrőkhöz hasonlóan) való alkalmazásával alkalmazhatók. A szűrőkkel ellentétben a konvenciók csak az alkalmazás indításakor lesznek végrehajtva, nem az egyes kérések részeként.

Megjegyzés:

A Pages útvonal- és alkalmazásmodell-szolgáltatói konvencióiról Razor további információt a Pages útvonal- és alkalmazáskonvenciái ASP.NET Core-ban találRazor.

Módosítsa a `ApplicationModel`

A következő konvencióval adhat hozzá tulajdonságot az alkalmazásmodellhez:

using Microsoft.AspNetCore.Mvc.ApplicationModels;

namespace AppModelSample.Conventions
{
    public class ApplicationDescription : IApplicationModelConvention
    {
        private readonly string _description;

        public ApplicationDescription(string description)
        {
            _description = description;
        }

        public void Apply(ApplicationModel application)
        {
            application.Properties["description"] = _description;
        }
    }
}

Az alkalmazásmodell-konvenciók beállításként lesznek alkalmazva az MVC hozzáadásakor:Startup.ConfigureServices

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc(options =>
    {
        options.Conventions.Add(new ApplicationDescription("My Application Description"));
        options.Conventions.Add(new NamespaceRoutingConvention());
    });
}

A tulajdonságok a ActionDescriptor.Properties vezérlőműveletek gyűjteményéből érhetők el:

public class AppModelController : Controller
{
    public string Description()
    {
        return "Description: " + ControllerContext.ActionDescriptor.Properties["description"];
    }
}

A `ControllerModel` leírás módosítása

A vezérlőmodell egyéni tulajdonságokat is tartalmazhat. Az egyéni tulajdonságok felülbírálják az alkalmazásmodellben megadott névvel rendelkező meglévő tulajdonságokat. A következő konvenció attribútum a vezérlő szintjén ad hozzá leírást:

using System;
using Microsoft.AspNetCore.Mvc.ApplicationModels;

namespace AppModelSample.Conventions
{
    public class ControllerDescriptionAttribute : Attribute, IControllerModelConvention
    {
        private readonly string _description;

        public ControllerDescriptionAttribute(string description)
        {
            _description = description;
        }

        public void Apply(ControllerModel controllerModel)
        {
            controllerModel.Properties["description"] = _description;
        }
    }
}

Ez a konvenció attribútumként van alkalmazva egy vezérlőn:

[ControllerDescription("Controller Description")]
public class DescriptionAttributesController : Controller
{
    public string Index()
    {
        return "Description: " + ControllerContext.ActionDescriptor.Properties["description"];
    }

A `ActionModel` leírás módosítása

Külön attribútumkonvenciát alkalmazhat az egyes műveletekre, az alkalmazás vagy a vezérlő szintjén már alkalmazott felülbírálási viselkedésre:

using System;
using Microsoft.AspNetCore.Mvc.ApplicationModels;

namespace AppModelSample.Conventions
{
    public class ActionDescriptionAttribute : Attribute, IActionModelConvention
    {
        private readonly string _description;

        public ActionDescriptionAttribute(string description)
        {
            _description = description;
        }

        public void Apply(ActionModel actionModel)
        {
            actionModel.Properties["description"] = _description;
        }
    }
}

Ha ezt egy vezérlőn belüli műveletre alkalmazza, az bemutatja, hogyan bírálja felül a vezérlőszintű konvenciót:

[ControllerDescription("Controller Description")]
public class DescriptionAttributesController : Controller
{
    public string Index()
    {
        return "Description: " + ControllerContext.ActionDescriptor.Properties["description"];
    }

    [ActionDescription("Action Description")]
    public string UseActionDescriptionAttribute()
    {
        return "Description: " + ControllerContext.ActionDescriptor.Properties["description"];
    }
}

Módosítsa a `ParameterModel`

A műveletparaméterekre a következő konvenciók alkalmazhatók a módosításukhoz BindingInfo. Az alábbi konvenció megköveteli, hogy a paraméter útvonalparaméter legyen. A rendszer figyelmen kívül hagyja az egyéb lehetséges kötési forrásokat, például a lekérdezési sztringértékeket:

using System;
using Microsoft.AspNetCore.Mvc.ApplicationModels;
using Microsoft.AspNetCore.Mvc.ModelBinding;

namespace AppModelSample.Conventions
{
    public class MustBeInRouteParameterModelConvention : Attribute, IParameterModelConvention
    {
        public void Apply(ParameterModel model)
        {
            if (model.BindingInfo == null)
            {
                model.BindingInfo = new BindingInfo();
            }
            model.BindingInfo.BindingSource = BindingSource.Path;
        }
    }
}

Az attribútum bármely műveleti paraméterre alkalmazható:

public class ParameterModelController : Controller
{
    // Will bind:  /ParameterModel/GetById/123
    // WON'T bind: /ParameterModel/GetById?id=123
    public string GetById([MustBeInRouteParameterModelConvention]int id)
    {
        return $"Bound to id: {id}";
    }
}

Ha az egyezményt az összes műveletparaméterre alkalmazni szeretné, adja hozzá a MustBeInRouteParameterModelConvention-t MvcOptions-hez a Startup.ConfigureServices-ben:

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

A `ActionModel` név módosítása

Az alábbi konvenció módosítja a(z) ActionModel -t úgy, hogy az alkalmazott művelet neve frissül. Az új nevet paraméterként adja meg az attribútum. Ezt az új nevet használja az útválasztás, ezért hatással van a művelet végrehajtásához használt útvonalra:

using System;
using Microsoft.AspNetCore.Mvc.ApplicationModels;

namespace AppModelSample.Conventions
{
    public class CustomActionNameAttribute : Attribute, IActionModelConvention
    {
        private readonly string _actionName;

        public CustomActionNameAttribute(string actionName)
        {
            _actionName = actionName;
        }

        public void Apply(ActionModel actionModel)
        {
            // this name will be used by routing
            actionModel.ActionName = _actionName;
        }
    }
}

Ez az attribútum a következő műveletmetódusra HomeControllerlesz alkalmazva:

// Route: /Home/MyCoolAction
[CustomActionName("MyCoolAction")]
public string SomeName()
{
    return ControllerContext.ActionDescriptor.ActionName;
}

Annak ellenére, hogy a metódus neve az SomeName, az attribútum felülírja a metódusnév MVC-konvencióját, és lecseréli a művelet nevét a következőre MyCoolAction: . Így a művelet eléréséhez használt útvonal a következő /Home/MyCoolAction.

Megjegyzés:

Ez a példa ebben a szakaszban lényegében ugyanaz, mint a beépített ActionNameAttribute.

Egyéni útválasztási konvenció

Az útválasztás működésének testreszabásához használjon egy IApplicationModelConvention-t. Az alábbi konvenció például a vezérlők névtereit foglalja bele az útvonalakba, úgy hogy a névtér . helyét az útvonalban /-re cseréli.

using Microsoft.AspNetCore.Mvc.ApplicationModels;
using System.Linq;

namespace AppModelSample.Conventions
{
    public class NamespaceRoutingConvention : IApplicationModelConvention
    {
        public void Apply(ApplicationModel application)
        {
            foreach (var controller in application.Controllers)
            {
                var hasAttributeRouteModels = controller.Selectors
                    .Any(selector => selector.AttributeRouteModel != null);

                if (!hasAttributeRouteModels
                    && controller.ControllerName.Contains("Namespace")) // affect one controller in this sample
                {
                    // Replace the . in the namespace with a / to create the attribute route
                    // Ex: MySite.Admin namespace will correspond to MySite/Admin attribute route
                    // Then attach [controller], [action] and optional {id?} token.
                    // [Controller] and [action] is replaced with the controller and action
                    // name to generate the final template
                    controller.Selectors[0].AttributeRouteModel = new AttributeRouteModel()
                    {
                        Template = controller.ControllerType.Namespace.Replace('.', '/') + "/[controller]/[action]/{id?}"
                    };
                }
            }

            // You can continue to put attribute route templates for the controller actions depending on the way you want them to behave
        }
    }
}

A konvenció a következő lehetőségként van hozzáadva Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc(options =>
    {
        options.Conventions.Add(new ApplicationDescription("My Application Description"));
        options.Conventions.Add(new NamespaceRoutingConvention());
    });
}

Jótanács

Konvenciók hozzáadása köztes szoftverhez MvcOptions az alábbi módszer használatával. A {CONVENTION} helyőrző az a konvenció, amelyet hozzá kell adni:

services.Configure<MvcOptions>(c => c.Conventions.Add({CONVENTION}));

Az alábbi példa egy konvenciót alkalmaz azokra az útvonalakra, amelyek nem attribútumalapú útválasztást használnak, ahol a vezérlő a nevében szerepel Namespace :

using Microsoft.AspNetCore.Mvc;

namespace AppModelSample.Controllers
{
    public class NamespaceRoutingController : Controller
    {
        // using NamespaceRoutingConvention
        // route: /AppModelSample/Controllers/NamespaceRouting/Index
        public string Index()
        {
            return "This demonstrates namespace routing.";
        }
    }
}

Alkalmazásmodell használata a következőben: `WebApiCompatShim`

ASP.NET Core MVC a ASP.NET Web API 2-től eltérő konvenciókat használ. Egyéni konvenciók használatával módosíthatja egy ASP.NET Core MVC-alkalmazás viselkedését, hogy összhangban legyen egy web API-alkalmazáséval. A Microsoft kifejezetten erre a célra szállítja a WebApiCompatShim NuGet-csomagot .

Megjegyzés:

A ASP.NET Webes API-ból való migrálással kapcsolatos további információkért lásd: Migrálás ASP.NET Webes API-ból ASP.NET Core-ba.

A Web API kompatibilitási réteg használata:

Adja hozzá a Microsoft.AspNetCore.Mvc.WebApiCompatShim csomagot a projekthez.
Adja hozzá a konvenciókat az MVC-hez azzal, hogy meghívja a AddWebApiConventions a Startup.ConfigureServices-ben.

services.AddMvc().AddWebApiConventions();

A shim által biztosított konvenciók csak az alkalmazás azon részeire vonatkoznak, amelyekre bizonyos attribútumok vonatkoztak. A következő négy attribútumot használjuk annak ellenőrzésére, hogy mely vezérlőknek kell módosítaniuk a konvencióikat a shim konvenciók szerint:

Műveleti konvenciók

UseWebApiActionConventionsAttribute az HTTP-metódus nevük szerinti műveletekre való leképezéséhez használatos (például a Get leképezve lenne a HttpGet-re). Csak azokra a műveletekre vonatkozik, amelyek nem használnak attribútum-útválasztást.

Túlterhelés

UseWebApiOverloadingAttribute a WebApiOverloadingApplicationModelConvention konvenció alkalmazására szolgál. Ez a konvenció hozzáad egy OverloadActionConstraint műveletkiválasztási folyamatot, amely korlátozza a jelöltműveleteket azokra, amelyek esetében a kérelem kielégíti az összes nem választható paramétert.

Paraméterkonvenciák

UseWebApiParameterConventionsAttribute a műveletkonvenció WebApiParameterConventionsApplicationModelConvention alkalmazására szolgál. Ez a konvenció azt határozza meg, hogy a műveleti paraméterekként használt egyszerű típusok alapértelmezés szerint az URI-ból, míg az összetett típusok a kérelem törzséből vannak kötve.

Útvonalak

UseWebApiRoutesAttribute szabályozza, hogy a WebApiApplicationModelConvention vezérlőkre vonatkozó konvenció érvényesül-e. Ha engedélyezve van, ez a konvenció a területek támogatásának hozzáadására szolgál az útvonalhoz, és jelzi, hogy a vezérlő a api területen van.

A kompatibilitási csomag a konvenciók mellett egy alaposztályt System.Web.Http.ApiController is tartalmaz, amely a webes API által biztosítottat helyettesíti. Ez lehetővé teszi, hogy az Ön ApiController API-vezérlői, amelyeket webes API-hoz írtak, működjenek, miközben az ASP.NET Core MVC-on futnak. UseWebApi* A korábban felsorolt összes attribútum az alapvezérlőosztályra lesz alkalmazva. A ApiController webes API-ban találhatóakkal kompatibilis tulajdonságokat, metódusokat és eredménytípusokat tesz elérhetővé.

Használja a `ApiExplorer` az alkalmazás dokumentálásához

Az alkalmazásmodell minden szinten elérhetővé tesz egy ApiExplorerModel tulajdonságot, amely az alkalmazás szerkezetének bejárására használható. Ez használható a webes API-k súgóoldalainak létrehozására olyan eszközök használatával, mint a Swagger. A ApiExplorer tulajdonság egy IsVisible tulajdonságot tesz elérhetővé, amely megadhatja, hogy az alkalmazás modelljének mely részei legyenek közzétéve. Konvenció használatával konfigurálja ezt a beállítást:

using Microsoft.AspNetCore.Mvc.ApplicationModels;

namespace AppModelSample.Conventions
{
    public class EnableApiExplorerApplicationConvention : IApplicationModelConvention
    {
        public void Apply(ApplicationModel application)
        {
            application.ApiExplorer.IsVisible = true;
        }
    }
}

Ezzel a megközelítéssel (és szükség esetén további konvenciókkal) az API láthatósága engedélyezve van vagy le van tiltva az alkalmazás bármely szintjén.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-06-28

Megosztás a következőn keresztül:

Az alkalmazásmodell működése a ASP.NET Core-ban

Modellek és szolgáltatók (IApplicationModelProvider)

Egyezmények

Módosítsa a ApplicationModel

A ControllerModel leírás módosítása

A ActionModel leírás módosítása

Módosítsa a ParameterModel

A ActionModel név módosítása

Egyéni útválasztási konvenció

Alkalmazásmodell használata a következőben: WebApiCompatShim

Műveleti konvenciók

Túlterhelés

Paraméterkonvenciák

Útvonalak

Használja a ApiExplorer az alkalmazás dokumentálásához

Visszajelzés

További források

Modellek és szolgáltatók (`IApplicationModelProvider`)

Módosítsa a `ApplicationModel`

A `ControllerModel` leírás módosítása

A `ActionModel` leírás módosítása

Módosítsa a `ParameterModel`

A `ActionModel` név módosítása

Alkalmazásmodell használata a következőben: `WebApiCompatShim`

Használja a `ApiExplorer` az alkalmazás dokumentálásához