REST API con ASP.NET 6 y MySQL
Tags: webdev, dotnet, api, mysql
Published: 2022-10-06 21:17:12

¡Hola! En este artículo tutorial aprenderemos a construir una web API desde ASP.NET 6 para manejar operaciones CRUD con una base de datos en MySQL. 

**_Nota:_** el código fuente empleado en este tutorial está disponible en GitHub en el siguiente repositorio: [ASP.NET 6 Web API](https://github.com/esdanielgomez/ASP.NET6_WebAPI). 

**Recursos necesarios:**

Para seguir paso a paso este articulo o ejecutar el demo incluido, es necesario tener en funcionamiento las siguientes herramientas: 

- MySQL. 
- .NET 6 SDK. 
- Visual Studio 2019/2022.
- La carga de trabajo desarrollo web y ASP.NET para Visual Studio 2019/2022.

**Proceso a seguir:**

En el tutorial tendremos tres partes importantes: 

1. Revisar la base de datos que vamos a utilizar. 
2. Establecer el acceso a la base de datos desde ASP.NET a través de Entity Framework. 
3. Establecer los controladores y sus métodos para el servicio web. 

Como caso de estudio para este tutorial se manejarán los datos de usuarios a través de operaciones CRUD (Crear, Leer, Actualizar, y Eliminar) en registros.

##**1. La base de datos para el domino de la aplicación**.

La base de datos que utilizaremos en este ejemplo está conformada por una única tabla llamada: `User`, con los atributos: `Id`, `FirstName`, `LastName`, `Username`, `Password`, y `EnrrollmentDate`; en MySQL.

![User Entity](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b8kvmlcgczhqgeqaj94v.png) 
 
La sentencia SQL para la creación de la tabla `User` es la siguiente: 

```sql
CREATE TABLE `user` (
  `Id` INT NOT NULL PRIMARY KEY,
  `FirstName` VARCHAR(45) NOT NULL,
  `LastName` VARCHAR(45) NOT NULL,
  `Username` VARCHAR(45) NOT NULL,
  `Password` VARCHAR(45) NOT NULL,
  `EnrollmentDate` datetime NOT NULL 
);
```

Muy bien, con la base de datos establecida, ya podemos comenzar con la implementación de nuestro primer proyecto para el desarrollo de servicios API Rest. 

##**2. Establecer el acceso a la base de datos desde ASP.NET a través de Entity Framework.**

**Proyecto ASP.NET 6 del tipo Web API.**

En Visual Studio lo primero que haremos es crear un nuevo proyecto de tipo ASP.NET Core Web API: 

![ASP.NET Core Web API project.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pzlmfrbmyr1sthgm2cb1.png)
 
Después, en los siguientes pasos podremos especificar el Framework. 

![Select .NET version in the new project.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9w3vfss1jzkobu297ks2.png)

Con este proyecto crearemos el acceso a la base de datos e implementaremos un controlador correspondiente para trabajar con esos datos y proporcionar la web API.

**Acceso a la base de datos con Entity Framework.**  

Para establecer las entidades a través de clases y la conexión de la base de datos se puede emplear el enfoque _Database First_ de Entity Framework, el cual permite hacer _scaffolding _desde la base de datos hacia el proyecto, es decir, generar clases automáticamente de acuerdo con las entidades establecidas en la base de datos y la conexión en el proyecto. 

Para este propósito, es necesario instalar tres paquetes NuGet: 

- `Microsoft.EntityFrameworkCore.Design`
- `Microsoft.EntityFrameworkCore.Tools`
- `MySql.EntityFrameworkCore`

En caso de que se este trabajando con SQL Server, el paquete NuGet a instalar será: `Microsoft.EntityFrameworkCore.SQLServer`. 

**_Nota:_** para encontrar el centro de administración de los paquetes NuGet podemos dirigirnos al menú de opciones -> proyecto -> manejar paquetes NuGet. 

![Go To Manage NuGet Packages option](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jonzng4xltlh7oubpgpr.png)
 
Con la instalación de estos paquetes NuGet, ahora abriremos la consola de administración de paquetes para introducir un comando que permitirá realizar _scaffolding _desde la base de datos: 

![Option to open Package Manager Console](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q6d0cgklv0pxhj04kg4y.png)
 
**Comando:**
```
Scaffold-DbContext "server=servername;port=portnumber;user=username;password=pass;database=databasename" MySql.EntityFrameworkCore -OutputDir Entities -f
```

El resultado es el siguiente:

![C# Entities](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7svp3b6w51eyzkhycagg.png)
 
Aquí, la clase `User` está definida de la siguiente manera: 

```csharp
public partial class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public DateTime EnrollmentDate { get; set; }
}
```

Y el `DBContext`, el cual tiene la configuración con la base de datos, cuyo método principal `OnConfiguring` se verá algo como esto: 

```csharp
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
  if (!optionsBuilder.IsConfigured)
  { optionsBuilder.UseMySQL("server=localhost;port=3306;user=root;password=;database=database");
  }
}
```

Ahora, no es lo más adecuado que la cadena de conexión a la base de datos se encuentre especificada en este método `OnConfiguring`. Para esto, dentro de nuestro proyecto podemos encontrar el archivo `appsettings.json`, en el cual podremos definir esta configuración: 

```json
"AllowedHosts": "*",
"ConnectionStrings": {
  "DefaultConnection": "server=servername;port=portnumber;user=username;password=pass;database=databasename;"
}
```

Luego, en la clase `Program` agregaremos como servicio al `DBContext`, y luego debemos hacer referencia a la propiedad `DefaultConnection` especificada en el archivo `appsettings.json`:

```csharp
builder.Services.AddEntityFrameworkMySQL()
    .AddDbContext<DBContext>(options =>
    {
        options.UseMySQL(builder.Configuration.GetConnectionString("DefaultConnection"));
    });
                });
```

En este caso, regresando a la clase del `DBContext`, borramos la cadena de conexión especificada en el método `OnConfiguring`. A la final tendríamos el método vacío:

```csharp
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{}
```

Con estos pasos ya tenemos lista la conexión y las configuraciones necesarias para trabajar con la base de datos en ASP.NET con la ayuda de Entity Framework. 

##**3. Establecer los controladores y sus métodos para el servicio web.**
 
Con el objetivo de transportar los datos entre los procesos para el manejo de la base de datos y los procesos para trabajar con los servicios web, es recomendable establecer clases DTO por cada entidad del proyecto, en este caso, un DTO para la entidad `User`.
 
Para ello crearemos una nueva carpeta dentro del proyecto llamada DTO y crearemos una clase llamada `UserDTO`, cuyos atributos serán los mismos que la clase `User` definida en la sección `Entities` anteriormente: 

```csharp
public class UserDTO
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public DateTime EnrollmentDate { get; set; }
}
```

**Controladores para el Web API.** 

Ahora lo que haremos es agregar los controladores, en este caso el controlador para el usuario, el cual permitirá establecer métodos para realizar operaciones CRUD sobre las tablas de la base de datos y exponerlos a través del Web API. Sobre la carpeta `Controllers`, agregaremos un controlador llamado `UserController`: 

![Create new Controller option](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t6pdro84c2wu3fyko875.png)
La definición de la clase y su constructor se verá así: 

```csharp
[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly DBContext DBContext;

    public UserController( DBContext DBContext)
    {
        this.DBContext = DBContext;
    }
    ...
}
```

Ahora el objetivo es realizar las operaciones CRUD. En este sentido, utilizaremos métodos para acceder a la información (Get), para insertar datos (Post), para modificar (Put) y para eliminar un registro (Delete).

A continuación, se muestra el código final de cada uno de los métodos:

**_A. Obtener el listado de todos los usuarios registrados._**

```csharp
[HttpGet("GetUsers")]
public async Task<ActionResult<List<UserDTO>>> Get()
{
    var List = await DBContext.User.Select(
        s => new UserDTO
        {
            Id = s.Id,
            FirstName = s.FirstName,
            LastName = s.LastName,
            Username = s.Username,
            Password = s.Password,
            EnrollmentDate = s.EnrollmentDate
        }
    ).ToListAsync();

    if (List.Count < 0)
    {
        return NotFound();
    }
    else
    {
        return List;
    }
}
```

**_B. Obtener los datos de un usuario especifico según su Id._**

```csharp
[HttpGet("GetUserById")]
public async Task<ActionResult<UserDTO>> GetUserById(int Id)
{
    UserDTO User = await DBContext.User.Select(
            s => new UserDTO
            {
                Id = s.Id,
                FirstName = s.FirstName,
                LastName = s.LastName,
                Username = s.Username,
                Password = s.Password,
                EnrollmentDate = s.EnrollmentDate
            })
        .FirstOrDefaultAsync(s => s.Id == Id);

    if (User == null)
    {
        return NotFound();
    }
    else
    {
        return User;
    }
}
```

_**C. Insertar un nuevo usuario.**_ 

```csharp
[HttpPost("InsertUser")]
public async Task<HttpStatusCode> InsertUser(UserDTO User)
{
    var entity = new User()
    {
        FirstName = User.FirstName,
        LastName = User.LastName,
        Username = User.Username,
        Password = User.Password,
        EnrollmentDate = User.EnrollmentDate
    };

    DBContext.User.Add(entity);
    await DBContext.SaveChangesAsync();

    return HttpStatusCode.Created;
}
```

_**D. Actualizar los datos de un usuario especifico.**_  

```csharp
[HttpPut ("UpdateUser")]
public async Task<HttpStatusCode> UpdateUser(UserDTO User)
{
    var entity = await DBContext.User.FirstOrDefaultAsync(s => s.Id == User.Id);

    entity.FirstName = User.FirstName;
    entity.LastName = User.LastName;
    entity.Username = User.Username;
    entity.Password = User.Password;
    entity.EnrollmentDate = User.EnrollmentDate;

    await DBContext.SaveChangesAsync();
    return HttpStatusCode.OK;
}
```

**_E. Eliminar a un usuario según su Id._**  

```csharp
[HttpDelete("DeleteUser/{Id}")]
public async Task<HttpStatusCode> DeleteUser(int Id)
{
    var entity = new User()
    {
        Id = Id
    };
    DBContext.User.Attach(entity);
    DBContext.User.Remove(entity);
    await DBContext.SaveChangesAsync();
    return HttpStatusCode.OK;
}
```

Con estos métodos y con los pasos seguidos hasta este punto, el servicio web está listo para ponerse en ejecución.
 
**Probar la web API implementada**

Para probar la API implementada podemos utilizar `Swagger UI`, una herramienta visual que nos permite interactuar con los métodos de nuestro servicio, y que a su vez ya se encuentra integrada en nuestro proyecto de ASP.NET 6.

Para las pruebas, necesitamos compilar y ejecutar la aplicación: 

![Run app](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mep9qhxdtseayya37622.png)
 
A continuación, podemos ver la interfaz de Swagger para que podamos realizar las pruebas correspondientes de acuerdo con los métodos definidos en nuestro controlador y de una manera interactiva: 

![Swagger UI](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q905w5n6w1shfpf6ky4t.png)
 
Al ser este un servicio RestFul, nosotros podemos utilizar cualquier otro programa o aplicación para consumir estos servicios. Por ejemplo, aquí podemos ver una llamada al método `GetUsers` desde la herramienta Postman: 

![HTTP Get example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wx44l75nddfqwjpwp79l.png)
 
##**What next?**
 
Con este tutorial hemos aprendido paso a paso como implementar servicios HTTP que manejen datos de usuarios desde ASP.NET 6, y como realizar pruebas con estas funcionalidades.

El código fuente de este ejemplo puede visualizarse desde el siguiente repositorio en GitHub: [ASP.NET 6 Web API](https://github.com/esdanielgomez/ASP.NET6_WebAPI). 

**Gracias por leer:**

Espero que te haya gustado el artículo. Si tienes alguna pregunta o alguna idea en mente, será un gusto poder estar en comunicación contigo y juntos intercambiar conocimientos entre sí.

Nos vemos en [Twitter](https://twitter.com/esDanielGomez) / [esDanielGomez.com](https://esdanielgomez.com)!

¡Saludos!