L’édition 2014 des Techdays vient de se terminer, trois jours riches en conférences, surtout la première pour le développeur que je suis.

Parmi les sessions les plus attendues (en tout cas par moi) il y avait “ASP.NET MVC 5 et Web API 2« .

Quoi de neuf ?

Rien de révolutionnaire mais des petites nouveautés que je trouve intéressantes et je vais vous les résumer en quelques points.

ONE ASP.NET

Une des nouveautés de Visual studio 2013 est le Template Web tout en un. En créant un nouveau projet Web l’assistant vous donne la possibilité d’inclure les différentes technologies à utiliser (Web forms, MVC, Web API)

Cela vous permet de mixer plusieurs types de projets.

ASP.NET Identity

ASP.NET identity Core, c’est le nom de la nouvelle brique qui remplace les ASP.NET membership providers.

C’est une librairie qui définit des interfaces pour la gestion d’authentification des utilisateurs dans votre application. La librairie est accessible sous la forme d’un package Nuget :

Au-dessus de ce package comme vous pouvez lire il y a “Microsoft ASTP.NET Identity EntityFramework”, il s’agit de l’implémentation sous Entity Framework de la librairie Identity, mais vous pouvez avoir bien évidemment d’autres implémentations.

Personnalisation du routage (Attribute routing)

Un nouveau type de routage est supporté appelé routage par attribut (Attribute routing). Comme son nom l’indique Il est utilisé pour définir le routage en passant par des attributs.

L’avantage est que ceux-ci sont directement mis sur les contrôleurs ou les actions, cela permet d’identifier facilement la route qui mène au contrôleur.

Il existe trois attributs qui permettent de gérer le routage, Route, RoutePrefix et RouteArea.

Et voici deux exemples d’utilisation de ces attributs :

Paramètre optionnel et valeur par défaut

Vous pouvez marquer un paramètre comme optionnel en lui rajoutant un point d’interrogation. Vous pouvez également spécifier une valeur par défaut.

public class BooksController : Controller
        {
            [Route("books/{isbn?}")]
            public ActionResult View(string isbn)
            {
                if (!String.IsNullOrEmpty(isbn))
                {
                    return View("OneBook", GetBook(isbn));
                }
                return View("AllBooks", GetBooks());
            }
            [Route("books/lang/{lang=en}")]
            public ActionResult ViewByLanguage(string lang)
            {
                return View("OneBook", GetBooksByLanguage(lang));
            }
        }

Dans cet exemple le paramètre isbn est optionnel et les deux appels /books/lang et /books/lang/en sont traités de la même façon.

Route Prefixes

Souvent les routes dans un contrôleur commence par le même préfixe, par exemple :


public class ReviewsController : Controller
{
    [Route("reviews")]
    public ActionResult Index() { ... }
    [Route("reviews/{reviewId}")]
    public ActionResult Show(int reviewId) { ... }
}

Dans ce cas vous pouvez mettre un préfixe en utilisant l’attribut [RoutePrefix] :


RoutePrefix("reviews")]
public class ReviewsController : Controller
{
    [Route]
    public ActionResult Index() { ... }
    [Route("{reviewId}")]
    public ActionResult Show(int reviewId) { ... }
}

Batching

Web API Batching permet de combiner plusieurs opérations dans une seule Requête HTTP POST, cela permet de réduire les messages échangés entre le client et le serveur.

Dans l’exemple qui suit on va utiliser MapHttpBatchRoute coté serveur pour créer un point de terminaison à “api/$batch” :


public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpBatchRoute(
                routeName: "WebApiBatch",
                routeTemplate: "api/$batch",
                batchHandler: new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer));

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


C’est tout ce qu’on a besoin coté serveur, coté client on utilise HttpClient pour lancer la requête :

private static void Main(string[] args)
        {
            string baseAddress = "http://localhost:8080";
            HttpClient client = new HttpClient();
            HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, baseAddress + "/api/$batch")
            {
                Content = new MultipartContent("mixed")
                {
                    // POST http://localhost:8080/api/values
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, baseAddress + "/api/values")
                    {
                        Content = new ObjectContent<string>("my value", new JsonMediaTypeFormatter())
                    }),

                    // GET http://localhost:8080/api/values
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, baseAddress + "/api/values"))
                }
            };

            HttpResponseMessage batchResponse = client.SendAsync(batchRequest).Result;

            MultipartStreamProvider streamProvider = batchResponse.Content.ReadAsMultipartAsync().Result;
            foreach (var content in streamProvider.Contents)
            {
                HttpResponseMessage response = content.ReadAsHttpResponseMessageAsync().Result;
            }
        }


Comme vous pouvez le voir on a lancé un POST suivi d’un GET en une seule requête.

Web API Odata

Web Api 2 supporte de nouveaux paramètres permettant de modifier la requête Odata afin de permettre au client de contrôler la représentation qu’il obtient à partir du serveur.

Voici quelques paramètres :

– $expand : par défaut, la réponse ne contient pas les entités liées si nous interrogeons une collection Odata. En utilisant $expand, on peut inclure ces entités dans la réponse de la même façon que le Include dans Entity Framework.

– $select : Permet de sélectionner que certaines propriétés de l’entité

– $orderby : Trier le résultat

OWIN

OWIN signifie Open Web Interface for .NET. Le but est d’abstraire l’utilisation de IIS et de toutes les fonctionnalités d’ASP.NET pour son application Web (Authentification, compression, logs… )

OWIN est un standard, katana en est l’implémentation. Il s’agit d’un projet visant à faciliter l’intégration de librairies compatibles avec OWIN sur la plateform Windows.

Voici un article intéressant qui détaille bien ce projet.

BSON

Le format BSON (Binary Media-Type Formatter) est maintenant pris en charge, il suffit de le rajouter à la collection des formateurs :

config.Formatters.Add(new BsonMediaTypeFormatter());

Conclusion

C’était une session à ne pas rater, pleins de petites nouveautés des deux frameworks phares du moment côté Web. Vous je ne sais pas, mais moi j’aime ces petites améliorations :)

Ne ratez plus aucunes actualités avec la newsletter mensuelle de SoftFluent