Transcripciones
1. 1. INTRODUCCIÓN: Hola a todos. Este es un tutorial sobre la API
mínima en dotnet six. Ahora, antes de comenzar
este tutorial, voy a explicar un
poco de lo que se puede esperar y lo que no
esperan en este tutorial. Entonces lo que puedes esperar
es que te voy a estar mostrando cómo somos creados
APIs en dotnet. Bien, es a tu manera. Después de la muerte,
te mostraré cómo creas, puedes crear una
API mínima en dotnet six. Para ello, estaré
creando un nuevo proyecto, así que vamos a
empezar desde cero. Así se puede ver
todo lo que se necesita para crear una API mínima, que no es mucho, de
ahí el nombre mínimo. Te estaré mostrando
un poco sobre la inyección de dependencia
y la API mínima. Además, te estaré mostrando cómo
puedes crear una API mínima asíncrona. Entonces, lo que no se puede esperar es una explicación en profundidad sobre
API y API en general. Espero que tengas algún
conocimiento de
eso porque no te
voy a decir. Además, este no es un tutorial
para C Sharp para principiantes. Si no tienes suficientes
conocimientos sobre C-Sharp, te
recomiendo encarecidamente que
sigas
primero un curso básico antes de comenzar
este tutorial. Entonces con eso, comencemos.
2. 2. Requisitos: Antes de comenzar el
tutorial o curso, suelo
decirle a la
gente qué tipo de requisitos son para
seguir el tutorial o curso. En este caso, estaré usando versión
comunitaria de
Visual Studio 2022, cual es gratuita y fácil de
descargar desde Internet. Otro requisito son
los conocimientos básicos de C Sharp. Si eres
principiante o C-Sharp, o nunca antes has programado
en C Sharp, no
es recomendable
seguir sus puntuaciones. Otra cosa que
debes tener en cuenta es
la inyección de dependencia. Debes conocer la idea básica de la inyección de dependencia,
cómo funciona, cómo configurarla
en tus programas, cómo usarla. Y el último
requisito es asíncrono. Al menos no le
dolió el término. Y sabes un poco sobre lo que hace y para
qué se usa. Entonces, si cumples con estos
requisitos que inicien.
3. 3. . API de NET 5: Como dije antes,
echemos un vistazo a esas cinco API antes comenzar con la API mínima de
Netflix para adultos. Entonces en mi pantalla tengo
adulto net cinco API abre. Este es el proyecto.
Tiene una solución. Tiene un proyecto como cada
aplicación dotnet que crees. Lo que más destaca
son los controladores de carpetas. Dentro de los controladores,
hay clases, en este caso una, que
es el controlador real. Cuando abrimos un controlador, puede ver ciertos métodos,
atributos y propiedades. Al abrir un controlador, verá la clase pública, el nombre del
controlador, que hereda del controlador. Esto es código andamiado, así que esto es lo que Microsoft te
da cuando creas una nueva API
y que está bien. No voy a crear
una nueva
aplicación dotnet find para una pequeña
pieza de información. No hay
constructor y
también hay un método que
se llama acción. Ahora bien, esto es típicamente
dotnet cinco API. Tiene una carpeta controllers, que contiene las clases, que son los controladores dentro de las acciones del controlador. Y cada acción tiene ciertos tipos de
devolución o no. Además, tenemos que
trastornar las cosas, program.cs y luego startups. Sí. Las cosas de Epstein son para la configuración
de tu Programa, que también está en dotnet six. Entonces esto no es algo de
lo que nos vamos a despedir. A lo que sí nos despedimos
es de la startup a startup dot cs es básicamente la configuración
de tu proyecto. Aquí puedes configurar si
quieres usar swagger o inyección de dependencia o
algún tipo de registro
o lo que sea, puedes configurar tu
contexto de base de datos si tienes uno con Entity Framework y mucho más, esto se moverá
al program.cs. Y el program.cs
es como, ya sabes, cada aplicación dotnet
tiene un archivo de programa dot cs. Aquí es donde realmente comienza la
aplicación. Si debo ejecutar esto, simplemente
funciona como una API normal. Se construyó, inicia tu navegador
predeterminado y
tienes API y puedes
probarlo si quieres. Bueno, eso es genial y esas cosas. Pero esto no es lo que
vamos a crear. Vamos a crear la API CICS neta para
adultos. Esa es la vieja manera. A lo mejor esto es familiar. Yo sólo quería
mostrarte por si acaso. Ahora vamos a crear la API de Netflix
para adultos.
4. 4. Crea la nueva API: Ahora ya sabemos cómo funciona el dotnet
five old way. Vamos a crear una nueva
API en dotnet six. Lo primero que hay que
hacer, por supuesto, es iniciar Visual Studio. Por lo general tendrás algunos proyectos recientes o los
eliminarás todos para
esta demostración. Pero para crear la API, vas a crear un nuevo proyecto. Al hacer clic en
eso, cargará todas las plantillas y podrá seleccionar la
plantilla que desee. En el lado izquierdo, tengo algunas
plantillas de proyecto recientes que ya contienen el
tipo de proyecto que quiero crear. Pero por diversión,
vamos a buscarlo. Quiero crear una API. Entonces en el
cuadro de búsqueda, escribo API. Hay algunos
resultados que aparecen. Las dos primeras son la API de
asp.net Core Web, y la tercera también. Solo hay una diferencia realmente
grande. La gran diferencia es,
son los idiomas. El primero es C sharp, el segundo es F sharp, y el tercero
en realidad no es el API. Es la aplicación web asp.net Core. Quiero crear una API, así seleccionaré la primera
porque quiero crearla en C-Sharp
y no en F sharp. También, en el texto se
ve Linux, macOS, windows, cloud,
servidores, web, web API. Entonces esto básicamente
significa que también puedes ejecutar esta API en un Linux
y macOS si quieres. Haga clic en Siguiente. Ahora necesito
darle un nombre de proyecto. Solo usaré un nombre de demostración, pero siempre piensa el nombre que quieres
dar porque quiere ser algo que te recuerde
lo que estás creando. Voy a nombrar a esto la demo
mínima de API. Voy a mantener la ubicación
no es la predeterminada, cuál es el
repositorio en alguna parte? Bueno, fisher studio almacena
tus proyectos por defecto. Y el nombre de la solución también
será el mismo que el nombre del proyecto. Doy clic en Siguiente. Cada proyecto tiene su propia
información adicional. En este caso, la API
necesita algunos extras. Si creas una aplicación de
consola, solo
tendrás que
seleccionar el framework. En este caso, necesito
seleccionar algunas opciones más. En este caso, estaré usando
el marco donuts six. Si lo abro, puedo
seleccionar dotnet cinco, que también dice fuera de soporte, si hago clic en la red para perros cinco, verás algunas opciones
desaparecerán a continuación. Estas opciones tienen que ver
con la API mínima. Así que vamos cinco no
soporta API mínima, y por lo tanto necesito
seleccionar dotnet seis o superior. Quiero configurarlo para HTPS, claro, habilitado más oscuro. Sí tengo Docker instalado
en esta máquina, pero no
lo habilitaré en este momento. Entonces tiene una
casilla de verificación que dice usar controladores y
verificar, usar API mínimas. Si empiezas con
esto la primera vez, esto será revisado. Si la mantienes marcada, obtendrás la caída de
ancho para controlar esto, que no es algo que
quisiéramos esta vez porque queremos
crear una API mínima. Entonces queremos deshacernos
de los controladores. Así que voy a mantener esta desmarca
Habilitar soporte OpenAPI. Es un nombre elegante para fanfarronear. Manténgalo habilitado. Porque de esta manera podemos probar
nuestra API cuando la ejecutamos. No utilice las declaraciones
de nivel superior. Esto también es algo para
dotnet seis y superiores. Puedes seleccionarlo o no. Solo lo mantendré desmarcado
para este tutorial. Si estás satisfecho con tu
configuración, selecciona Crear.
5. 5. Archivos y carpetas: Ahora tenemos que
volcar esa API CICS creada y tenemos
Visual Studio abierto. Y echemos un
vistazo de cerca a la estructura
de carpetas de estos nuevos proyectos. Vamos a acercarnos a este explorador de
soluciones. Nuevamente, tenemos nuestra
solución y nuestros proyectos, y estos son los
archivos y carpetas de andamios. No voy a
hablar de todos ellos a fondo. Solo quiero mostrarte que
las cosas que Jason todavía está disponible y
solo hay un archivo de clase, el program.cs, los
controladores de carpetas se han ido, y el startup.js
no está disponible también. Entonces, si abres el program.cs, verás que todo
está configurado en este archivo. Ahora tienes un
constructor donde se
crea la aplicación web y la forma de construir o puedes agregar servicios a
tu aplicación. Esto también significa para la hoja de trabajo de
pensiones y su contexto de base de datos y registro y otras cosas que
necesitará durante la
construcción de su API. También verás que
todo el andamio sobre el pronóstico del tiempo también se coloca en este
programa punto c. Sí. Todo lo que estaba en
diferentes clases y en un controlador ahora se coloca
en este archivo en particular. Aquí puede ver el resumen
del tipo de tipos de clima. Abajo. Es un mapa obtiene, que en realidad es un mapeo a un punto final particular
de su API. Este código estaba en realidad en el
controlador en dotnet cinco. Esto ahora está en un solo archivo. Tiene un cuerpo de
expresión lambda que
en realidad es la función que
devolverá el pronóstico, que simplemente no es
el pronóstico real. Entonces este es tu primer ejemplo de la API mínima de que
todo está en un solo archivo. Y con mapeos,
puedes crear los diferentes
endpoints de tu API. Inicie esta aplicación. Podemos ver lo que hace. Inicia el navegador predeterminado
y verás swinger. Y esto se ve exactamente igual que con la aplicación
dotnet porque aquí tengo
mi punto final para el pronóstico del tiempo.
Puedo probarlo. Puedo ejecutar. En el exterior.
Nada ha cambiado, pero por dentro ha
cambiado mucho porque ahora ya no
tengo controladores. Solo tengo un
banco de archivos y configuro, creo y administro toda mi API.
6. 6. Mappings - Preparativos: Entonces este es el
andamio básico que la información y el código para la
API en dotnet six. siguiente paso es
crear más mapeos. Tenemos un mapeo para diferentes métodos de solicitudes
HTTP. En este caso,
quiero usar el get
the post para eliminar
esto para actualizarlo. Entonces antes de hacer eso, voy a crear algunos abrigos y
preparaciones
adicionales antes de
entrar en las otras métricas. Entonces primero voy a crear una
nueva clase para una película. Dish creará un
ID, que es un int. Quiero crear un título. Así que en realidad puedo
nombrar la película. Y quiero darle una calificación,
que también es un
entero, calificándolo 1-5. A continuación, quiero crear una lista de la película oscura
que acabo de crear. Y quiero usar la película. Id es uno. La calificación es, vamos a darle un cinco. Y el título es Trek. Ni una película. Calificación Id2. Uno. El título es engaño. Nuevo. Idea. Tres. La calificación es de tres. El título es, preguntas solo
porque es muy viejo. Y nuevamente, nuevo ID es para calificación es uno y el título
es The Green Lantern. Y por último pero no
menos importante, id es cinco. La calificación es de cinco. El título es la matriz. Ahora me da una línea roja y dice que deben continuar las
declaraciones de nivel superior. Declaraciones de espacio de nombres. Vamos a mover esto. Vamos a mover
esto un poco a la cima, y el error se ha ido. Bien, entonces ahora también
vamos a eliminar el mapa obtiene y los registros internos. Mantenga la aplicación dot run. Si eliminas esa, la aplicación no se ejecutará. Y es muy importante, realmente no
me hago
más amplio raptar a John no llega tarde la última
línea integrales, sino que también se quitaron los resúmenes porque
ya no lo vamos a usar y tenemos una aplicación
muy clara. Entonces esa es la preparación. Y ahora vamos a crear los mapeos
comenzando por para obtener, que es el más simple.
7. 7. Mapa GET: Bien, así que el
primer mapeo que
vamos a crear es el Get, que también son los
métodos request, HTTP GET. Este es el más
simple porque la API
recibirá una solicitud desde el
exterior para devolver algunos datos. Y estos datos son justo
lo que queramos devolver. Lo primero que tenemos que hacer
es crear app dot map gets. Esto significa que queremos
crear una solicitud HTTP get. En dotnet five, tuvimos que agregar algunos atributos
para decirle
a la API que es un
GET o post o lo que sea. Ya no tenemos que hacerlo. Sólo podemos crear
app dot map, get. Asegúrese de crear
las nuevas asignaciones y todos los demás tipos de asignaciones
por encima de la aplicación dot run. No los cree debajo de ellos. Mapa. Obtener. El primer parámetro
es el patrón. El patrón es en realidad
el punto final de la API en otras aplicaciones puede
apuntar a, para obtener los datos. En este caso, quiero
llamarlo películas, pero es una API. Entonces voy a poner API al frente
para que sepamos que son datos. Obtenemos de una API. Agreguemos otro
slash al frente. El segundo parámetro
es el delegado learn, o en este caso el cuerpo de expresión
lambda, que ejecuta porque para
devolver este caso películas. Entonces voy a estar empezando por
una función anónima, crear registros y
decir resultados de retorno. Bien, entonces la persona que llama sabe que obtendrá un código de
estado de 200, lo
que significa que está bien. Disculpe. 204 significa que está bien. Se ha ejecutado pero no
has devuelto datos. En este caso, serán 200 porque voy a estar
regresando las películas. Y no olvides el
punto y coma al final. Este es básicamente el mapeo de API más
simple. Obtendrás. El mapa de puntos obtiene, este es el endpoint
API slash movies. El cuerpo devuelve resultados, ¿de acuerdo? Y el perímetro son las películas,
que es la lista de películas. Puedo iniciar ahora es
la API y vamos a construir e inicia el navegador
por defecto. El pronóstico del tiempo se ha ido. Ahora vemos las películas de la API slash. Puedo hacer clic en él abrir,
probarlo, ejecuta. Y lo tengo. Estas son mis películas. Entonces este es el mapa. Consigue el más simple. Y pasemos a
algo diferente. Consigamos una película por identificación, que también es una solicitud GET. Por cierto, un
parámetro en la URL.
8. 8. Mapa GET con parámetro: Entonces el siguiente es el mapa de
moverte con un perímetro, en este caso la identificación de una película. Lo que quiero crear es el, puedes obtener una sola
película de la API dado un ID en el punto final, es bastante similar a
lo que obtiene
el mapa anterior. Así que en realidad puedo
copiar y pegar esto. Y lo único que voy a cambiar es agregar
un
ID de corchetes en el punto final
de las películas, y tiene que haber una
raya delante de ella. Ahora creo un
punto final que dice películas
API y el
ID de una película. Y la siguiente parte es que
en una función anónima, voy a incluir el perímetro
en este caso id La API notará que
hay un parámetro extra
y luego apuntará, intentará hacer un análisis de ese
perímetro a un entero, y luego podré
usarlo en mis métodos. En este caso, devuelven
resultados, ¿de acuerdo? Películas quemadas, identificación única
equivale a dar una identificación. Eso es básicamente todo. Ya puedo iniciar la API. Veo una segunda API de punto final,
películas, ID de corchetes y corchetes. Puedo abrirlo,
probarlo para ID, elegiré ejecutarlo. Y ahí tenemos nuestra
película con identificación a. Puedo cambiar la identificación
a cuatro, ejecutar, y voy a ver la película
con una identificación para este caso, típicamente, la Linterna Verde.
9. 9. PUBLICACIÓN de mapa: Entonces la siguiente parte es
sobre la publicación. En algunos casos se quiere publicar datos de los
clientes a la API. Y para preparar la API
para una solicitud de post, vamos a mapear el post. Para crear esto, simplemente creamos un nuevo mapa de puntos, mapa presumir. Y tiene el mismo punto final. O para iniciar películas. Y eso es todo porque
quería enviar
una película a las películas de la API de
endpoint. En un breve solo
mapeo en el ID, tuvimos que crear
parámetro en la URL. En este caso relevó
el endpoint como S, en este caso, películas API. Pero voy a agregar el tipo de clase Película con un nombre en la
lista de parámetros de mi cuerpo. En este caso, la
API sabe que cuando se al punto final de películas API con llama
al punto final de películas API con
los
métodos post request, debe
haber un objeto en el cuerpo que represente
la clase Movie. Fui a puntos. Puedo continuar en este caso, puedo decir películas,
impresión, película publicitaria. Y eso es todo. Normalmente con un jefe, no devuelves datos y
tal vez solo se crea un objeto. Para fines de demostración, utilizaré una devolución y devolveré
todas las películas. Por lo que puedes ver que la película ha sido agregada a
la lista de películas. Así que devuelven los resultados. Bien. No olvides el punto y coma
al final de la fila. Y vamos a ponerla en marcha. Entonces ahora tengo tres
puntos finales que conseguir. Un post y el posttest,
el que acabamos de crear. Puedo abrirlo. Puedo decir que pruébalo. Y el cuerpo de la solicitud es
básicamente adyacente. Bueno, las identificaciones suelen
crearse por sí solas. En mi caso no lo hace. Entonces estaré agregando mi propia identificación
y estaré usando ICD-9. El título es de los Muppets
y la calificación es de cinco. Eso es. Esto es lo que se
publicará en mi API. Yo sí ejecuto. Y
el código es 200, que son los resultados, pero bien. Y al final está ICD-9, los Muppets calientan cinco. Entonces ahora he publicado
datos en la API. Si volví al punto final de películas
API, pero para los
métodos de solicitudes GET, ejecuto ese. Volveré a ver a los Muppets porque no lo hice
para no cerrar mi API. Entonces todavía está en la memoria en
la lista cuando apagué la API y empezaron a
reiniciar ICD-9, los Muppets se habrán ido.
10. 10. BORRAR mapa: Ahora hemos creado tres
puntos finales para un gas, obtener mi identificación y un alarde. El siguiente momento
será el borrado. Este enviará
una solicitud de eliminación a la API para que la API sepa
que algo será eliminado. La eliminación de mapa, que es la asignación para el
punto final para la eliminación, es bastante similar a
la anterior. Voy a crear un mapa de
aplicaciones, eliminar. Y el punto final
será el mismo que el post y
el primer GET que creamos. Y detrás de él, voy a crear
el perímetro para ID, y voy a hacer que
sea un entero que es lo
mismo que la puerta por ID. No hay conflicto entre estos dos
puntos finales porque
están separados por los métodos get y
delete requests. Entonces, si envié un método de
solicitud GET con un id en el punto final, recibiré y veré la
película con un ID dado. Si utilizo la misma URL o puntos finales y lo envío con un
método de solicitud de eliminación a la API, esa película en particular
será eliminada. agregaré el ID en la lista de
parámetros. Para que pueda usarlo en mi cuerpo. Y esto es básicamente de conocimiento
común. Si estás trabajando
con C-Sharp, películas, quita películas, single,
y encuentra el ID. Y eso es todo. Esta es la forma
normal de eliminar
un elemento a través de una API. No devuelves nada. El cliente recibirá
200 chicas que está bien o 204 o errores como 400's, 500's Eso es todo lo que necesitas
saber del lado del cliente. Pero en nuestro caso,
queremos ver si realmente funciona. Entonces voy a estar devolviendo
los resultados. Bien. Películas. Todo bien. Eso es. Vamos a probarlo. Voy a poner en marcha la API. El navegador predeterminado
se abre de nuevo. Y ya verás por
puntos finales para obtener el, obtener la publicación y eliminar. Para conseguir, voy a ampliar los
leads, voy a probarlo. Y eliminemos
película con ID dos. No tengo idea de qué película
esta pero bien, ejecuta. Y en este caso, veo que el primero
es Shrek con id uno, y el segundo es
jaws con ID tres, y el ID dos ha sido eliminado. Así es como borro trabajo.
11. 11. PUT de mapa: El último mapeo que vamos
a crear es la actualización. O más bien
se está utilizando el pie para indicar que quieres cambiar
un objeto o valor existente. La salida es en realidad lo mismo que alardearse excepto que
cambias mi mapa de póster. Entonces en este caso,
mapear ambos puntos finales. Solo películas API y
agregaré película en
la lista de parámetros. Si desea actualizar
un objeto existente, necesita saber
dónde encontrarlo. Entonces, asumo que la identificación
se ha llenado de la película. En este caso, tengo que obtener el objeto existente
de la lista. Encontrado. Película es
películas single dot ID. Y ahora puedo cambiar
el contenido
del archivo en movimiento. Entonces, por ejemplo, clasificación de
movimiento es igual a
la clasificación de la película que se está jactando de
rendimiento para la API. Y eso es todo. Por lo general se
tiene Entity Framework para manejar los cambios y personal, pero en este caso, Justin list, ahora
puedo decir devolver resultados. Bien, películas. Bien, y vamos a ponerlo en marcha. A ver si funciona. Escucho mis botas
y una expandida. Pruébalo. Cambiemos
el título de la segunda película. Puedo dejar un vacío porque no
estoy actualizando eso. Y la calificación se establece en cinco. Vamos a ejecutarlo. Regresando todas las
películas. Y aquí vamos. Id2 es el título, inicio. Lo he puesto a
uno aleatorio y ahora son cinco. Y con eso concluye
el orden de actualización.
12. 12. Agregación de inyección de dependencia: Entonces ahora hemos discutido las necesidades básicas de la
API en dotnet six. Tenemos que hablar sobre
la configuración general y cómo podemos crear
endpoints a través de mapeos. siguiente elemento de la lista es la inyección de
dependencia, algo que nosotros como desarrolladores
usamos mucho en nuestro código. Y una API amino también
acepta el patrón
de inyección de dependencia. Y cómo podemos hacer esto es casi lo mismo que en dotnet. Bien. Simplemente no lo hagas en una startup
porque no está ahí. Ahora tenemos que
configurarlo en el program.cs. Entonces, antes que nada, hice algunos cambios en mi aplicación. Vamos a recorrer eso
primero antes de que te voy a explicar cómo puedes usar la inyección de
dependencia. Entonces esta es mi aplicación y creo una nueva lógica de carpetas. Y dentro de la carpeta
hay dos archivos, dossier de
película y punto de superficie de
película. Entonces ahí está la
película sí dice que sí. En realidad objeto película que anteriormente
estaba en
el program.cs, Pero lo moví a este archivo. Y los servidores de películas
es una clase que encarga de todo para las películas. Cuando abrí eso,
hay una lista privada de películas que contiene las mismas
películas y el program.cs. Y hay algunos
métodos en este caso, eliminar, obtener todos, obtener
por ID e insertar. Quité la actualización porque solo quiero que sea
breve y simple. El program.cs ha
sido limpiado. Aquí inicializo el
servicio de películas en una variable. Cambiemos el nombre de eso para propósitos
obvios. Lo cambié de nombre a
servicio de películas cuando un pequeño m. y cambié todos los cuerpos de
los puntos finales con servicio de películas en lugar de una lista de películas porque ya no está aquí. Así que eliminé la
clase Película y la lista de
películas de este archivo y
las moví a la lógica de carpetas. Bien, Genial. Para crear la inyección de penitencia, necesitamos una interfaz. En este caso, quiero crear una interfaz
del servicio de películas. Hay menos métodos públicos que necesitan estar en la
interfaz son los primeros, voy a crear una nueva interfaz
en la lógica de archivos, y lo llamo servicio de películas. Y yo sólo voy a copiar, borrar, y luego al
menos moverme. Y luego muévelo. Buena, mala idea e insertos. Bien, y estos son vacíos. ¿Bien? Tienen interfaz. Ahora voy a conectar
la interfaz con la clase Movie Service.
Y lo agregaron. Entonces ahora tengo una
interfaz conectada a la clase de servicio de películas. Vuelvo al program.cs y voy a empezar a
buscar el servicio builder dot, sobre todo porque ahí es donde configuramos nuestra inyección de
dependencia. Entonces lo que suelo
hacer es buscar el anuncio swagger gin
y por debajo de eso, voy a escribir
servicios de relleno con alcance. Bien, Servicio de mudanza y conéctelo a la clase de servicio de
películas. Eso es. Ahora hemos configurado nuestra inyección de dependencia
para el servicio de películas. Pero, ¿cómo lo vamos a
utilizar en nuestros endpoints? Básicamente, lo pones en la lista
de parámetros de la función. Comencemos con
el más simple, el map.get o map get rich tiene un
punto final de películas API, una lista de parámetros vacía y return que también vino. Servicistas, agárrense a todos amigo. Estos serán muy simples
porque estaré inyectando la interfaz en la lista de
parámetros del cuerpo. Entonces en este caso,
I Movie Service, le
voy a dar un nombre,
Movie Service. Da un error. Ahora, puedo dejar esto igual porque
son uno a uno. He inyectado el
servicio iMovie en mi método. Cómo funciona
con la segunda,
que es la midgut, y puedo conseguir una película
por ID, muy simple, int id comma i movie
service. Y funciona. Simplemente puede poner la inyección de penitencia detrás de
la lista de parámetros de las consultas de punto final u
otras partes de la acción. Lo mismo va para el puesto. Tengo aquí una película
que está siendo publicada por un cliente en el servicio de películas API
coma, servicio películas, y eliminar. Lo mismo que la puerta por identificación. Ya da la pista, tal vez quieras que el
iMovie sirve. Yo quiero. Y ahora ya está hecho. Puedo quitar la realización
del servicio de películas. Y sigue funcionando si solo
presiono F5 ahora
, iniciará la API. Y se puede ver
si realmente funcionó. Todavía veo todo
mi punto final aquí. Y probemos el se
seca, ejecuta. Y sigo viendo todas mis películas. Intentemos presumir, pruébalo. Id nueve Muppets, y
la calificación es de cinco. Ejecuta. Como pueden ver, se ha
agregado a esa lista los Muppets. Por supuesto, este
no es el mejor ejemplo para la inyección de dependencia
porque estoy usando, estoy configurando la inyección de
dependencia y utilizándola directamente. Por lo general está por todas
partes y eso está bien. Pero como
inyección de dependencia en pocas palabras.
13. 13. Haciéndolo ASYNC: El último capítulo de este curso
trata sobre hacer de API un sumidero con medios que la API pueda manejar múltiples solicitudes
al mismo tiempo. Y eso hace que la API sea un
poco más rápida para que tus acciones y métodos sean asíncronos, tenemos que cambiar
un poco de los objetivos y es realmente fácil. En realidad no
es tanto trabajo. Lo primero que quiero hacer
es ir a la interfaz y hacer todo
preparado para un canta. Entonces voy a estar agregando tarea
a todos los métodos. En este caso lista de tareas en movimiento. Me estoy moviendo. Y cambia la voz a anochecer. Bien, eso es fácil. Ahora ve a la superficie y
verás que se rompe
porque la implementación
del servicio ya no es lo
mismo que la interfaz. Entonces cambiemos
éste también rápidamente. Nuevamente, esto es
algo que debes saber antes de
comenzar este curso, y necesito hacerlo todo asíncrono, lo contrario no funciona. Entonces eso es solo una acción de
copiar y pegar. Porque esta es una demo sobre
hacer algo asincrónico. Por lo general, algo dentro del
método debería estar disponible. Bueno, este no es el caso, pero hago que todos los métodos
asíncronos los esperen en la API, que es todo el punto
de esta demostración. Bien, así que ahora todo está
preparado para tareas asincrónicas. Vuelvo al program.cs. Aquí no se puede ver
nada cambiado. No hay
advertencias, no hay errores. Pero si pongo el cursor sobre, simple consigue todo,
verás que está disponible. Así que sólo puedo escribir
aquí y esperar. Acerca de la deuda no
funciona porque alguna manera siempre se necesita usar dentro de un método asincrónico y este método o el
cuerpo no es asíncrono. Entonces para hacerlo asíncrono, simplemente escriba asincrónico aquí,
y luego funciona. Entonces ahora veo que el servicio de películas dot insert también
está disponible. Entonces hicimos esto también. Entonces puedo hacer que todo sea
asíncrono simplemente agregando asincrónico a todas las expresiones lambda y hacer que los métodos de
servicio de películas. Voy a esperar. Eso es. Entonces ahora inicio la API
y sigue siendo la misma. No ha cambiado nada. Ejecutemos el
get para probarlo, ejecuta. Y lo tengo. Puedo hacer esto lo mismo para
el otro punto final también. Pero creo que entiendes el punto. Así es como haces que
la API mínima sea asíncrona.
14. 14. Conclusión: Bueno, eso concluye nuestra API
mínima en dotnet six. Es una excelente manera de crear API
más pequeñas con menos chicas. Y no se ha desmoronado? A mí me gusta menos el código. La desventaja es que si
tienes una API realmente grande, tienes un archivo grande
con todos los endpoints. Entonces lo que pasa es que la
gente va a
esparcir los diferentes puntos finales a
lo largo de diferentes archivos. Y luego básicamente crear controladores de nuevo, realmente
no funciona. Creo que sí si tienes pequeñas
APIs y microservicios, pero no para los
proyectos más grandes donde tienes una API realmente grande que
maneja muchas solicitudes. Gracias por ver. Espero que hayas
aprendido algo. Si tienes alguna
duda, solo
avísame en los comentarios
o envíame un mensaje. No olvides seguirme para más tutorial viniendo
en un futuro próximo. Gracias y adiós.