Arbeiten mit dem Anwendungsmodell in ASP.NET CoreWork with the application model in ASP.NET Core

Von Steve SmithBy Steve Smith

ASP.NET Core MVC definiert ein Anwendungsmodell, in dem die Komponenten einer MVC-App dargestellt werden.ASP.NET Core MVC defines an application model representing the components of an MVC app. Sie können dieses Modell lesen und bearbeiten, um die Verhaltensweise von MVC-Elementen zu ändern.You can read and manipulate this model to modify how MVC elements behave. MVC folgt standardmäßig bestimmten Konventionen, um zu ermitteln, welche Klassen als Controller betrachtet werden, welche Methoden in diesen Klassen Aktionen darstellen und wie sich Parameter und das Routing verhalten.By default, MVC follows certain conventions to determine which classes are considered to be controllers, which methods on those classes are actions, and how parameters and routing behave. Sie können dieses Verhalten an die Anforderungen Ihrer App anpassen, indem Sie Ihre eigenen Konventionen schaffen und diese global oder in Form von Attributen anwenden.You can customize this behavior to suit your app's needs by creating your own conventions and applying them globally or as attributes.

Modelle und AnbieterModels and Providers

Das ASP.NET Core-MVC-Anwendungsmodell enthält abstrakte Schnittstellen und konkrete Implementierungsklassen, die eine MVC-Anwendung beschreiben.The ASP.NET Core MVC application model include both abstract interfaces and concrete implementation classes that describe an MVC application. Dieses Modell resultiert aus der MVC-Ermittlung von Controllern, Aktionen, Aktionsparametern, Routen und Filtern der App gemäß den Standardkonventionen.This model is the result of MVC discovering the app's controllers, actions, action parameters, routes, and filters according to default conventions. Wenn Sie mit dem Anwendungsmodell arbeiten, können Sie Ihre App so ändern, dass sie verschiedenen Konventionen des MVC-Standardverhaltens folgt.By working with the application model, you can modify your app to follow different conventions from the default MVC behavior. Die Parameter, Namen, Routen und Filter werden alle als Konfigurationsdaten für Aktionen und Controller verwendet.The parameters, names, routes, and filters are all used as configuration data for actions and controllers.

Das ASP.NET Core-MVC-Anwendungsmodell weist folgende Struktur auf:The ASP.NET Core MVC Application Model has the following structure:

  • ApplicationModelApplicationModel
    • Controller (ControllerModel)Controllers (ControllerModel)
      • Aktionen (ActionModel)Actions (ActionModel)
        • Parameter (ParameterModel)Parameters (ParameterModel)

Jede Modellebenen kann auf eine allgemeine Properties-Sammlung zugreifen. Zudem ist auf niedrigeren Ebenen der Zugriff auf Eigenschaftswerte sowie die Überschreibung von Eigenschaftswerten möglich, die auf höheren Ebenen in der Hierarchie festgelegt wurden.Each level of the model has access to a common Properties collection, and lower levels can access and overwrite property values set by higher levels in the hierarchy. Die Eigenschaften werden bei der Erstellung der Aktionen in der Datei ActionDescriptor.Properties permanent gespeichert.The properties are persisted to the ActionDescriptor.Properties when the actions are created. Wenn eine Anforderung dann verarbeitet wird, kann über ActionContext.ActionDescriptor.Properties auf sämtliche Eigenschaften zugegriffen werden, die über eine Konvention hinzugefügt oder geändert wurden.Then when a request is being handled, any properties a convention added or modified can be accessed through ActionContext.ActionDescriptor.Properties. Die Verwendung von Eigenschaften stellt eine gute Möglichkeit zur Konfiguration Ihrer Filter, Modellbindungen usw. auf Grundlage einer Aktion dar.Using properties is a great way to configure your filters, model binders, etc. on a per-action basis.

Hinweis

Nachdem die App gestartet wurde, ist die ActionDescriptor.Properties-Sammlung nicht threadsicher (bei Schreibvorgängen).The ActionDescriptor.Properties collection isn't thread safe (for writes) once app startup has finished. Konventionen stellen die beste Möglichkeit zum sicheren Hinzufügen von Daten zu dieser Sammlung dar.Conventions are the best way to safely add data to this collection.

IApplicationModelProviderIApplicationModelProvider

ASP.NET Core MVC lädt das Anwendungsmodell über ein durch die Schnittstelle IApplicationModelProvider definiertes Anbietermuster.ASP.NET Core MVC loads the application model using a provider pattern, defined by the IApplicationModelProvider interface. Dieser Abschnitt enthält einige interne Implementierungsdetails zur Funktionsweise dieses Anbieters.This section covers some of the internal implementation details of how this provider functions. Dies ist allerdings ein Thema für Fortgeschrittene. In den meisten Apps, die das Anwendungsmodell nutzen, sollte mit Konventionen gearbeitet werden.This is an advanced topic - most apps that leverage the application model should do so by working with conventions.

Implementierungen der Schnittstelle IApplicationModelProvider umschließen sich gegenseitig. Dabei wird bei den einzelnen Implementierungen die Methode OnProvidersExecuting in aufsteigender Reihenfolge basierend auf der zugehörigen Eigenschaft Order aufgerufen.Implementations of the IApplicationModelProvider interface "wrap" one another, with each implementation calling OnProvidersExecuting in ascending order based on its Order property. Anschließend wird die Methode OnProvidersExecuted in umgekehrter Reihenfolge aufgerufen.The OnProvidersExecuted method is then called in reverse order. Das Framework definiert verschiedene Anbieter:The framework defines several providers:

Erst (Order=-1000):First (Order=-1000):

Then (Order=-990):Then (Order=-990):

Hinweis

Die Reihenfolge, in der zwei Anbieter mit dem gleichen Wert für Order aufgerufen werden, ist nicht definiert und sollte daher nicht als zuverlässig betrachtet werden.The order in which two providers with the same value for Order are called is undefined, and therefore shouldn't be relied upon.

Hinweis

IApplicationModelProvider ist ein erweitertes, auszuweitendes Konzept für Autoren von Frameworks.IApplicationModelProvider is an advanced concept for framework authors to extend. Im Allgemeinen sollten in Apps Konventionen und in Frameworks Anbieter verwendet werden.In general, apps should use conventions and frameworks should use providers. Der Hauptunterschied besteht darin, dass Anbieter immer vor Konventionen ausgeführt werden.The key distinction is that providers always run before conventions.

Das Konzept DefaultApplicationModelProvider etabliert viele der von ASP.NET Core MVC verwendeten Standardverhaltensweisen.The DefaultApplicationModelProvider establishes many of the default behaviors used by ASP.NET Core MVC. Zu den Zuständigkeiten des Konzepts zählen die folgenden:Its responsibilities include:

  • Hinzufügen globaler Filter zum KontextAdding global filters to the context
  • Hinzufügen von Controllern zum KontextAdding controllers to the context
  • Hinzufügen öffentlicher Controllermethoden in Form von AktionenAdding public controller methods as actions
  • Hinzufügen von Aktionsmethodenparametern zum KontextAdding action method parameters to the context
  • Anwenden einer Route und anderer AttributeApplying route and other attributes

Einige integrierte Verhaltensweisen werden vom DefaultApplicationModelProvider implementiert.Some built-in behaviors are implemented by the DefaultApplicationModelProvider. Dieser Anbieter ist für das Erstellen von zuständig ControllerModel , das wiederum auf ActionModel PropertyModel -,-und-Instanzen verweist ParameterModel .This provider is responsible for constructing the ControllerModel, which in turn references ActionModel, PropertyModel, and ParameterModel instances. Die DefaultApplicationModelProvider-Klasse stellt ein Detail zur Implementierung des internen Frameworks dar und wird sich in Zukunft ändern.The DefaultApplicationModelProvider class is an internal framework implementation detail that can and will change in the future.

AuthorizationApplicationModelProvider ist für die Anwendung des Verhaltens zuständig, das den Attributen AuthorizeFilter und AllowAnonymousFilter zugeordnet ist.The AuthorizationApplicationModelProvider is responsible for applying the behavior associated with the AuthorizeFilter and AllowAnonymousFilter attributes. Weitere Informationen zu diesen Attributen.Learn more about these attributes.

CorsApplicationModelProvider implementiert Verhalten, das dem IEnableCorsAttribute und IDisableCorsAttribute sowie dem DisableCorsAuthorizationFilter zugeordnet ist.The CorsApplicationModelProvider implements behavior associated with the IEnableCorsAttribute and IDisableCorsAttribute, and the DisableCorsAuthorizationFilter. Weitere Informationen zu CORS.Learn more about CORS.

KonventionenConventions

Das Anwendungsmodell definiert Konventionsabstraktionen, die eine einfachere Möglichkeit zur Anpassung des Verhaltens der Modelle bieten, wodurch auf eine Überschreibung des gesamten Modells oder Anbieters verzichtet werden kann.The application model defines convention abstractions that provide a simpler way to customize the behavior of the models than overriding the entire model or provider. Diese Abstraktionen werden als Methode für eine Änderung des Verhaltens Ihrer App empfohlen.These abstractions are the recommended way to modify your app's behavior. Mithilfe von Konventionen können Sie Code schreiben, der Anpassungen dynamisch anwendet.Conventions provide a way for you to write code that will dynamically apply customizations. Während Filter eine Möglichkeit zum Ändern des Frameworkverhaltens bieten, können Sie mithilfe von Anpassungen steuern, wie die einzelnen Komponenten der App zusammenarbeiten.While filters provide a means of modifying the framework's behavior, customizations let you control how the whole app works together.

Folgende Konventionen sind verfügbar:The following conventions are available:

Konventionen werden angewendet, indem Sie den MVC-Optionen hinzugefügt werden, oder indem Sie Attribute s implementieren und auf Controller, Aktionen oder Aktionsparameter anwenden (ähnlich wie Filters ).Conventions are applied by adding them to MVC options or by implementing Attributes and applying them to controllers, actions, or action parameters (similar to Filters). Im Gegenteil zu Filtern werden Konventionen nur beim Starten der App ausgeführt, nicht im Rahmen einzelner Anforderungen.Unlike filters, conventions are only executed when the app is starting, not as part of each request.

Beispiel: Ändern von ApplicationModelSample: Modifying the ApplicationModel

Die folgende Konvention wird zum Hinzufügen einer Eigenschaft zum Anwendungsmodell verwendet.The following convention is used to add a property to the application model.

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;
        }
    }
}

Konventionen von Anwendungsmodellen werden als Optionen angewendet, wenn MVC in ConfigureServices zu Startup hinzugefügt wird.Application model conventions are applied as options when MVC is added in ConfigureServices in Startup.

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

Auf Eigenschaften kann innerhalb von Controlleraktionen über die ActionDescriptor-Eigenschaftensammlung zugegriffen werden:Properties are accessible from the ActionDescriptor properties collection within controller actions:

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

Beispiel: Ändern der ControllerModel-BeschreibungSample: Modifying the ControllerModel Description

Wie im vorherigen Beispiel kann auch das Controllermodell so geändert werden, dass es benutzerdefinierte Eigenschaften enthält.As in the previous example, the controller model can also be modified to include custom properties. Diese Eigenschaften überschreiben vorhandene Eigenschaften mit dem gleichen Namen, die im Anwendungsmodell angegeben sind.These will override existing properties with the same name specified in the application model. Das folgende Konventionsattribut fügt eine Beschreibung auf Controllerebene hinzu:The following convention attribute adds a description at the controller level:

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;
        }
    }
}

Diese Konvention wird als Attribut für einen Controller angewendet.This convention is applied as an attribute on a controller.

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

Auf die Eigenschaft „Beschreibung“ wird auf die gleiche Weise wie in vorherigen Beispielen zugegriffen.The "description" property is accessed in the same manner as in previous examples.

Beispiel: Ändern der ActionModel-BeschreibungSample: Modifying the ActionModel Description

Auf einzelne Aktionen kann eine separate Attributkonvention angewendet werden, mit der das bereits auf Anwendungs- oder Controllerebene angewendete Verhalten überschrieben wird.A separate attribute convention can be applied to individual actions, overriding behavior already applied at the application or controller level.

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;
        }
    }
}

Eine Anwendung dieser Konvention auf eine Aktion innerhalb des Controllers aus dem vorherigen Beispiel veranschaulicht, wie die Konvention auf Controllerebene überschrieben wird:Applying this to an action within the previous example's controller demonstrates how it overrides the controller-level convention:

[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"];
    }
}

Beispiel: Ändern von ParameterModelSample: Modifying the ParameterModel

Die folgende Konvention kann auf Aktionsparameter zur Änderung ihrer BindingInfo angewendet werden.The following convention can be applied to action parameters to modify their BindingInfo. Für folgende Konvention ist erforderlich, dass es sich bei dem Parameter um einen Routenparameter handelt; andere mögliche Bindungsquellen (z.B. Abfragezeichenfolgewerte) werden ignoriert.The following convention requires that the parameter be a route parameter; other potential binding sources (such as query string values) are ignored.

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;
        }
    }
}

Das Attribut kann möglicherweise auf sämtliche Aktionsparameter angewendet werden:The attribute may be applied to any action parameter:

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}";
    }
}

Beispiel: Ändern des ActionModel-NamensSample: Modifying the ActionModel Name

Folgende Konvention ändert das ActionModel, um den Namen der Aktion zu aktualisieren, auf die sie angewendet wird.The following convention modifies the ActionModel to update the name of the action to which it's applied. Der neue Name wird als Parameter für das Attribut bereitgestellt.The new name is provided as a parameter to the attribute. Er wird beim Routing verwendet und beeinflusst die Route, die zum Erreichen dieser Aktionsmethode verwendet wird.This new name is used by routing, so it will affect the route used to reach this action method.

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;
        }
    }
}

Dieses Attribut wird auf eine Aktionsmethode im HomeController angewendet:This attribute is applied to an action method in the HomeController:

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

Obwohl der Methodenname SomeName lautet, überschreibt das Attribut die MVC-Konvention für die Verwendung des Methodennamens und ersetzt den Aktionsnamen durch MyCoolAction.Even though the method name is SomeName, the attribute overrides the MVC convention of using the method name and replaces the action name with MyCoolAction. Daher lautet die Route zum Erreichen dieser Aktion /Home/MyCoolAction.Thus, the route used to reach this action is /Home/MyCoolAction.

Hinweis

Dieses Beispiel ist im Wesentlichen mit der Verwendung des integrierten Attributs ActionName identisch.This example is essentially the same as using the built-in ActionName attribute.

Beispiel: Benutzerdefinierte RoutingkonventionSample: Custom Routing Convention

Sie können die Funktionsweise von Routing mithilfe einer IApplicationModelConvention anpassen.You can use an IApplicationModelConvention to customize how routing works. Die folgende Konvention bezieht beispielsweise Namespaces von Controllern in ihre Routen ein und ersetzt dabei in der Route . im Namespace durch /:For example, the following convention will incorporate Controllers' namespaces into their routes, replacing . in the namespace with / in the route:

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
        }
    }
}

Die Konvention wird als Option unter „Start“ hinzugefügt.The convention is added as an option in Startup.

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

Tipp

Sie können Konventionen zu Ihrer Middleware hinzufügen, indem Sie über services.Configure<MvcOptions>(c => c.Conventions.Add(YOURCONVENTION)); auf MvcOptions zugreifen.You can add conventions to your middleware by accessing MvcOptions using services.Configure<MvcOptions>(c => c.Conventions.Add(YOURCONVENTION));

Im nachfolgenden Beispiel wird diese Konvention auf Routen angewendet, die kein Attributrouting verwenden, bei dem der Name des Controllers „Namespace“ enthält.This sample applies this convention to routes that are not using attribute routing where the controller has "Namespace" in its name. Der folgende Controller veranschaulicht diese Konvention:The following controller demonstrates this convention:

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.";
        }
    }
}

Verwendung eines Anwendungsmodells in WebApiCompatShimApplication Model Usage in WebApiCompatShim

ASP.NET Core MVC verwendet andere Konventionen aus ASP.NET-Web-API 2.ASP.NET Core MVC uses a different set of conventions from ASP.NET Web API 2. Mithilfe von benutzerdefinierten Konventionen können Sie das Verhalten einer ASP.NET Core-MVC-App so ändern, dass es mit dem einer Web-API-App konsistent ist.Using custom conventions, you can modify an ASP.NET Core MVC app's behavior to be consistent with that of a Web API app. Microsoft liefert die WebApiCompatShim speziell für diesen Zweck aus.Microsoft ships the WebApiCompatShim specifically for this purpose.

Hinweis

Hier finden Sie weitere Informationen zum Migrieren der ASP.NET-Web-API.Learn more about migration from ASP.NET Web API.

Für die Verwendung der Web-API-Kompatibilitätsshim müssen Sie das Paket zu Ihrem Projekt und anschließend die Konventionen zu MVC hinzufügen, indem Sie AddWebApiConventionsunter Startup aufrufen:To use the Web API Compatibility Shim, you need to add the package to your project and then add the conventions to MVC by calling AddWebApiConventions in Startup:

services.AddMvc().AddWebApiConventions();

Die von der Shim bereitgestellten Konventionen gelten nur für Teile der App, auf die bestimmte Attribute angewendet worden sind.The conventions provided by the shim are only applied to parts of the app that have had certain attributes applied to them. Die folgenden vier Attribute steuern, bei welchen Controllern die zugehörigen Konventionen durch die Konventionen der Shim geändert werden sollten:The following four attributes are used to control which controllers should have their conventions modified by the shim's conventions:

AktionskonventionenAction Conventions

Das UseWebApiActionConventionsAttribute wird für die Zuordnung der HTTP-Methode zu Aktionen basierend auf ihrem Namen verwendet (beispielsweise würde Get der Aktion HttpGet zugeordnet).The UseWebApiActionConventionsAttribute is used to map the HTTP method to actions based on their name (for instance, Get would map to HttpGet). Es gilt nur für Aktionen, die kein Attributrouting verwenden.It only applies to actions that don't use attribute routing.

ÜberladenOverloading

Das UseWebApiOverloadingAttribute wird für die Anwendung der Konvention WebApiOverloadingApplicationModelConvention verwendet.The UseWebApiOverloadingAttribute is used to apply the WebApiOverloadingApplicationModelConvention convention. Diese Konvention fügt eine OverloadActionConstraint zum Aktionsauswahlprozess hinzu, wodurch mögliche Aktionen auf die Aktionen begrenzt werden, bei denen die Anforderung alle nicht optionalen Parameter erfüllt.This convention adds an OverloadActionConstraint to the action selection process, which limits candidate actions to those for which the request satisfies all non-optional parameters.

ParameterkonventionenParameter Conventions

Das UseWebApiParameterConventionsAttribute wird für die Anwendung der Aktionskonvention WebApiParameterConventionsApplicationModelConvention verwendet.The UseWebApiParameterConventionsAttribute is used to apply the WebApiParameterConventionsApplicationModelConvention action convention. Diese Konvention gibt an, dass einfache Typen, die als Aktionsparameter verwendet werden, standardmäßig vom URI abhängen, während komplexe Typen vom Anforderungstext abhängen.This convention specifies that simple types used as action parameters are bound from the URI by default, while complex types are bound from the request body.

RoutenRoutes

Das UseWebApiRoutesAttribute steuert, ob die Controllerkonvention WebApiApplicationModelConvention angewendet wird.The UseWebApiRoutesAttribute controls whether the WebApiApplicationModelConvention controller convention is applied. Bei Aktivierung wird diese Konvention verwendet, um Unterstützung für Bereiche zur Route hinzuzufügen.When enabled, this convention is used to add support for areas to the route.

Neben einer Reihe von Konventionen enthält das Kompatibilitätspaket eine System.Web.Http.ApiController-Basisklasse, welche die von der Web-API bereitgestellte Klasse ersetzt.In addition to a set of conventions, the compatibility package includes a System.Web.Http.ApiController base class that replaces the one provided by Web API. Dadurch funktionieren Ihre Controller, die für die Web-API geschrieben wurden und von dem zugehörigen ApiController übernommen werden, bei der Ausführung im ASP.NET Core-MVC so, wie sie entwickelt wurden.This allows your controllers written for Web API and inheriting from its ApiController to work as they were designed, while running on ASP.NET Core MVC. Alle oben aufgeführten UseWebApi*-Attribute werden auf die Basiscontrollerklasse angewendet.All of the UseWebApi* attributes listed earlier are applied to the base controller class. Der ApiController macht Eigenschaften, Methoden und Ergebnistypen verfügbar, die mit denen in der Web-API kompatibel sind.The ApiController exposes properties, methods, and result types that are compatible with those found in Web API.

Verwenden von ApiExplorer zum Dokumentieren Ihrer AppUsing ApiExplorer to Document Your App

Das Anwendungsmodell macht eine ApiExplorer -Eigenschaft auf jeder Ebene verfügbar, die zum Durchlaufen der Struktur der APP verwendet werden kann.The application model exposes an ApiExplorer property at each level that can be used to traverse the app's structure. Diese kann zum Generieren von Hilfeseiten für Ihre Web-APIs mithilfe von Tools wie Swagger verwendet werden.This can be used to generate help pages for your Web APIs using tools like Swagger. Die Eigenschaft ApiExplorer macht eine Eigenschaft vom Typ IsVisible verfügbar, die festgelegt werden kann, um anzugeben, welche Teile des Modells Ihrer App verfügbar gemacht werden sollten.The ApiExplorer property exposes an IsVisible property that can be set to specify which parts of your app's model should be exposed. Sie können diese Einstellung mithilfe einer Konvention konfigurieren:You can configure this setting using a convention:

using Microsoft.AspNetCore.Mvc.ApplicationModels;

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

Mit diesem Ansatz (und ggf. zusätzlichen Konventionen) können Sie die API-Sichtbarkeit auf einer beliebigen Ebene innerhalb Ihrer App aktivieren oder deaktivieren.Using this approach (and additional conventions if required), you can enable or disable API visibility at any level within your app.