Le Web évolue rapidement, et Microsoft est conscient de cela. L’éditeur a ainsi adopté un cycle de mise à jour pour ASP.NET plus rapide que celui de Visual Studio.

La société compte donc publier une mise à jour pour sa plateforme de développement Web ASP.NET en début d’année prochaine.

Les développeurs qui veulent commencer à « jouer » avec les nouvelles fonctionnalités de cette mise à jour peuvent déjà télécharger sa version Release Candidate (RC) qui vient d’être publiée par les équipes ASP.NET et Visual Web Developer de Microsoft.

« ASP.NET et Web Tools 2012.2 » RC étend le runtine ASP.NET existant et ajout de nouveaux outils Web à Visual Studio 2012 pour WebForms, MVC, WebAPI, etc. Il s’agit des fonctionnalités suivantes :

1. De nouveaux modèles de projets ASP.NET MVC. la création d’applications Facebook est désormais plus facile avec le modèle Facebook, qui permet en quelques étapes de créer une application qui interagir avec le réseau social. Le nouveau modèle « Single Page Application » permet aux développeurs de créer des applications Web interactives côté client à l’aide de jQuery, Knockout et ASP.NET Web API ;
2. Le support de la communication en temps réel avec ASP.NET SignalR. SignalR est une bibliothèque client/serveur qui permet aux clients basés sur un navigateur et aux composants serveur basés sur ASP.NET d’avoir une conversation à étapes multiples et bidirectionnelle;
3. Le support de l’IntelliSense pour Knockout et l’ajout de la prise en charge de JSON en tant que classe ;
4. L’introduction de nouvelles fonctionnalités pour ASP.NET Web API, y compris le support d’OData, l’ajout des fonctions de traçabilité, de monitoring et de génération d’une page d’aide pour une API Web;
5. Des améliorations de l’inspecteur de page, qui offre désormais de meilleures performances pour JavaScript et CSS, dont la capacité de voir les mises à jour en temps réel d’un fichier CSS ;
6. L’unification de l’expérience de publication pour une application Web et un projet de type site Web, ainsi que l’ajout des options de publication sélective ;
7. L’intégration de la nouvelle fonctionnalité ASP.NET Friendly URL. Cette fonction rend facile la génération des URL sans l’extension .aspx. Elle permet également au développeur d’ajouter plus facilement le support du mobile dans son application Web ;
8. La mise à jour des modèles de projets Web dans Visual Studio 2012.

Cette mise à jour est livrée comme des packages NuGet supplémentaires. Ce qui signifie qu’il ne peut avoir aucun problème de compatibilité avec les projets existants.

Télécharger « ASP.NET et Web Tools 2012.2″ RC

Dans ce article, nous avons créer une première API et consommer celle-ci dans une page Web en utilisant jQuery. Dans ce billet de blog, je vais vous montrer comment vous pouvez interagir avec votre API dans une application native en utilisant HttpClient.

Dans une application Web, vous pouvez simplement interagir avec une API Web coté client en appelant les requêtes HTTP Get, Put, Post et Delete dans un Script JavaScript ou en utilisant jQuery. Mais, si vous voulez accéder à votre API à partir d’une application Desktop par exemple, comment procéder ?

C’est à ce niveau qu’intervient HTTPClient. HTTPClient est un client moderne HTTP pour les applications .NET. Il peut être utilisé pour consommer avec souplesse et simplicité les fonctionnalités exposées via HTTP. Vous pouvez utiliser HTTPClient pour mettre en œuvre des interactions avec une API Web en envoyant et en recevant des réponses à partir des verbes standards Get, Put, Post et Delete de HTTP grâce aux méthodes GetAsync, PutAsync, PostAsync, DeleteAsync.

L’exemple ci-dessous illustre comment vous pouvez consommer les données au format XML d’une API Web en utilisant la méthode GetAsync.

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
var response = client.GetAsync("http://localhost:59130/api/Customer").Result;

Si vous souhaitez que les données soient retournées au format XML, vous pouvez procéder comme suit :

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.GetAsync("http://localhost:59130/api/Customer").Result;

La procédure client.DefaultRequestHeaders.Accept.Add() permet de définir le format qui sera utilisé pour sérialiser les données.

La procédure asynchrone GetAsync() de la classe HttpClient() prend en paramètre une URI ou une chaine de caractères qui représente l’URL de l’API Web. GetAsync effectue une requête HTTP GET en utilisant l’URL passée en paramètre, puis retourne directement une tache dont la propriété Result (Task.Result) contient la réponse HTTP (HttpResponseMessage).

NB : Il est recommandé lors de l’utilisation d’une méthode asynchrone d’utiliser également le mot clé await pour éviter que l’application ne soit bloquée jusqu’à ce que l’opération soit complète. On peut s’en passer pour une application console, mais pour une solution Desktop, faudra penser à utiliser await pour éviter le blocage de l’interface utilisateur. Pour plus de détails sur async et await, je vous invite à lire cet excellent article sur le sujet : les nouveautés de C# 5.0.

A titre d’exemple, vous allez créer une application console qui consomme l’API que vous avez créée ci-dessus. Cliquez sur le menu « FICHIER », sélectionnez « Ajouter » puis « Nouveau projet ». Sélectionnez le projet « Application Console » et donnez-lui le nom « TestFirstWebAPI ».

Après création du projet, vous allez ajouter une référence à HTTPClient. HTTPClient n’étant pas disponible par défaut dans le Framework .NET ou avec ASP.NET MVC 4, vous devez passer par le gestionnaire de packages NuGet pour ajouter cette dépendance à votre application.

Faites un clic droit sur votre projet dans l’explorateur de solution et sélectionnez la commande « Gérer les packages NuGet… ». Lorsque l’interface de NuGet va s’afficher, recherchez le package HTTPClient.

L’installation du package va entrainer l’installation des dépendances System.Net.Http et System.Json que vous allez utiliser dans votre application.

Ajoutez une classe dans votre projet ayant la même définition que la classe Customer dans le projet ASP.NET MVC. Pour rappel, cette classe doit avoir la définition suivante :

public class Customer
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string EMail { get; set; }
    }

Ajoutez par la suite une référence à System.Net.Http.Formatting et System.Net.Http.Headers.

using System.Net.Http.Formatting;
using System.Net.Http.Headers;

Vous allez maintenant ajouter les lignes de code suivantes à la fonction Main de votre application.

HttpClient client = new HttpClient();


client.DefaultRequestHeaders.Accept.Add(
     new MediaTypeWithQualityHeaderValue("application/json"));

 var response = client.GetAsync("http://localhost:59130/api/customer").Result;  

 if (response.IsSuccessStatusCode)
 {
     
     var Customers = response.Content.ReadAsAsync<IEnumerable<Customer>>().Result;
     foreach (var c in Customers)
     {
         Console.WriteLine("{0}\t{1}\t{2}", c.FirstName, c.LastName, c.EMail);
        
     }
 }
 else
 {
     Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
 }
     Console.ReadLine();

La procédure ReadAsAsync() lit et déserialise automatiquement le corps de la réponse HTTP qui contient la liste des clients.

En appuyant sur F5 pour lancer le débogage de votre application, vous allez obtenir le résultat suivant :

Rassurez vous que vous utilisez un numéro de port spécifique pour votre application (59130 pour mon cas). Vous pouvez vérifier cela dans les propriétés du projet, onglet Web :

Vous avez le choix entre utiliser un numéro de port spécifique ou utiliser le serveur Web IIS local si vous en avez. Dans ces cas, le numéro de port ne varie que si vous décidez de le modifier.

Dans mon précédent billet de blog sur WebAPI, j’ai décrit comment utiliser WebAPi dans une application ASP.NET MVC. Mais, il est également possible de l’utiliser dans une application ASP.NET WebForms.

Je vais montrer dans cet article comment utiliser simplement WebAPI dans une application ASP.NET. Dès lors que vous avez installé ASP.NET MVC 4 beta, vous pouvez dans n’importe quel projet (Application Web, Site Web) ajouter un contrôleur WebAPI. Celui-ci va automatiquement intégrer dans votre solution toutes les références nécessaires pour WebAPI.

Pour illustrer cela, vous allez créer une nouvelle application Web ASP.NET. Vous devez au préalable avoir installé ASP.NET MVC 4 beta.

Dans l’application, vous allez ajouter un dossier App_Code. Ensuite, vous allez créer la classe Web API Controller dans ce dossier en faisant un clic droit sur celui-ci, puis en sélectionnant Add, et ensuite New Item :

Dans la fenêtre de sélection du Template, vous verrez un nouveau Template « Web API Controller Class ». Sélectionnez celui-ci, et renommez le fichier en vous assurant que le nom s’achève par « Controller ». Puis cliquez sur « Add » :

Un nouveau contrôleur Web API qui hérite de ApiController sera créé dans le dossier App_code avec des lignes de code par défaut illustrant comment vous pouvez créer des requêtes Get(), Post(), Put() et Delete() pour votre API.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http;

namespace WebApplication1.App_Code.Controllers
{
    public class ValuesController : ApiController
    {
        // GET /api/<controller>
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET /api/<controller>/5
        public string Get(int id)
        {
            return "value";
        }

        // POST /api/<controller>
        public void Post(string value)
        {
        }

        // PUT /api/<controller>/5
        public void Put(int id, string value)
        {
        }

        // DELETE /api/<controller>/5
        public void Delete(int id)
        {
        }
    }
}

Pour ce billet, on se limitera uniquement à l’utilisation du code généré.

Exposer les fonctionnalités de l’API

Vous allez maintenant définir une route pour WebAPI afin de pouvoir exposer les fonctionnalités de votre API.

Pour cela, vous allez ajouter les lignes de suivantes dans la méthode Application-Start du fichier Global.ascx.cs.

void Application_Start(object sender, EventArgs e)
        {
            // Code that runs on application startup
            RouteTable.Routes.MapHttpRoute(
            name: "DefaultApi",
              routeTemplate: "api/{controller}/{id}",
              defaults: new { id = System.Web.Http.RouteParameter.Optional }
          );

        }

Vous devez également ajouter une référence à System.Web.Routing et System.Web.Http

Consommer l’API

Voyons maintenant comment vous pouvez consommer L’API créée. Il est possible d’appeler votre service en utilisant JavaScript, Ajax ou HttpClient.

Le script ci-dessous permet d’appeler le verbe Get pour lire les données en utilisant JavaScript.

<script type="text/javascript">
    $(document).ready(function () {
        // Envoi de la requête Ajax
          $.getJSON("api/values/",
             function (data) {
                // En cas de succès, 'data' contient la liste des clients.
                   $.each(data, function (key, val) {
                    var str = val;
                    $('<li/>', { html: str }).appendTo($('#getvalues'));
                });
            });
    });
</script>

Les lignes ci-dessous seront utilisées pour afficher les informations retournées.

<h1>GET VALUES</h1>
<ul id='getvalues' />

A l’exécution, vous allez obtenir le résultat suivant :

Nb : Si vous ne disposez pas d’ASP.NET MVC 4 beta, vous pouvez télécharger et installer séparément le package ASP.NET Web API via le gestionnaire de packages NuGet.

Aujourd’hui, je vais revenir sur l’une de ces nouveautés les plus importantes à savoir : Web API. ASP.NET Web API a pour objectif principal de permettre aux développeurs d’exposer leurs applications, données et services sur le web directement à travers HTTP.

Le support d’ASP.NET Web API permet de créer facilement des API Web puissantes, qui peuvent être consultées à partir d’un large éventail de client (réseaux sociaux, navigateurs, terminaux mobiles, etc.). Web API fournit les fonctionnalités suivantes :

• Modèle de programmation HTTP moderne : l’API Web permet d’accéder directement et manipuler les requêtes et réponses HTTP à l’aide d’un nouveau modèle objet HTTP fortement typé. Le même modèle de programmation HTTP est pratiquement disponible sur le client par l’intermédiaire de HttpClient pouvant être utilisé pour appeler des API Web dans n’importe quelle application .NET.

• Négociation de contenu : Le client et le serveur peuvent travailler ensemble afin de déterminer le bon format pour les données retournées à partir d’une API. Les formats pris en charge par défaut sont le XML et JSON. Le développeur pourra élargir ce soutien en ajoutant ses propres formats, ou même en remplaçant la stratégie de négociation du contenu par défaut.

• Prise en charge complète des routes : l’API Web prend désormais en charge l’ensemble des fonctionnalités de route qui ont toujours été une partie de la pile Web, y compris les paramètres d’itinéraire et les contraintes. En outre, la cartographie des actions possède un support complet pour les conventions, de sorte que le développeur n’aura plus besoin d’appliquer des attributs à une classe ou méthode. La configuration de Web API se fait uniquement à travers le code.

• Composition de requêtes : Web API permet de prendre rapidement en charge l’interrogation par l’intermédiaire des conventions URL OData. Lorsque le développeur retourne un type IQueryable de son API Web, le cadre fournira rapidement un soutien pour OData, rendant facile l’implémentation de la pagination et le tri.

• Validation des modèles : Le modèle fournit un moyen facile d’extraire des données de diverses parties d’une requête HTTP et de convertir ces parties du message en objets .NET, qui peuvent être utilisés par des actions Web API. Web API offre le même support qu’ASP.NET MVC pour la liaison des modèles et l’infrastructure de validation.

• Filtres : l’API Web permet de créer et utiliser facilement des filtres, qui permettent d’encapsuler et d’appliquer divers comportements.

• Améliorations des tests : plutôt que de fixer des détails dans les objets de contexte HTTP statiques, les actions Web API peuvent maintenant travailler avec les instances de HttpResquestMessage et HttpResponseMessage, deux nouveaux objets HTTP qui permettent d’effectuer plus facilement des tests.

• Support de l’IoC : Web API prend en charge le modèle de service de localisation mis en œuvre par ASP.NET MVC, qui permet de résoudre les dépendances pour de nombreux dispositifs différents. Le développeur peut facilement intégrer cela avec un conteneur IoC, ou un cadre permettant l’injection de dépendances.

• Flexibilité lors de l’hébergement : Web API peut être déployé dans n’importe quel type d’application ASP.NET (y compris à la fois ASP.NET MVC et ASP.NET Web Forms). Web API peut également être hébergé au sein de votre plateforme, si vous ne voulez pas utiliser ASP.NET/IIS pour le faire. Cela vous donne un maximum de flexibilité dans la façon dont vous l’utilisez.

Voyons de près quelques-unes de ces fonctionnalités au travers d’une application Web API.

Lors de la création d’un nouveau projet ASP.NET MVC 4, un nouveau modèle de projet est disponible dans les Templates par défaut qui fournit une implémentation basique d’une API Web.

Par défaut, un nouveau contrôleur Web API qui hérite de ApiController est disponible dans ce modèle de projet, qui illustre comment vous pouvez créer des requêtes Get(), Post(), Put() et Delete() pour votre API.

public class ValuesController : ApiController
    {
        // GET /api/values
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET /api/values/5
        public string Get(int id)
        {
            return "value";
        }

        // POST /api/values
        public void Post(string value)
        {
        }

        // PUT /api/values/5
        public void Put(int id, string value)
        {
        }

        // DELETE /api/values/5
        public void Delete(int id)
        {
        }
    }

Support complet des routes

Comme pour ASP.NET MVC, la définition des routes pour Web API est effectuée dans le fichier Global.ascx. Les routes pour Web API reprennent quasiment le même format que celle de MVC, afin que le développeur puisse capitaliser sur ses notions acquises.

En ouvrant donc le fichier Global.ascx, la route suivante est définie par défaut pour l’API Web :

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

A la différence de MVC, la route est ajoutée dans MapHttpRoute() et la méthode d’action n’est par définie dans le modèle de route. Ce qui implique que le développeur n’a pas besoins de spécifier une action. Web API identifie automatiquement la méthode du contrôleur qui sera exécutée en fonction du verbe HTTP qui est effectué (GET, POST, etc.).

Jetons un premier coup d’œil sur notre API Web en utilisant le contrôleur d’exemple (Values) inclus dans l’application pour avoir un aperçu du résultat qui est retourné.
Il suffit d’exécuter l’application et renseigner dans la barre d’adresse du navigateur l’URL suivant : « …/api/Values ».

Le résultat qui est retourné au format XML est le suivant :

<ArrayOfString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<string>value1</string>
<string>value2</string>
</ArrayOfString>

Passons maintenant à un exemple plus concret qui présente comment mettre en œuvre simplement des actions CRUD avec ASP.NET Web API.

Il est possible de créer un API controller avec par défaut les actions Read/Write. La boite de dialogue contient désormais un nouveau template pour la création d’un contrôleur qui hérite d’APIController avec des actions Read/Write.

Lorsque l’on crée un contrôleur en utilisant ce modèle, il contient par défaut les actions Get, Post, Put et Delete tel que mentionné ci-haut.

Ces actions peuvent être modifiées comme suit pour exposer les fonctionnalités CRUD de l’application directement à travers HTTP.

public class CustomerController : ApiController
    {

        private CustomerRepository repository = new CustomerRepository();
 
        // GET /api/customer
        public IEnumerable<Customer> Get()
        {
        
           return repository.GetAll();
        }

        // GET /api/customer/5
        public Customer Get(int id)
        {
            var customer = repository.Single(id);

           return customer;
        }

        // POST /api/customer
        public HttpResponseMessage Post(Customer customer)
        {
            Int id = repository.Add(customer);

            //spécification de l'emplacement du produit au Client REST
            var response = new HttpResponseMessage(HttpStatusCode.Created);
            response.Headers.Location = new Uri("/api/customer/" + id);

            return response;
        }

        // PUT /api/customer/5
        public void Put(int id, Customer customer)
        {
            var customeri = repository.Single(id);

            if (customeri == null)
                //Informe le client que la ressource n'existe pas
                throw new HttpResponseException(HttpStatusCode.NotFound);

            repository.SaveChanges(customer);
        }

        // DELETE /api/customer/5
        public HttpResponseMessage Delete(int id)
        {
            Customer customer = repository.Single(id);
            
            this.repository.Delete(customer);
            //Confirmation de la suppression au client 
            return new HttpResponseMessage(HttpStatusCode.NoContent);
        }
    }

Comme je l’ai signalé plus haut avec la négociation de contenu, Web API peut automatiquement sérialiser votre modèle aux différents formats qui sont supportés (JSON, XML, etc.) et ensuite écrire les données sérialisées dans le corps du message de la réponse HTTP. Le client peut desérialiser l’objet transmis par HTTP tant qu’il peut lire le format de sérialisation. La plupart des clients supportent par défaut le format XML et JSON.

- Appel du service avec JavaScript

Voyons maintenant comment appeler le service en utilisant JavaScript. Le script ci-dessous permet d’appeler le verbe Get pour lire les données.

<!DOCTYPE html>
<html lang="en">
<head>
    <title>ASP.NET Web API</title>
    <script src="../../Scripts/jquery-1.6.2.min.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            // Envoi de la requête Ajax
            $.getJSON("api/Customer/",
            function (data) {
                // En cas de succès, 'data' contient la liste des clients.
                $.each(data, function (key, val) {

                         var str = val.Id + ' ' + val.FirstName + ' ' + val.LastName;

                         $('<li/>', { html: str }).appendTo($('#customers'));
                });
            });
        });
    </script>
</head>
<body>
    <div>
        <h1>Customers</h1>
        <ul id='customers' />
    </div>
</body>
</html>

En remplaçant le code de la page Index.cshtml de mon application par celui ci-dessus, j’obtiens le résultat suivant dans mon navigateur :

– Utilisation de HttpClient

Il est également possible d’utiliser la Classe HttpClient pour accéder à une WebAPI dans n’importe quelle application .NET (WebForms, MVC, WinForms, Console, etc.). Elle permet d’effectuer avec souplesse des appels HTTP en utilisant les méthodes GetAsync, PostAsync, PutAsync, DeleteAsync qui vont appeler les verbes Get, Post, Put et Delete.

Exemple :

HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            var response = client.GetAsync("http://localhost:1369/api/Customer").Result;

Pour spécifier que les données retournées doivent être au format JSON, on peut procéder comme suit :

HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            var response = client.GetAsync("http://localhost:1369/api/Customer").Result;

L’intégration d’ASP.NET Web API dans ASP.NET MVC 4 est vraiment fluide et permet au développeur de capitaliser sur ses acquis pour facilement exposer les fonctionnalités de son application via HTTP.

Ressources sur WebApi

– Henrik F Nielsen
– Les ressources Web API sur ASP.NET