Les WebAPI en général et en Asp .Net Core
Les WebAPI : Qu’est-ce que c’est ? Comment cela fonctionne en général ? Et comment faire une WebAPI en Asp .Net Core ?
Vidéo explicative
Les WebAPI en général
API signifie Application Programming Interface. Autrement dit : interface de programmation logiciel. Il s’agit d’une connexion entre plusieurs applications. Dans le cadre d’une WebAPI, on parlera d’un FRONT-END (la partie visuelle de l’application : les fenêtres, boutons etc) qui se connecte à la partie BACK-END (notre WebAPI).
Le FONT-END peut être :
- Un browser web
- Une application mobile
- etc.
Le BACK-END représente notre WebAPI et se décompose en une architecture sur plusieurs couches :
- Peu importe le langage, on arrive sur une méthode d’un controller. La route (l’url) va indiquer au système de routage de l’application WebAPI quelle méthode de quel controller il faut appeler. Ainsi donc, le premier point d’entrée est notre controller. Celui-ci ne contiendra normalement pas de logique mais va appeler une FACADE.
- La FACADE est la première couche métier qui fait le lien entre le monde FRONT et le monde BACK (WebAPI). Elle fait le lien entre le controller qui reçoit des objets FRONT et la BLL (couche BUSINESS) qui contient des objets BUSINESS. C’est donc elle qui fait le mapping entre les 2.
- La couche BUSINESS (BLL) va contenir tous les services qui représentent la logique métier. Cette logique métier peut avoir besoin parfois d’interagir avec une DB. Dans ce cas, la BUSINESS va appeler une couche DAL (DATAACCESS).
- La couche DATAACCESS (DAL) contient tous les repositories qui s’occupent de gérer les accès à la DB.
Vous découvrirez plus d’infos sur ces architectures dans d’autres tutos ou formations mais cela vous donne déjà une bonne idée.
Les WebAPI Asp .Net Core
Les WebAPI Asp .Net Core sont donc des WebAPI faite en dotnet Core. Vous pouvez créer :
- Soit un projet Asp Net Core vide qui aura pour code le stricte minimum pour créer une application Web pouvant être une WebAPI ou tout autre application Web.
- Soit un projet API web Asp Net Core qui contiendra un exemple de WebAPI écrite en Asp Net Core avec un controller etc.
Le code le plus simple pour une application Web est le suivant :
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World");
app.Run();
On génère un builder sur lequel on appel .Build() pour créer notre application web “app”.
Sur cette application, on va mapper une fonction GET en lui indiquant que si on demande la route “/” donc rien de spécial après l’url, on affiche “Hello World”.
Enfin, on fait un .Run() sur notre app pour la lancer. Un mini serveur IIS est alors créé en local (localhost) sur un port disponible pour lancer notre application web qui s’affiche dans un navigateur web. Le navigateur web sert ainsi de FRONT et notre application WebApi qui est notre BACK affiche le résultat de la méthode qui est mappée sur “/”.
Généralement, pour des WebApi, on va créer des controllers et éviter de mapper directement des route sur du code. Pour se faire, on doit ajouter quelques lignes ce qui donne le code suivant :
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();
Ici, on fait un “builder.Services.AddControllers()” avant de faire le build() pour dire d’ajouter tout ce qu’il faut afin de pouvoir gérer les controllers.
Ensuite on va faire “app.MapControllers()” avant de lancer notre app afin de mapper les routes sur les controllers correspondants. L’application va alors parcourir toutes les classes et retrouver celles qui héritent de ControllerBase ou Controller et surtout qui ont un attribut de classe [ApiController]. Ensuite, pour savoir quelle est la route, il va regarder ce qu’il y a dans l’attribut de classe [Route(“ma route”)]. Enfin, il va rediriger sur la bonne méthode en fonction du GET/POST/etc.
Exemple de controller simple :
[ApiController]
[Route("[controller]")]
public class HelloController : Controller
{
[HttpGet]
public string Index()
{
return "Hello world !!!";
}
}
Ici, on a :
- L’attribut [ApiController] qui permet à notre app de retrouver notre controller
- L’attribut [Route] qui permet à notre app de savoir qu’elle doit mapper la route /Hello ([controller] = le nom de notre classe sans le suffixe Controller) vers ce controller.
- On a bien notre classe qui hérite de Controller.
- Enfin, on a une méthode qui sera appelée lors d’un http GET : la méthode Index().
Plus d’infos sur les routes et controllers suivront dans d’autres tutos / formations mais vous avez ainsi la base pour mieux comprendre les WebApi.
Conclusion
En bref, une WebAPI est donc la partie BACK END d’une application WEB.
Les WebAPI DotNet peuvent être créée facilement en quelques lignes de code comme décrit ci-dessus.
J’espère que cette vidéo et ce tuto vous auront plu. N’hésitez pas à me laisser un commentaire et à vous abonner pour ne rien manquer.
Je vous dis à très bientôt pour de nouvelle vidéos / tutos pour développer en Web facilement.