Web Api Entity Framework

Bienvenidos a este tutorial donde aprenderás a crear una web api en el entorno ASP.NET Framework.

Para este tutorial necesitaremos varias herramientas:

Visual Studio: Interfaz donde realizaremos nuestra aplicación.

Link de descarga: https://docs.microsoft.com/es-es/visualstudio/install/install-visual-studio?view=vs-2019

Sql Server Management: La base de datos donde nuestro software accederá a nuestros datos.

Link de descarga SQL SERVER: https://www.microsoft.com/es-es/sql-server/sql-server-downloads

Descargar SQL Server Management: https://docs.microsoft.com/es-es/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver15

Postman: Aplicación que nos permitirá realizar peticiones HTTP a nuestra WEB API.

Link de descarga: https://www.getpostman.com/

¿Qué es una API?

Empezaremos explicando que es una API (Interfaz de Programación de Aplicaciones). Es una interfaz que mediante protocolos se desarrolla e integra aplicaciones software. Incorpora aplicaciones de terceros, facilitando a los desarrolladores invertir menos tiempo en la creación de aplicaciones.

¿Qué es una WEB API?

Ahora que sabemos que es una API, explicaré que es una WEB API.

La gran característica de una Web Api es de solicitar mediante el protocolo HTTP al software de terceros al que se quiere integrar.

La ventaja de poder trabajar con el protocolo HTTP es poder realizar peticiones en cualquier lenguaje de programación. Y al solicitar la petición devuelve la información en formato JSON o XML.

CREACIÓN DEL PROYECTO

Paso 1 Realización de la base de datos.

Para crear una nueva base de datos.

Pinchamos con el botón derecho la carpeta Database y creamos una nueva.

En este caso lo llamaremos Biblioteca.

Paso 2 Creación de una tabla.

Abrimos la pestaña Biblioteca. Dentro de esta, pinchamos botón derecho Nuevo —> Tabla

Escribimos los nombres de cada columna con su correspondiente tipo de dato.

Los datos de las columnas a representar son:

Nombre Columna		Tipo de Dato
Cod_Libro		int
Nombre_Alumno		nvarchar(50)
Titulo_Libro		nvarchar(50
Fecha_Entrega		date
IdEdtudiante		int

Guardamos los datos y le asignamos el nombre Prestamo_Libro a la tabla creada.

Insertamos los datos en la table Prestamo_Libro mediante una consulta.

INSERT INTO Prestamo_Libro

(Cod_Libro, Nombre_Alumno,Titulo_Libro, Fecha_Entrega, IdEstudiante)

VALUES

(1, ‘Juan’, ‘Jardinería en 3 Pasos’, ‘2020-4-8’, 1),

(2, ‘Maria’, ‘Historia de las Matemáticas’, ‘2020-5-18’, 2),

(3, ‘Esteban’, ‘Literatura Universal s.XX’, ‘2020-6-22’, 3),

(4, ‘Marta’, ‘Electrónica’, ‘2020-9-11’, 4)

Pinchar en el botón derecho sobre la tabla y seleccionamos la pestaña Select Top 1000 Rows para ver los datos de dicha tabla.

En Cod_Libro que será primary key y no aceptará valores null(vacíos).

-No valores null.

– Primary Key

– Botón derecho a la flecha y asignamos Primary.

Paso 3 Elaborar un Proyecto WEB API en el entorno EntityFramework en Visual Studio.

Creamos un nuevo proyecto.

Escribimos en el buscador asp.net web Application(.NETFramework)

Y buscaremos la plantilla indicada.

Asignamos el nombre del proyecto llamado ProyectoBiblio.

Elegimos la plantilla Web API

Paso 4 Instalar la librería de EntityFramework

Botón derecho sobre el proyecto y seleccionamos Manage NuGet Packages.

En el buscador, dentro de la pestaña Browse escribiremos EntityFramework e instalamos el paquete.

Paso 5 Establecer la clase LibroPrestado.

Creamos una clase llamada LibroPrestado. En ella escribimos las propiedades a la que mapearemos con las columnas procedente de la tabla Prestamo_Libro de la base de datos.

Asignamos la primary Key sobre la propiedad CodigoLibro para equiprar con Cod_Libro de la base de datos.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace ProyectoBiblio.Models
{
[Table(«Prestamo_Libro»)]
public class LibroPrestado
{
[Key]
[Column(«Cod_Libro»)]
public int CodigoLibro { get; set; }
[Column(«Nombre_Alumno»)]
public String NombreAlumno { get; set; }
[Column(«Titulo_Libro»)]
public String TituloLibro { get; set; }
[Column(«Fecha_Entrega»)]
public DateTime FechaEntrega { get; set; }
[Column(«IdEstudiante»)]
public int IDEstudiante{ get; set; }

}

Paso 6 Llamar la base de datos desde Visual Studio.

En la esquina superior izquierda pinchamos sobre Server Explorer.

Ahora añadimos una nueva conexión.

Escribimos el nombre de nuestro servidor que se encuentra en Sql. Y seleccionamos el nombre de la base de datos(Biblioteca).

Paso 7 Conectar la base de datos a Visual Studio.

Crear la carpeta Data dentro del proyecto.

Pinchamos botón derecho sobre el proyecto y creamos una carpeta nueva llamada Data.

Creamos una clase llamada ContextoLibro.

Paso 8 Desarrollo de la cadena Conexión.

Copiaremos la cadena conexión alojado en Server Explorer. Designamos la etiqueta connectionString dentro de la etiqueta configuration.

En la pestaña WebCongfig integramos la cadena conexón a nuestro proyecto.

Elaboramos las etiquetas <connectionStrings> donde alojaremos la conexión copiada.

<add name=»conexionbiblioteca» connectionString=»Data Source=DESKTOP-KHV752N;Initial Catalog=Biblioteca;Integrated Security=True»

providerName=»System.Data.SqlClient»/> </connectionStrings>

Paso 9 Enlazar el contexto con la cadena conexión.

Ahora, volvemos a la clase ContextoLibro alojada en la carpeta Data. El nombre de esta clase heredará de DbContext que nos permite hacer de puente hasta nuestra cadena conexión.

Escribimos el constructor de la clase llamada (ContextoLibro) donde anotamos el nombre de la conexión.

Asociamos la tabla mapeada (LibroPrestado) junto a la colección de tipo DbSet.

Creamos el método OnModelCreating para poder actualizar la clase LibroPrestado.

using ProyectoBiblio.Models;

using System;

using System.Collections.Generic;

using System.Data.Entity;

using System.Linq;

using System.Web;

namespace ProyectoBiblio.Data

{

public class ContextoLibro : DbContext {

public ContextoLibro():

base(«name=conexionbiblioteca») { }

public DbSet DbLibros { get; set; }

protected override void

OnModelCreating(DbModelBuilder modelBuilder)

{

Database.SetInitializer(null);

base.OnModelCreating(modelBuilder);

}

Paso 10 Asignar nuevo Controlador con EntityFramework

Compilamos el proyecto para poder arrancar el controlador sin problemas. Agregamos con botón derecho un nuevo controlador. Elegimos WebApi2 Controller with action, using Entity Framework.

Seleccionamos clase LibroPrestamo en la primera casilla.

En la segunda casilla elegimos la clase ContextoLibro .

Nombramos al controlador WebLibroController.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Description;
using ProyectoBiblio.Data;
using ProyectoBiblio.Models;

namespace ProyectoBiblio.Controllers
{
public class WebLibroController : ApiController
{
private ContextoLibro db = new ContextoLibro();

// GET: api/WebLibro

public IQueryable GetDbLibros()
{
return db.DbLibros;
}

// GET: api/WebLibro/5
[ResponseType(typeof(LibroPrestado))]

public IHttpActionResult GetLibroPrestado(int id)
{
LibroPrestado libroPrestado = db.DbLibros.Find(id);
if (libroPrestado == null)
{
return NotFound();
}

return Ok(libroPrestado);

}

// PUT: api/WebLibro/5
[ResponseType(typeof(void))]

public IHttpActionResult PutLibroPrestado(int id, LibroPrestado
libroPrestado)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != libroPrestado.CodigoLibro)
{
return BadRequest();
}

db.Entry(libroPrestado).State = EntityState.Modified;

try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!LibroPrestadoExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return StatusCode(HttpStatusCode.NoContent);

}

// POST: api/WebLibro
[ResponseType(typeof(LibroPrestado))]

public IHttpActionResult PostLibroPrestado(LibroPrestado libroPrestado)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

db.DbLibros.Add(libroPrestado);
db.SaveChanges();

return CreatedAtRoute(«DefaultApi», new { id =

libroPrestado.CodigoLibro }, libroPrestado);
}

// DELETE: api/WebLibro/5
[ResponseType(typeof(LibroPrestado))]

public IHttpActionResult DeleteLibroPrestado(int id)
{
LibroPrestado libroPrestado = db.DbLibros.Find(id);
if (libroPrestado == null)
{
return NotFound();
}

db.DbLibros.Remove(libroPrestado);
db.SaveChanges();

return Ok(libroPrestado);

}

protected override void Dispose(bool disposing)
{
if (disposing)
{
db.Dispose();
}
base.Dispose(disposing);
}

private bool LibroPrestadoExists(int id)
{
return db.DbLibros.Count(e => e.CodigoLibro == id) > 0;
}

}

Paso 11 Resultado del proyecto

Arrancamos el proyecto.

En la sección del menú de inicio tenemos la opción de API.

Tenemos cuatro métodos a utilizar. GET, POST, PUT Y DELETE.

GET: Encargado de leer los datos.

POST: Introduce un nuevo dato.

PUT: Actualiza un dato.

DELETE: Elimina los datos.

Paso 12 Uitlizar el programa Postman.

Este último paso de este proyecto consiste en realizar las peticiones http mediante el programa Postman.

Copiamos la url de nuestro servidor local. Pinchamos con botón derecho sobre nuestro proyecto (ProyectoBiblioteca).

Buscamos la opción Properties. Pinchamos en la opción Web.

Dentro de Web nos muestra lo que buscamos, la url que nos da el acceso para realizar las peticiones.

Ahora sabiendo que cada url realiza una función específica, pegamos la url GET en el programa de Postman.

GET

Es importante indicar al programa que tipo de método vamos a realizar.

GET/id

Introducir nuestra url local y nos mostrará los datos de un libro específico.

PUT

En el caso de actualizar debemos realizar varios cambios para poder modificar los datos.

En la pestaña Body seleccionaremos la opción raw para poder escribir los datos. Elegimos JSON el tipo de dato a representar.
Seleccionamos el dato a modificar y comprobamos en Sql el cambio realizado.