Différence entre ApiController et Controller dans ASP.NET MVC

J'ai joué avec ASP.NET MVC 4 beta et je vois maintenant deux types de contrôleurs: ApiControlleret Controller.

Je suis peu confus dans quelles situations je peux choisir un contrôleur particulier.

Par exemple: si je veux retourner une vue alors je dois utiliser ApiControllerou l'ordinaire Controller? Je suis conscient que l'API Web WCF est désormais intégrée à MVC.

Depuis maintenant, nous pouvons utiliser les deux contrôleurs. Quelqu'un peut-il indiquer les situations à adopter pour le contrôleur correspondant.

Utilisez Controller pour rendre vos vues normales. L'action ApiController renvoie uniquement les données sérialisées et envoyées au client.

Voici le lien

Citation:

Remarque Si vous avez travaillé avec ASP.NET MVC, vous connaissez déjà les contrôleurs. Ils fonctionnent de manière similaire dans l'API Web, mais les contrôleurs dans l'API Web dérivent de la classe ApiController au lieu de la classe Controller. La première différence majeure que vous remarquerez est que les actions sur les contrôleurs d'API Web ne renvoient pas de vues, elles renvoient des données.

Les ApiControllers sont spécialisés dans le retour de données. Par exemple, ils prennent en charge la sérialisation transparente des données dans le format demandé par le client. En outre, ils suivent un schéma de routage différent par défaut (comme dans: mappage des URL aux actions), fournissant une API REST par convention.

Vous pourriez probablement faire n'importe quoi en utilisant un contrôleur au lieu d'un ApiController avec le codage manuel (?). En fin de compte, les deux contrôleurs s'appuient sur la fondation ASP.NET. Mais avoir une API REST-ful est une exigence tellement courante aujourd'hui que WebAPI a été créé pour simplifier la mise en œuvre d'une telle API.

Il est assez simple de décider entre les deux: si vous écrivez une application Web / Internet / Intranet basée sur HTML - peut-être avec l'appel AJAX occasionnel renvoyant json ici et là - restez avec MVC / Controller. Si vous souhaitez fournir une interface pilotée par les données / REST à un système, optez pour WebAPI. Bien sûr, vous pouvez combiner les deux en ayant un ApiController pour répondre aux appels AJAX à partir d'une page MVC.

Pour donner un exemple concret: je travaille actuellement avec un système ERP qui fournit une API REST-ful à ses entités. Pour cette API, WebAPI serait un bon candidat. Dans le même temps, le système ERP fournit une application Web hautement AJAX que vous pouvez utiliser pour créer des requêtes pour l'API REST-ful. L'application Web elle-même pourrait être implémentée en tant qu'application MVC, en utilisant WebAPI pour récupérer des métadonnées, etc.

Que préférez-vous écrire et conserver?

ASP.NET MVC

public class TweetsController : Controller {
  // GET: /Tweets/
  [HttpGet]
  public ActionResult Index() {
    return Json(Twitter.GetTweets(), JsonRequestBehavior.AllowGet);
  }
}

API Web ASP.NET

public class TweetsController : ApiController {
  // GET: /Api/Tweets/
  public List<Tweet> Get() {
    return Twitter.GetTweets();
  }
}

J'adore le fait que le MVC6 d'ASP.NET Core a fusionné les deux modèles en un, car j'ai souvent besoin de prendre en charge les deux mondes. Bien qu'il soit vrai que vous pouvez modifier n'importe quel MVC standard Controller(et / ou développer vos propres ActionResultclasses) pour agir et se comporter comme un an ApiController, il peut être très difficile à maintenir et à tester: en plus de cela, avoir des méthodes de Contrôleurs retournant ActionResultmélangées avec d'autres le retour de données brutes / sérialisées / IHttpActionResultpeut être très déroutant du point de vue du développeur, en particulier si vous ne travaillez pas seul et que vous avez besoin d'accélérer d'autres développeurs avec cette approche hybride.

La meilleure technique que j'ai trouvée jusqu'à présent pour minimiser ce problème dans les applications Web non Core ASP.NET consiste à importer (et à configurer correctement) le package d'API Web dans l'application Web basée sur MVC, afin que je puisse avoir le meilleur des deux. mondes: Controllerspour les vues, ApiControllerspour les données.

Pour ce faire, vous devez procéder comme suit:

• Installez les packages d'API Web suivants à l'aide de NuGet: Microsoft.AspNet.WebApi.Coreet Microsoft.AspNet.WebApi.WebHost.
• Ajoutez un ou plusieurs ApiControllers à votre /Controllers/dossier.
• Ajoutez le fichier WebApiConfig.cs suivant à votre /App_Config/dossier:

using System.Web.Http;

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // Web API routes
        config.MapHttpAttributeRoutes();

        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
    }
}

Enfin, vous devrez enregistrer la classe ci-dessus dans votre classe de démarrage (soit Startup.csou Global.asax.cs, selon que vous utilisez le modèle de démarrage OWIN ou non).

Startup.cs

 public void Configuration(IAppBuilder app)
 {
    // Register Web API routing support before anything else
    GlobalConfiguration.Configure(WebApiConfig.Register);

    // The rest of your file goes there
    // ...
    AreaRegistration.RegisterAllAreas();
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);

    ConfigureAuth(app);
    // ...
}

Global.asax.cs

protected void Application_Start()
{
    // Register Web API routing support before anything else
    GlobalConfiguration.Configure(WebApiConfig.Register);

    // The rest of your file goes there
    // ...
    AreaRegistration.RegisterAllAreas();
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
    // ...
}

Cette approche - avec ses avantages et ses inconvénients - est expliquée plus en détail dans cet article que j'ai écrit sur mon blog.

Chaque méthode de l'API Web renvoie des données (JSON) sans sérialisation.

Cependant, afin de renvoyer les données JSON dans les contrôleurs MVC, nous allons définir le type de résultat d'action renvoyé sur JsonResult et appeler la méthode Json sur notre objet pour nous assurer qu'il est conditionné dans JSON.

La principale différence est la suivante: l'API Web est un service pour tout client, tout appareil et MVC Controller ne sert que son client. De même car il s'agit de la plateforme MVC.

Il est assez simple de décider entre les deux: si vous écrivez une application Web / Internet / Intranet basée sur HTML - peut-être avec l'appel AJAX occasionnel renvoyant json ici et là - restez avec MVC / Controller. Si vous souhaitez fournir une interface pilotée par les données / REST à un système, optez pour WebAPI. Bien sûr, vous pouvez combiner les deux en ayant un ApiController pour répondre aux appels AJAX à partir d'une page MVC. Fondamentalement, le contrôleur est utilisé pour mvc et api-controller est utilisé pour Rest-API, vous pouvez utiliser les deux dans le même programme que votre besoin