Ya hemos instalado nuestras herramientas de desarrollo tales como:  .Net Core SDK, Visual studio code y SQL server. Ahora necesitamos poner manos a la obra. Haremos magia con C# para crear un API con al menos dos entidades, Authors and Books. Como ya sabemos las API carecen de UI o Vistas por lo tanto tendremos que consultar nuestros endpoints por medio de postman, accediendo a las URLs que vamos a diseñar siguiendo los estándares REST.

Breve Introducción a conceptos Básicos,

La gema central de ASP.NET Core Web API son los controladores y acciones. La palabra controlador viene del patrón de diseño muy conocido, M-V-C, Model, View, Controller.

Introduzcamos estos conceptos de forma rápida y concisa:

  • Modelos, los modelos son abstracciones de entidades, usualmente existen tres tipos de modelos. El modelo de dominio, la cual es una abstracción de las entidades usada por la lógica del negocio. El View Model, es la conexión de la data con la vista. La data será renderizada por la vista. y por ultimo, Modelo de transferencia de data, es la data que viaja entre el cliente y el servidor.

 

  • Vistas, es la plantilla para generar la interfaz de usuario.

 

  • Controladores, Donde se encuentra la lógica del negocio, este se comporta según la interacciones del usuario, envolviendo modelos(data) y las vistas (plantillas). Los controladores son clases, mientras que sus métodos de estos son quienes procesan las solicitudes y responder por medio de las vistas a los usuarios, tales operaciones son llamadas acciones(Actions).

Modelo (1).png

Ejemplificamos de la siguiente manera:

Nuestra usuaria, navega por nuestra web application, sobre unicornios, y le parece tan divertido que desea registrarse en la página, lo cual implica 1-Acción, 2-Almacenamiento de data para poder ingresar de nuevo.

Ella mediante la vista, da click a un botón de registro, lo cual genera una evento, que generará un formulario de registro. A su vez el usuario digite sus datos que serán almacenados en la base de datos.

Sin embargo, en este tutorial no seguiremos el modelo MVC, pues recordemos que por su naturaleza las APIs carecen de Vistas, por tanto, solo tendremos modelos y controladores.

Los requerimientos de nuestra API son los siguientes:

  1. Se consultará a la API Library, para obtener todos los autores registrados, y los libros que estos han escrito.
  2. Encontrar autores por medio de clave única o id.
  3. Endpoint de consulta para libros que nos permita, visualizar los autores de los libros disponibles.
  4. Encontrar libros por su clave única(id).

Vamos a crear un proyecto desde nuestra línea de comandos ,

  1. shift + click derecho en donde desea agregar el proyecto, seleccione abrir la linea de comando en la carpeta de destino y asi no sera necesario especificar la ruta. En caso contrario presione la tecla Windows + R, escribe cmd + presiona enter.
1
2
3
4
5
6
7
dotnet new api --name Library.
cd Library
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet restore
dotnet build
code .

unicornEnhorabuena!! has creado tu primer API.

 


light-bulbNota: El último comando te permite abrir el proyecto en Visual Studio Code desde consola. Este comando es opcional.


Si sigues al pie de la letra estas serie de artículos podrás aprender los conceptos básicos de desarrollo de API, podrás entender la estructura de estos proyectos y como funcionan.

Ya hemos creado nuestro proyecto, ahora tenemos que crear nuestro modelo de base de datos, para eso vamos a crear nuestras tablas desde SQL SERVER, en este ejemplo estaremos usando SQL Server Express, pero eres libre de elegir otro motor de base de datos como MySql, sin embargo tendrías que modificar algunas configuraciones.

Lo primero que debemos hacer es crear nuestra base de datos, las tablas, agregar las claves primarias y foráneas.  

Inicia y conectate a tu localhost en SQL server.

  1. Agregar nuevo query.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
CREATE DATABASE [Library];
USE [Library];

 

CREATE TABLE [Authors]
(
[Id_Author] INT IDENTITY(1,1),
[Name] VARCHAR (30),
[Last_Name] VARCHAR(30),
[Email] VARCHAR(30)

CONSTRAINT PK_Author PRIMARY KEY (Id_Author),
);

CREATE TABLE [Books]
(
[Id_Book] INT IDENTITY(1,1),
[Id_Author] INT NULL,
[Title] VARCHAR(30),
[Description] VARCHAR(200),
[Section] VARCHAR(20),
[Genre] VARCHAR(30),
[Year] INT,
[Publisher] VARCHAR(30),

CONSTRAINT PK_Book PRIMARY KEY (Id_Book),

CONSTRAINT FK_BooksAuthors FOREIGN KEY ([Id_Author]) REFERENCES [Authors]([Id_Author])
);

 

  • Luego de crear nuestra base de datos y las tablas, necesitamos registros para consultar, para ello ejecutamos el siguiente script.

Insertamos en la tabla Authors:

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 USE [Library]

INSERT INTO [Authors]
(
[Name],
[Last_Name],
[Email]
)
VALUES
(
'Jane',
'Austen',
'j.austey@gmail.com'
);

-- ==========
INSERT INTO [Authors]
(
[Name],
[Last_Name],
[Email]
)
VALUES
(
'Paulo',
'Coelho',
'p.coelho@gmail.com'
);

-- ==========
INSERT INTO [Authors]
(
[Name],
[Last_Name],
[Email]
)
VALUES
(
'William',
'Goldman',
'w.goldman@gmail.com'
);

-- ==========

INSERT INTO [Authors]
(
[Name],
[Last_Name],
[Email]
)
VALUES
(
'Miguel',
'Cervantes',
'm.cervantes@gmail.com'
);

-- ==========

 

  • La siguiente tabla es Books:

 

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
USE [Library]
INSERT INTO Books
(
[Id_Author],
[Title],
[Description],
[Section],
[Genre],
[Year],
[Publisher]
)
VALUES
(
3,
'The princess bride',
'The book combines elements of comedy and romance',
'Family',
'Romance',
'1973',
'Londom-Books'
);
-----===================================

 

INSERT INTO Books
(
[Id_Author],
[Title],
[Description],
[Section],
[Genre],
[Year],
[Publisher]
)
VALUES
(
1,
'Pride and Perjudice',
'Pride and Prejudice is a romantic novel by Jane Austen, first published in 1813.',
'Adults',
'Romance',
'1813',
'Thomas Egerton'
);
----------------------------================
INSERT INTO Books
(
[Id_Author],
[Title],
[Description],
[Section],
[Genre],
[Year],
[Publisher]
)
VALUES
(
4,
'Sir Quixote of La Mancha',
'Is a Spanish novel by Miguel de Cervantes Saavedra. ',
'Adventure',
'Novel',
'1605',
'Francisco de Robles'
);

 

-----------=============
----------------------------================
INSERT INTO Books
(
[Id_Author],
[Title],
[Description],
[Section],
[Genre],
[Year],
[Publisher]
)
VALUES
(
4,
'Don quijote de la Mancha',
'Novela mas influyente en la lengua española ',
'Adventura',
'Novela',
'1605',
'Francisco de Robles'
);

 

-----------=============

INSERT INTO Books
(
[Id_Author],
[Title],
[Description],
[Section],
[Genre],
[Year],
[Publisher]
)
VALUES
(
2,
'The darkest forest',
'Is a novel by Brazilian author Paulo Coelho which was first published in 1988. ',
'Adults',
'Fear',
'1988',
'Bright-Books'
);
SELECT * FROM [books];

Ya que has creado tus tablas, y ya tienen registros. Podemos empezar a crear nuestros Modelos, conectarnos a la base de datos, para posteriormente acceder a ella por medio de nuestros controladores.

Volvamos a Visual Code

Como hemos visto anteriormente la estructura por defecto de nuestros proyectos Web API al ser creados en code:

part6

Por defecto tenemos la carpeta controller, bin, wwwroot y obj, que ya hemos explicado anteriormente, sin embargo, es necesario que creemos una nueva carpeta que llamaremos  Models, además de la carpeta agregaremos las clases Author.cs y Book.cs

Models, classes

  • A continuación, procedemos a agregar el siguiente código para cada una de las clases respectivamente, Author.cs:
1
2
3
4
5
6
7
8
namespace Library.Models{
public class Author{
public int Id_Author { get; set; }
public string Name { get; set; }
public string Last_Name{get; set;}
public string Email{get; set;}
}
}
  • Y por supuesto nuestra siguiente entidad que es Book.cs

Vamos a crear nuestra conexión de Base de Datos, pues ya poseemos los modelos de la Base de datos pero si no podemos acceder a estos, no estaríamos haciendo nada. Por tanto, procedemos a crear nuestro connection string.

  • No sin antes instalar los paquetes requeridos:
1
2
3
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
donet restore
dotnet build

 

  • Una vez hecho esto,  debemos agregar nuestro «Connection String» en appsettings.json
1
2
3
4
5
{
"ConnectionStrings": {
"DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=Library;Trusted_Connection=True;"
},
}

 

  • El siguiente paso es crear nuestro Data Access, para ello creamos un nuevo archivo en la carpeta Models, llamado DataAccess.cs

 

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using Microsoft.EntityFrameworkCore;

namespace Library.Models{

public class LibraryDbContext : DbContext{
public LibraryDbContext(DbContextOptions<LibraryDbContext> data)
:base (data){}

 

public DbSet<Author> Authors{get; set;}
public DbSet<Book> Books{get; set;}


}
}

 

  • Por último, debe realizarse una configuración adicional en el archivo startup.cs
    1
    2
    3
    4
    5
    6
     public void ConfigureServices(IServiceCollection services)
    {
    services.AddDbContext<LibraryDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddMvc();
    }
    

 

Ya Hemos creado nuestros modelos, el Data Access, nuestro Connection String, y el startup.cs, Aún nos hace falta la parte principal de toda API.

giphy

  • Los controladores

Qué sigue?

A fin de que aprendamos de la manera más sencilla y práctica, el siguiente artículo de esta serie definirá qué son los controladores y aprenderemos a crear los nuestros y por supuesto haremos las pruebas usando Postman.  

Accede a este link para ver ultimo articulo de esta serie: Desarrollo de API REST: Parte final