Transcripciones
1. INTRODUCCIÓN: Hola y bienvenidos a mi curso, ASP.Net Core desarrollo mínimo
API. Soy tu instructor de guerra Williams y soy ingeniero de
software y conferencista y
he estado haciendo esto 12 años. En este curso, vamos a obtener una comprensión de cómo
desarrollamos API mínimas
usando dotnet six, vamos a entender verbos API
enteros
funcionan secuela entera, light y Entity Framework
Núcleo combinado para darnos un lugar para almacenar
y recuperar datos. También veremos la
inyección de dependencias y los
documentos completos de swagger nos ayudan a
interactuar con nuestra API. Lanzar este curso van
a estar usando Visual Studio 2022 y secuelas Para dotnet. Y se
requiere Visual Studio 2022 para usar dotnet six. Es un IDE totalmente destacado
y extensible, y es muy potente
y nos permite hacer mucho más por el desarrollo. Entonces sin más preámbulos,
comencemos.
2. Descripción de la API: Hey chicos, bienvenidos
al inicio de esta nueva sección
donde estaremos trabajando en una API RESTful para
complementar nuestra app móvil. Entonces miramos todos los
conceptos básicos de Maui ya. Pero ahora queremos ir
a construir una aplicación real. Y en términos generales, las aplicaciones
móviles se comunica con APA es por eso
que muchas de ellas requieren acceso a
Internet. Ahora si no estás tan familiarizado
con lo que es una API, te
voy a guiar a través
de algunos de los conceptos básicos en este momento. Y si realmente quieres
profundizar en más de
los detalles que puedes consultar mis otros
cursos donde te traigo a través del timbre
con diseño de API. Pero para este curso lo
vamos a mantener lo suficientemente
simple como para que
podamos poner en marcha una API y ver
cómo podemos consumir e interactuar con esta API
a través de nuestra aplicación móvil. Ahora estamos construyendo
una API RESTful. Y muñeca es un acrónimo de Transferencia
Estatal Representacional. Esencialmente es un estándar
abierto que
permite que cualquier tipo de cliente pueda
interactuar con algún endpoint y acceder a algunos, lo que llamaremos recursos de TI. Por ejemplo, tomemos una
aplicación como Facebook. Estamos facebook en
nuestro teléfono móvil, o si está en nuestro Internet, nuestros navegadores de Internet, lo
tenemos en diversos dispositivos y
tenemos apps para Android, para iOS, etcétera. El hecho es que cada una de estas aplicaciones no es factible,
construida desde cero. En realidad es solo
interactuar con una API que Facebook ha desarrollado
y sigue desarrollando. Y es por eso que cuando
te levantas actualizaciones, lo que tal vez lo que hacen se
quede en algo, la API y tienen que
actualizar la forma en que arriba interactúa con esa API. Pero esencialmente, la
inteligencia descansa en la APA. Y luego porque es
un estándar abierto, no importa si
se trata de un dispositivo Android o un dispositivo Windows, o tu teléfono móvil, o tu reloj móvil o
tu reloj inteligente más bien. Todos ellos pueden interactuar con
este API estándar abierto o servicio
web que generalmente se ajusta al resto del estilo
arquitectónico. Cuando hablamos de
APIs y APIs reparadoras, hay ciertos
conceptos con los que queremos
asegurarnos de estar
cómodos. Una es uniforme, lo
que significa que hay una forma estándar formular tus URL
y atender esas llamadas. Aún es menos. Por lo que generalmente no
encuentras que las cookies y otros archivos se generan en el dispositivo para
soportar la API. Llamada se hace una vez que
llamo a esto terminado, se olvida de ello. No hay nada realmente
aguantado, ¿verdad? Es cacheable, lo
que significa que a veces
tienes inflamación que
siempre se está solicitando. Entonces en lugar de ir a la base de datos o a la
tienda de datos, cada vez, ponemos allí un efectivo para que la API pueda responder
más rápidamente con inflamación a la que
se
accede con más frecuencia y en general
no cambia tanto. Está en capas. Por lo que tienes diferentes
partes y capas a la API para restringir lo que se
puede hacer en diferentes niveles. O el recurso generalmente
representa bits de datos o un objeto entre la base de datos y la aplicación
cliente. Y en
términos generales, cuando estás nombrando tus endpoints de
API RESTful, quieres ser autodescriptivo. Entonces si es un punto final para lidiar personalmente con
la inflamación, entonces quieres
asegurarte de decir inflamación de la persona. Entonces esos son sólo principios. A continuación tenemos
los métodos HTTP. Ahora tenemos diferentes métodos en las formas de get,
put, post, delete. Esos son los más populares que verás que se usan. Hay otros. Pero en términos generales, cuando estamos lidiando
con un Datastore, queremos llevar a
cabo para operaciones. Generalmente llamamos a esa
multitud operaciones. Queremos crear
datos en la base de datos, queríamos recuperar los
datos en la base de datos. Queremos hacerle cambios o
actualizarlo, y queremos
eliminarlo o eliminarlo. Por lo que ver DIU. Así que consigue maneja la
recuperación
cuando se quiere ver el registro
o un montón de registros. Poner I GET request, put es la u, que es actualización. También tienes parche, pero ese es un tema
para otro momento. Poner el más
fácil de implementar, estaremos trabajando con eso
para nuestros fines aquí. Pero enviamos
solicitudes PUT siempre que queramos hacer una
actualización a los datos. Tenemos la solicitud de post
siempre que queramos crear datos. Y luego tenemos las solicitudes de
eliminación, que creo que es
autoexplicativa, si no la más
autoexplicativa, una de todas ellas, entonces
tenemos la respuesta HTTP. Entonces esas fueron las peticiones
que acabamos de mirar. La respuesta es lo que
el servidor devuelve. Entonces generalmente tenemos uno XX
y XX solo significa número, números como 100,
entre ciento ciento noventa y nueve. El eje x representa
cualquier cosa del 00 al 99100. Los códigos de estado
generalmente hablan de comunicación sobre
protocolos de transferencia a 100. Generalmente alcanza el éxito
en la operación. 300s fue que
hubo una redirección. 400 muestra que tal vez hubo algún mal centro de datos
o del cliente. Entonces al usuario mid se envían datos que el
servidor no pudo procesar. Y así diríamos que fue malo, una mala solicitud o
solicitaste algo que no se pudo encontrar
como un error 404. Estoy seguro de que todos pueden identificarse
con un error de fluoróforo. Y luego tenemos el error 500, lo que significa que el servidor
está donde estaba el problema. Entraron los datos, pero
tal vez no llamaste a ese
problema de conectividad de base de datos o se hizo el servidor, entonces la API respondería
con una respuesta 500. Entonces esas son
cotizaciones de respuesta general y es muy importante conseguir esos
derechos en un buen diseño de API. Entonces todo esto para ver que
nuestra API servirá como punto
de interacción entre nuestra aplicación móvil y
alguna base de datos central. Todo lo que hacemos
en la app móvil, queremos que fluya a
través de la API porque ahí
estará la inteligencia
real y eso es en lo que
vamos a empezar
este viaje. Entonces en esta sección
estamos iniciando el diseño de API y
caminaremos a través de lo básico, haciendo lo suficiente para ponerlo en
marcha y entenderlo una vez más, si quieres más detalles, tú puede echar un vistazo a ese
curso última guía de desarrollo de API de ASP.Net
Core. Puedes comprobar eso hacia fuera para
todo lo que necesitas saber sobre el
diseño adecuado de API desde cero. En este curso, lo estamos
manteniendo sencillo. Entonces en la siguiente lección
vamos a configurar nuestro proyecto API y
hacer rodar la pelota.
3. Proyecto de configuración: Muy bien chicos,
bienvenidos de nuevo. Así que vamos a saltar a la derecha en ella. Vamos a abrir
nuestro Visual Studio 2022 y vamos a proceder
a crear un nuevo proyecto, pero quiero una solución vacía. Por lo que prefiero empezar
con una solución vacía. Para que sean
solución en blanco más bien, para que pueda darle
un nombre a la solución y luego agregar los
proyectos después. Entonces vamos a estar trabajando en una aplicación
móvil de carrito de compras, ¿verdad? Entonces lista de carrito de compras, así que sólo voy a
decir lista de carrito de compras. Ese es el nombre
de la solución. Para que podamos seguir adelante
y crear eso. Ahora una vez que tengamos la solución, voy a crear
un nuevo proyecto. Entonces voy a simplemente
directamente la solución, Añadir Nuevo Proyecto. Y luego podemos agregar
una API proyectos. Solo voy a
buscar una vez más la API. Y luego voy
a ir con una API web de C-sharp ASP.Net Core. Y luego voy a llamar a
la lista de carrito de compras dot API. Entonces le pegamos a Next. Y ahora aquí hay algunas opciones
interesantes para nosotros. Y como dije,
quiero mantenerlo relativamente sencillamente,
simple para nosotros. Uno, vamos a estar
usando dotnet Core six ahora con Visual
Studio 2022 preview, puedes volver a cinco,
que al momento de
esta grabación ha
llegado al final de la vida más o menos así que tú probablemente no
quiera ir allí. Dotnet Core de tres puntos uno
todavía tiene soporte a largo plazo, también lo hace dotnet six y
dotnet siete está en vista previa. Por razones de estabilidad, voy a proceder con dotnet seis. Y podemos poner en un tipo
de autenticación. Pero por ahora, simplemente escojamos ninguno porque
lo haremos manualmente más adelante. Podemos configurar para HTTPS, no
necesitamos más oscuro. Ahora, aquí es donde se
pone interesante. Podemos optar por usar
controladores o podemos desmarcar, para que podamos usar API mínimas. Tradicionalmente
siempre usaríamos controladores, pero creo que este
sería un buen momento para intentar ver cómo se ve la API
mínima. Sobre todo porque esta es
realmente una aplicación ligera, pero podría
crecer en nosotros de todos modos. Entonces voy a desmarcar ese untick use controller para que podamos usar API mínimas, dejar soporte de API abiertas. Y entonces la siguiente opción que es bastante interesante sin embargo, es si queremos o no
usar unas declaraciones de nivel superior. Entonces con dotnet six, las declaraciones de nivel superior
habrían sido como la función principal y el espacio de nombres
principal y así sucesivamente. Por lo que ciertas personas
habrían dicho que prefieren
verlo hecho en seis, introdujeron clases de
estilo mínimo donde no necesariamente necesitas ser
tan explícito en la parte superior. Para que puedas, puedes elegir
cuál quieres. No voy a usar las declaraciones de alto nivel
porque me gustan así. Y acabaré de golpear Create. Muy bien, ahora tenemos nuestro proyecto
API creado. Entonces si voy a program.cs, nota si estás acostumbrado a ver la carpeta de controladores
en tu desarrollo de API, no la vas a ver aquí
porque desmarcamos
los controladores estadounidenses. Si optas por usar controles, no hay problema, deberías
poder seguir lo largo bien. Pero porque estamos
haciendo API mínimas, o elegí las plantillas
API mínimas. Lo que pasa es
que vamos a ver todo sucediendo
aquí mismo en ese program.cs. Entonces, una vez
que se ejecuta un programa, construye todas
las dependencias que necesita. Y luego va
directamente a ejecutar el código o saber qué codificación se
ejecuta y luego se ejecuta. Por lo que la API se sentará allí
y esperará solicitudes y todo se está ejecutando desde nuestro program.cs más o menos. Sólo voy a ejecutar
esto para asegurarme de
que esté arriba y funcione. Y lanzará este navegador
mostrándonos nuestro doc Swagger. Entonces, debido a que elegimos el soporte de API
abiertas, automáticamente tenemos
swagger integrado en nuestra API. Entonces, una vez que ejecutemos esto,
veremos la documentación. Por lo que cuanto más
habilidades de puntos finales es más de este documento se expande
automáticamente. Entonces eso es todo para nosotros creando. Cuando volvamos,
estableceremos la política del curso.
4. Configuración de la política de CORS: Muy bien chicos, así que
en esta lección estamos configurando nuestra política de cursos. Y tiendo a hacer esto como
una de las primeras cosas. En cualquier momento construyo una API, ¿por qué? Bueno, se
supone que la API por diseño debe ser consumida
por otros clientes. Otros son clientes que pueden no estar
necesariamente en el
mismo servidor que la APA. Ningún automóvil es un término general de
seguridad para cualquier app que esté
alojada en Internet. Y en términos generales,
esta política dictaría recursos
enteros diferentes son solicitudes
diferentes más bien, pueden ser facilitadas por
la app que se solicita. Todo eso para ver. La política del curso
nos permite rechazar solicitudes de ciertas fuentes son todas las
fuentes son unas bajas solicitudes. Entonces cuando tenemos el
móvil en algún otro lugar, o 60 millones de
aplicaciones móviles en todo
el mundo y nuestras API
en un servidor en algún lugar. Necesitaríamos tener una política de
cursos que decir, bueno, no sé, no puedo hacer un seguimiento de
60 millones de solicitudes y
60 millones de teléfonos móviles. Así que sólo permitiré
que alguien me hable. Por supuesto, podemos sumar otra
seguridad a otro nivel. Pero por ahora, solo usaremos política
del curso para
asegurarnos de que podamos facilitar las solicitudes provenientes de
aplicaciones móviles después del hecho, ¿verdad? Subiremos a esto es lo que las líneas siete en el program.cs. Y como dije en
la última lección, no
elegí usar
las declaraciones de alto nivel. Así que sólo se pone directo
al grano, ¿verdad? Simplemente inicia el
código porque ya sabe que es
el program.cs, por lo que no necesita
declarar int,
void, clase de programa,
etc, etc. Así que no clase nula, ¿
sabes lo que he visto? Así que vamos a entrar en ella. Por lo que decimos constructor puntos
servicios, punto, agrega autos. Justo ahí está. Y lo que vamos
a hacer aquí es configurar algunas opciones que
guiarán la configuración. Muy bien, entonces dijimos Opciones
y luego usamos llaves rizadas. Y déjame hacer
esto un poco más grande. Asegúrate de que podamos ver
darme un poco más realista. Se asegura de que todos podamos ver lo que está sucediendo con claridad. Muy bien, así que construye los
servicios de puntos que agregan CORS
en la web u opciones. Y luego dentro de nuestras
opciones van a tener opciones, punto, add, política. Entonces esta es nuestra política de rumbo. Tenemos que darle un nombre. Así que sólo voy a decir un bajo todo porque no estoy dispuesto
a poner ninguna restricción. Entonces sí, literalmente
va a ser Hola a todos. Y entonces voy a empezar
otra expresión lambda. Apenas ver un Lambda. Y entonces esto es como funciones de
un constructor, así que sólo voy a decir un punto y luego puedo decir
permitir cualquier encabezado. Entonces eso significa cualquier tipo
de solicitud que
entra , se tira, etcétera. A pesar de que comenzó,
ver cualquier origen. Dondequiera que esté,
que se
origina de, siendo las
solicitudes son bajas, y luego puedo ver un bajo, cualquier método realmente
permitir que cualquier método es el método HTTP que está entrando en
encabezado es diferente. Me disculpo, el encabezado está arriba
partes del cuerpo de solicitud. Y a veces ciertos
bateadores podrían ser milicias. Por lo que sólo vamos a seguir cualquier encabezado, permitir, cualquier método, etcétera y ahí vamos. Entonces esa es la política
que hemos establecido. No, tenemos que dejar que
el middleware, así que aquí es donde
construimos nuestros servicios. Pero entonces el
middleware comienza en la declaración up aquí. Y se dio cuenta de que la
variable aquí cambia, ¿verdad? Es, o el
nombre del objeto cambia, está arriba en lugar de
puntos de Builder, servicios o lo que sea. Y entonces lo que
tenemos que hacer es que
sepa al AppBuilder que debe usar núcleos. Entonces tiendo a poner esto
debajo de eso. Así que sólo voy a
decir hasta usar núcleos. Entonces usa el
middleware cors y por favor aplique la política que fue
creada llamada baja. Muy bien, así que ten cuidado errores tipográficos en ese punto porque
eso es un cuerdas mágicas. Por lo que podría terminar depurando
nada si siente derramar estos dos
carros a la derecha. Entonces eso es realmente por
establecer nuestra política de cursos. Puedo parar aquí porque en realidad no
hay ninguna forma tangible de validar
esto en este punto. Fuera de tal vez
ejecutar la API, tratando de alojarla
en algún lugar y luego intentar acceder
a ella desde
otra máquina. Entonces esa es realmente
nuestra política de rumbo. Ya he explicado por qué lo
necesitamos para hacer esto. Entonces, cuando volvamos,
seguiremos construyendo nuestra API.
5. Configurar la base de datos SQLite: Hola chicos, bienvenidos de vuelta. En este episodio vamos
a construir nuestra base de datos. Normalmente, por supuesto,
para una aplicación que se va a escalar
para un uso grande, desea utilizar una base de datos de grado
empresarial como Oracle o
Microsoft SQL Server. Y luego la herramienta de mapeo
relacional de objetos insignia, o la, la biblioteca que dotnet Core nos da la
interacción con la base de datos. El buque insignia es
Entity Framework Core. Sé que tiene conectores
para muchas otras bases de datos, así que no
te estoy diciendo que tienes que usar la base de datos que
estoy a punto de usar, pero
lo estoy manteniendo bastante simple, pero te voy a explicar el concepto general
a ti para que puedas apreciar por qué estoy
tomando estas decisiones. Entonces para este curso, solo
voy a usar una base de datos de
secuelas que
simplemente se sentará dentro de la
carpeta con la APA. Pero una vez más, en una aplicación de
nivel empresarial, querría conectarse a
algún servidor remoto para una base de datos de grado empresarial
como Microsoft SQL Server. Entonces para conseguir Entity
Framework en nuestro proyecto, voy a hacer clic derecho el proyecto y luego
ir a los paquetes NuGet. Y entonces sólo
vamos a ir a
Browse y voy a
buscar Microsoft dot Entity
Framework Core, secuela luz. Una vez más, si quieres
usar una base de datos diferente, así que tal vez ya
sepas cómo
conectarla a SQL Server. Entonces solo buscas Microsoft pero Entity
Framework Core, y verías morir
los diferentes para SQL Server, para mi SQL, etc. Por lo
general, el nombre es consistente donde solo
dices Entity Framework, Core, duct, y el
ingeniero de bases de datos, prefieres. Entonces encontrarías
las bibliotecas. Alguien para descargar. Entity Framework Core
hace secuela luz, y eso vendrá con
algunas bibliotecas adicionales. Así que déjame seguir adelante y
descargar e instalar eso y aceptar
todo lo que surja. Para esto, también
necesitaré otra biblioteca, que es Microsoft dot data
dot secuela light dot core. Para que pueda seguir adelante
y agarrar esa. Y eso me permite hacer algunas
otras operaciones importantes. Voy a seguir adelante e instalar eso. Ahora vamos a saltar de nuevo a nuestro program.cs y luego
empezar a cablear esto. Así que sólo voy
a poner en algunas configuraciones y luego te voy a caminar a través de ellas. Entonces lo que estamos haciendo aquí es
que estamos configurando una carpeta. Muy bien chicos, así que
vamos a saltar de nuevo a nuestro program.cs. Y sólo voy a poner en algunas
líneas de configuración y luego te guiaré por lo que
está pasando cuando estoy configurando la ruta de la base de datos. Entonces la ruta de la base de datos sólo
va a ir a la carpeta raíz y crear un archivo llamado carrito de
compras dot db. Entonces la cadena de conexión solo
estoy llamando a
una con para abreviar, es igual a una nueva conexión
SQL lite. Por supuesto, a medida que avanza, necesitarás incluir algunos
desaparecidos usando referencias. Por lo que sólo incluirlos
como los ve. Y la fuente de datos va
a ser igual a la ruta DB. Y luego decimos construir
servicios en el contexto DB. Y tenemos
carrito de compras DB context, el cual tiene una línea roja
porque aún no existe, pero adelante y
póngalo sin importar. Y luego ponemos en
la opción de que estamos usando secuela ITE, y esa es nuestra conexión. Muy bien, para que podamos
crear este archivo. Simplemente controlaré puntos y lo generaré
en un nuevo archivo. Entonces entonces tenemos el carrito de
compras DB context. Ahora voy a
conocer en primer lugar a este público y luego voy a hacer que sea
heredado del contexto DB. Entonces una vez que hagas eso, por
supuesto poniendo cualquier faltante, faltando usando
referencia en consecuencia. Entonces ahora que tengo
estos contextos
DVI, quiero nuestro constructor. Y entonces este
constructor va
a inicializar nuestro tick en el contexto DB, opciones de
contexto DB. Y esas opciones se
tomarían como su tipo. Sólo vamos a llamar a eso Options y luego pasaremos
eso a la base, ¿verdad? Entonces esencialmente lo
que estamos haciendo es inyectar las opciones que vienen
desde nuestro program.cs. Y estas serían las
opciones aquí, se ve la luz. Y simplemente
lo estaban pasando a la base, que es el contexto DB
que estamos usando. Cql ITE. ¿ Está bien? No, realmente sólo
necesitamos una mesa. Así que sólo voy a decir prop. Y luego voy a
crear un nuevo tipo de datos. Simplemente lo llamaré carrito
de compras. Y llamemos a esto carritos de
compras. Muy bien, así que si estamos construyendo una
aplicación móvil, piénsalo. Estás construyendo una aplicación
móvil para ayudar a las personas a compilar lo que
quieren cuando van de compras. Eso es esencialmente lo que
estamos haciendo aquí, ¿verdad? Entonces más adelante a medida que evoluciona la app, podríamos querer
ponernos como alguna manera de
identificar a qué registro de
carrito de compras pertenece, a qué usuario o
cuál usuario tiene esos
intereses en dos. Pero como dije, lo estoy
manteniendo muy sencillo. En este punto a medida que evolucionamos, podemos poner en cosas más lujosas. Y pongo esto en
el lugar equivocado, eso no debería ser
en el constructor. Me disculpo, eso debe
ser después del constructor. Ahí vamos. Entonces esta es la propiedad
en el contexto EB. Dentro del Framework Core, tendré que hacer es poner
en las propiedades. Y en realidad esto debería ser
DB conjunto de tipo carrito de compras. Entonces preguntándose por
qué se ve tan raro. Entonces DB conjunto de tipo carrito de compras consigue no es carrito de compras
es un tipo de datos que necesitamos. Así que sólo voy a crear eso. Y acabo de generar
esa clase en un nuevo archivo. Por lo que ahora tenemos ese archivo de carrito de
compras. Simplemente puedo presionar F 12 con esta seleccionada y saltará
a su definición. No, ¿qué tiene un
carrito de compras? No, la mayoría de las entidades,
y yo diría que cada entidad en su base siempre
debe
comenzar con NAD. ¿ Está bien? Podríamos tener
nombre del artículo, nombre del artículo. De acuerdo, como estoy
en esto correctamente, estoy aquí tratando de
tomar atajos, pero es como mi,
mis sentidos de programación están hormigueando. Uno, cuando estás agregando
algo a un carrito de compras, utilizarías probablemente escribir
en el nombre del artículo. Probablemente
escribirías la cantidad que esperas recoger. Y tal vez quieras establecer una bandera para ver si
está seleccionada o no. ¿ Lo has recogido o no? Entonces aquí hay una cadena
para el nombre del elemento. Y luego tenemos int
para la cantidad. O podría ser doble para la cantidad porque se
podría decir 1.5 o algo así. Oh no, puedes elegir el tipo de datos
apropiado, por lo que cantidad y un
booleano que dice que es. Entonces esos son nuestros
tipos de datos, ¿verdad? Sepan que tenemos esos
cuenco que estaba corriendo. Por lo que ahora que tengo la plantilla
básica para cómo se verá mi
entrada de carrito de compras. Dice, saltar de nuevo al carrito de
compras DB contexto. Y lo que voy
a hacer es anular el método para en la creación de
modelos. Entonces cuando escribas
la palabra anulación, te preguntará ¿qué
te gustaría anular? Y estamos anulando
un no-modelo creando, y luego solo
generará todo eso para nosotros, por lo que necesitamos esa primera línea. Después fui a ver a una entidad de punto
ModelBuilder, ese carrito de compras. Y entonces quiero
decir que tiene datos. Entonces en este caso, lo que
estoy haciendo es que
voy a sembrar la base con algunos datos para que cuando
ejecutemos nuestra API para comprobar, vamos a ver datos ahí, ¿verdad? Así tiene los datos toma una colección de objetos de cualquier tipo que
esté especificando aquí. Por lo que sólo diría nuevo carrito de
compras y luego darle a esto una identificación de uno se
recoge igualaría caídas. Y el nombre del artículo sería, vamos a ver, jabón y
eso es una cuerda. Y entonces el final
sería la cantidad. Y necesitamos tres barras de
jabón, por ejemplo, ¿verdad? Entonces sólo va a tomar
una colección más o menos. Por lo que sólo podemos comas, separa estos objetos tantos
objetos como quieras. Por supuesto, cada uno debe
tener un ID diferente, ya que id se verá automáticamente como una clave primaria
en la base de datos. Así que vamos a mezclarlo un poco. Vamos a conocer a ese verdadero. Y esto sería criado y
deberíamos recoger dos
panes de pan. Y ésta puede permanecer caídas, y ésta debe ser champú. Sólo estoy inventando esto
a medida que voy ya que no es lista de compras de Mariel. Ahí vamos. Por lo que tenemos tres ítems
que queremos sembrar en nuestra tabla de base de datos
cuando se ejecute nuestra aplicación. Y hemos cableado casi todo para tener una base en ese momento, en tiempo de ejecución, ¿verdad? Entonces lo que voy a hacer es ir a los paquetes
NuGet e instalar un paquete más, al
menos por null. Y ésta sería Entity Framework
Core dock herramientas que nos
darán acceso a ciertos
comandos que podemos ejecutar porque necesitamos crear
la tabla en la base de datos. Vamos a seguir adelante y conseguir
las herramientas, instalar eso. Y si solo miras,
puedes consultar mi curso Entity Framework Core si no estás tan familiarizado,
no tan cómodo con
Entity Framework Core. Pero en pocas palabras, esto nos permite ejecutar estos
comandos donde podemos agregar una migración y
actualizarla para que sean switches, lo que nos vamos a
centrar en este momento. Así que vamos a Herramientas y vayamos por NuGet package manager
y lanzamos esa consola. Y luego voy a decir
agregar migración de guiones. Y entonces sólo voy a decir
crear base de datos. Y luego presionamos Enter, que lo piense un poco. Entonces una vez que haya hecho eso, obtenemos nuestro archivo de migración, que no voy a
entrar en los detalles fuera, pero en pocas palabras está viendo crear tabla e
insertar los datos. Y habíamos sembrado tres
registros en, ¿verdad? Entonces el siguiente comando
sería actualizar la base de datos de guiones. Si la base de datos no existe, va a seguir adelante y
crearla y luego seguir
adelante y poner en
todos los registros. Entonces en este punto nuestra
base de datos debería existir. Puedes seguir adelante y construir
y correr y solo probarlo. Pero por supuesto que aún no hemos
construido el punto final. Entonces cuando volvamos, construiremos el endpoint API
que nos permita luego consultar o recuperar estos registros que sabemos que están
en la base de datos.
6. Explora métodos GET: Hola chicos, bienvenidos de vuelta.
Por lo que acabamos de configurar nuestra base de datos ahora
queremos configurar nuestros primeros puntos finales para que podamos
ver lo que hay en la base de datos. Porque cuando se
creó la base de datos en tiempo de ejecución
en la creación modal, queríamos ver
estos registros en, por lo que al menos estos registros deberían estar en la
base de datos y todo lo que queremos al menos recuperar ellos
y ver cómo funciona la API. Entonces lo que vamos
a hacer es seguir la plantilla que se nos
ha dado. Sí, son
pronósticos meteorológicos y sí, los datos son inversor estático en términos de solo
ser esta matriz. Pero el principio detrás cómo vamos a leer
nuestro código es el mismo. Debajo o pronóstico del tiempo justo encima de la aplicación dot run. Lo que voy a hacer es
escribir puntos, trapear, conseguir. Muy bien, entonces lo que
sucede es que para todos los métodos que
querrías usar, puedes ver un mapa y
luego el tipo de método. Por lo que queremos hacer conseguir, gettier de mi
PUT, publicar o borrar, etc, ¿verdad? Entonces a medida que pasamos por ellos, verás ese
tipo de patrones. Entonces veremos mop obtener, y después tenemos que
darle la dirección. Entonces para obtener el pronóstico del tiempo, hay
que ver la URL
o la URL del servidor
slash los pronósticos del logotipo. Queremos conseguir los artículos del
carrito de compras. Diríamos slash en nuestra
cuerda, recortar las tarjetas de compras. ¿ Está bien? Y entonces lo que queremos
hacer es hacer un asíncrono. Entonces obtenemos más o menos asíncrono y necesitamos nuestra representación
de nuestra base de datos. Entonces voy a
derrumbarme todo lo que no
sea absolutamente necesario. Entonces podemos ver la mayor parte de lo que necesitamos ver en
un solo disparo, ¿verdad? Necesitamos alguna representación
de nuestra base de datos. Entonces voy a tener que ver base de datos
asíncrona crear un objeto. Sólo voy a llamarlo dB. Y luego creamos
una flecha Lambda. Y luego podemos escribir
nuestro código más o menos. Muy bien. Así que sólo voy a mover esto hacia abajo y terminar con un punto y coma. Y entonces nuestro
código de función estará en esta sección
del método, ¿verdad? Así que voy a decir un DB raro. Carrito de compras Dots, carritos de compras
universitarios. Eso está bien. Lista. Por lo que más o menos estoy diciendo
seleccionar estrella de esa mesa. ¿ Está bien? Y más o menos eso es
lo que va a hacer. Así que vamos a revisar esto, mira esto bonito y limpio. Así que si no estuvieras
acostumbrado a las API mínimas y estás acostumbrado a
los controladores,
ya sabes qué, Como tendrías
todo un archivo grande para realmente sólo esta línea de código con método antiguo
y todo. Entonces esta es una bonita forma
sucinta de ver. Cuando llegue a este punto final, obtenga una copia de la base de datos de nuestro constructor
de servicios, consulta y devuelva, lo que sea. Entonces eso es realmente
todo lo que tenemos que hacer. Muy bien, así que
probemos los dedos de los pies. Sólo voy a seguir
adelante y correr. Muy bien, así que ahora
probemos esto. Sólo voy a seguir adelante
y ejecutar el proyecto API. Y de inmediato
notarás que tenemos nuestros nuevos
puntos finales, ¿verdad? Entonces tenemos nuestro punto final GET. Podemos ampliar eso
y podemos verlo, probarlo, y luego
podemos ejecutarlo. Por lo que en este punto debe
golpear el método que va a la base de datos y
recupera nuestros registros. Excelente, bien, así que ahora
sabemos que se
ha creado una o API, sí, se está ejecutando a nuestra base de datos y los
registros están ahí en tres, somos capaces de recuperarlos e interactuar con nuestra
base de datos a través de nuestra API. Entonces antes de irnos, solo
voy a implementar
el otro tipo de getMethod. Entonces llego a recuperar
datos, ¿verdad? Normalmente, o bien quieres todos los datos
o quieres algunos, algunos de los datos. Y la forma en que determiné
la suma sería alguna. Entonces ME SUMA. Pero la forma en que determinas qué subconjunto de los datos
quieres sería a través algún parámetro que
proporcionas y luego ejecutas una consulta
basada en el parámetro. Todo eso para ver
dificultad en un APA, tienes dos tipos de puertas. Ante cualquier otro tipo de puertas, tienes el Git, que lo
devuelve todo. Y luego se obtiene por algún identificador
único que generalmente debería
devolver uno o no devolver nada si no
pudo ser encontrado, ¿verdad? Entonces todo lo que voy
a hacer es copiar y pegar este método getter. Voy a modificar la
URL y voy a ver slash carrito de
compras
y luego poner en una plantilla usando
llaves rizadas y decir id Así que estoy esperando que cuando
llames a este punto final, vas a
proporcionar algún valor id, lo que significa que desea el
registro con este ID. Ahora, en esto En el encabezado delegado aquí, voy a añadir un parámetro para facilitar
la recolección del ID. Así que sólo voy a decir int id, coma carrito de compras DB context. Sabemos que esto
ya lo proporciona el, por el sistema. Para que eso no viene
del usuario, pero estamos facilitando el valor de id entrante
del usuario aquí. Entonces nuestra consulta va
a verse diferente. No vamos a ver
unas tarjetas de compras raras. Acuda a la base de datos
y encuentra un fregadero. Y luego le daré identificación. Y entonces puedo
calificar esto un poco. No, porque o
va a encontrarlo y devolverlo o no queremos
encontrarlo y devolverlo. O queremos tal vez
volver no telefoneado. Por lo que puedo ver es carrito de compras. Entonces esta es mi forma de ver es lo que se
recuperó aquí, un objeto de carrito de compras. ¿ Está bien? Y puedo hacer una
expresión lambda y
simplemente romperé líneas para que no
sea tan confuso. Así que vamos a ver. Quisiera
devolver un resultado de tipo, de acuerdo, con los datos que
has solicitado, que sería el objeto de carrito de
compras que se recuperó. Y estoy seguro, estoy seguro si estás haciendo
discurso aquí familiarizado con C-sharp básico. Entonces expresión lambda, no
lambdas ni una operación ternaria. Oh mi, lo siento por eso. Entonces la operación ternaria sería una operación lógica donde se
ve cuál es la, ¿cuál es la lógica que estoy
evaluando? ¿Es cierto? ¿ Eso es falso? Haz eso. Fue encontrado y es un objeto de tipo carrito de
compras entonces, vale, estamos devolviendo eso. De lo contrario Budista ver
resultados comienzan no telefoneados. Y eso daría ese 404
que discutimos antes. Ahora, otro que
probablemente querría hacer
ahora mismo mientras estamos aquí, es lo que si quisiera
encontrar todos los artículos que han sido
recogidos rápidamente, correcto. Entonces la cosa es que
el arresto APIs tuyo, puedes usarlo, cómo puedes
crearlo todo lo que quieras. Simplemente
asegúrate de seguir los estándares. Para que pueda crear otro
importante aquí para ver recogido. Entonces si llaman a este
punto final sólo se supone
que devuelvan artículos que
han sido recogidos. Porque recuerda
donde sea esa flor
ves el recogido
o no recogido. Entonces, si es recogido, sólo esos deberían
volver aquí. Esto lo va a
mostrar todo. Y éste sólo va
a traer de vuelta un artículo. Muy bien, hasta ahora recogido, lo que voy a hacer es decir db dot carritos de
compras punto donde. Y luego ponemos en
nuestra expresión Lambda y nuestra condición
donde es recogido. ¿ Está bien? Y porque es booleano, sólo
puedo dejarlo así. Y entonces yo sólo
Piracy dijo a enumerar, que es nuestra declaración de ejecución para o si la declaración del curso. Y eso es todo. Y más o menos acabamos de
crear tres obtiene puntos finales en una forma de
minutos, en cuestión de minutos. Así que una vez que llegues a todo, quiere que sólo se
recojan artículos. No quiero conseguir algo
específicamente por Adi, así que déjame correr esto rápidamente
para que podamos evaluar o trabajar. Muy bien, así que tenemos swagger, ya
probamos se pone también
en molestarse con esa. Sabemos que tenemos
al menos un elemento que
recogió era cierto alguien para
probarlo y ejecutarlo. Y no debería volver
todo en su lugar, solo
consigo el único elemento que se recoge,
su verdadero Excelente. Y luego si quiero uno por ID, puedo ver intentarlo todo hecho. Proporciono sólo el DNI de uno. El registro que obtengo a Buck
tiene identificación de uno, ¿verdad? Si he proporcionado DNI de diez, sabiendo que no sé
lo que pedí diez que estoy obteniendo eso por las
cuatro respuestas no encontradas. Entonces eso es todo trabajo de
respuestas, ¿verdad? Observe que cuando
tuvo éxito, recuperamos un acorde de 200. De acuerdo, así que esa es la
respuesta clave O a 100 está bien. Entonces cuando quieras ser específico, puedes ver resultados que están bien. Si sólo mientras
devuelvas algo, automáticamente
estará encendido. ¿De acuerdo? Entonces eso es realmente todo para nosotros
creando u obtenemos puntos finales.
7. Explora el método PUT: Muy bien chicos, así que estamos
avanzando en nuestra aventura y vamos a seguir con el método put, ¿verdad? Entonces, lo que tenemos hasta ahora sería conseguir
métodos que podamos recuperar, pero ¿y si lo necesitamos para editar? Tal vez cometí un error
cuando creé el artículo, algo así, ¿verdad? Por lo que necesito poner en el método PUT. Entonces el put más o menos
toma los nuevos datos y luego le dice a la base reemplazó los datos antiguos
con estos nuevos datos. Eso es esencialmente todo lo
que sucede en las salidas. Entonces para subir nuestro punto final, solo
voy a decir
hasta puertos de mapa de puntos. Y como dije,
tendrás mapa actualizado. Y entonces el método que
quieres más o menos
después ¿verdad? Ahora vamos a poner en nuestro patrón de
cadena o nuestra URL. Así que típicamente el puerto parece igual que obtienen en términos de cómo se ve esa
plantilla. Así que estamos consiguiendo esa misma identificación del
carro de la compra, ¿verdad? Y luego vemos es
hundir e int id Entonces vamos a tomar un objeto del tipo
que estamos actualizando. Entonces, en otras palabras, vamos a estar actualizando
un artículo del carrito de compras. Entonces eso significa que si
me estás enviando un registro para actualizar
en mi base de datos, entonces obviamente necesitas
enviarme el registro que quieres reemplazar. Ese registro sería ese ID, ¿cuáles son los datos que
desea reemplazar? Esencialmente, eso es todo lo que es. Por lo que tengo que poner en un parámetro de tipo carrito de compras,
carrito de compras. Entonces recuerda, id está entrando
a través de la plantilla, pero el puerto a solicitar
generalmente enviaría los datos no en el parámetro es como lo que sería parte
de la solicitud, el cuerpo. Por lo que veremos que
en unos pocos int id, carrito de
compras, carritos de compras. Y por supuesto que necesitamos
alguna representación de nuestro contexto DB. Y esto es sólo
un gran delegado. Y luego nos punto y coma
ese paréntesis correcto. Ahora, ¿qué quiero hacer? Lo primero es que quiero
asegurarme de que lo que estés tratando de actualizar
realmente existe. Si no existe, entonces simplemente
realmente no puedo encontrar un registro que estés
tratando de actualizar. Entonces voy a hacer algo
como lo que hice aquí. Fui a ver un peso, el método find, pero antes de eso tengo que
asignarlo en alguna parte. Entonces var nos deja ver registro es igual a mirar en carritos de
compras y encontrar el registro con
esa identificación, ¿verdad? Y en realidad, déjame retroceder un poco
antes, elimine esta línea. Lo que pasa es
que vamos a tener múltiples cosas haciendo. Entonces, a diferencia de los otros
donde había uno-liners, vamos a tener
una serie de cosas haciendo para que nuestro delegado realmente no puede simplemente
permitirnos poner en múltiples líneas. Por lo que tengo que poner llaves
rizadas en lugar
de este órgano delegado. Y simplemente cerraré eso. Y luego dentro de
estos tirantes rizados, ahora
puedo poner en las diversas
líneas de código que quiero. Entonces aquí puedo ver var record es igual a db dot
carritos de compras que encuentran asíncrono. Y entonces puedo terminar
con el punto y coma. ¿ Está bien? Entonces es un
estilo diferente de codificación. Es un poco
más funcional que procesal, como probablemente
estarías acostumbrado a ambos. Es sólo cuestión de
práctica hacer permanente. Por lo que quería ver
si un registro y en general me gusta comprobar primero
por lo negativo. Entonces si el registro es nulo
y se puede comprobar
por null viendo equivalente a null o en realidad se puede ver es nulo. Ese probablemente
leería un poco mejor. Si es nulo, entonces solo voy a devolver
resultados, puntos no encontrados. No pude encontrar el registro que dijiste que estás
tratando de abrirla? No. Si va más allá de esa parte, entonces vamos a
querer hacer esta actualización. Así que me fui a ver un récord
puntos y luego voy a tener que orinar y pegarme en legal
a través de cada método lo siento, cada propiedad que entró
y no estar en ella. Entonces registro aquí es
lo que hay en la base de datos. carrito de compras aquí representa los datos entrantes del carrito de compras, la carga útil, el
cuerpo de solicitud con los nuevos datos. No sé si
cambias el nombre. No sé qué cambiar. Entonces para estar en el lado seguro
después de actualizar todo. Entonces, si estás acostumbrado a SQL y
actualizar sentencias en SQL, sabes que tienes que
cambiar cada cosa dentro de una instrucción SQL
solo para estar seguro, ¿verdad? Entonces es recogido, es recogido. ¿ Qué más teníamos? Hemos tenido cantidad. No creo que tengamos nada que sea global.
No se puede actualizar Id. Muy bien, queríamos
actualizar el ID de registro. Entonces después de que hayamos hecho
todos esos cambios, lo que queríamos
hacer es que esperaré, db dot save cambia un fregadero, entonces podemos volver. Entonces cada vez que hacemos una solicitud HTTP que no necesariamente tiene
nada que devolver, lo que vemos no es contenido. Entonces es el capullo de Solon. No voy a volver. De acuerdo, pero después de la operación de
actualización, realmente no
necesito
devolverte los datos que me acaba de dar
porque ya lo tienes. Entonces diría que no hay contenido, lo que más o menos significa que no
tengo nada que devolver. Pero esta es una herramienta
para, ahí vamos. Entonces básicamente dice,
no tengo nada que volver a ti, pero tu operación fue buena. Todo está bien para ir
en ese punto, ¿verdad? Así que probemos
nuestra operación. Así que sólo voy a
correr sin depurar. Y swagger está en la pelota
con la codificación de colores, por lo que se pone en azul y luego
tenemos estamos poniendo naranja. Puedo probarlo. Nadie. Te veré en el ID
va en el parámetro. También estaba viendo que el resto de los datos van en
el órgano de solicitud. Entonces aquí es donde digo que quiero
actualizar registro con el ID1. Y entonces, ¿cuáles son los datos que
quiero enviar? Entonces estas son cosas arriesgadas. Y en mi, en mi curso completo de API de
extremo a extremo, sí
señalo
los peligros de tener ciertos campos expuestos en
la vida PUT y post puntos finales. Puedes pasar por ese curso. Pero una vez más,
lo estoy manteniendo sencillo aquí, ¿verdad? Pero típicamente te
gustaría tomar ese valor de ID o puedes escribir el código como lo hicimos para no un colon por el
valor id que está siendo encarcelado. Entonces digamos que cambio
estos valores, ¿verdad? Entonces graba con el ID1,
vamos a mirarlo. No. Entonces si voy al get, pruébalo y di
Muéstrame grabar con el ID1. Me va a mostrar jabón de artículo ID1. Entonces la cantidad tres top
grande es falsa. No voy a cambiar
nada en este órgano de solicitud. Este cuerpo de solicitud representa
los mismos campos y valores
correspondientes
que esperarían para entrada de
nuestro carrito de compras. Entonces si presiono Ejecutar, lo que sucederá es que a
los cuatro fue exitoso. Y si vuelvo a recuperar
ese registro con ID1, solo
voy a
ejecutar esto de nuevo. Ahora
lo vamos a ver partiendo igual lo que acabamos de enviar
como órgano de solicitud. Entonces si quiero cambiar esto para
tararear y recoger
diez viviendas, ¿verdad? Ejecuta. Todo lo que hace es tomar
todo aquí. Y la idea es que
sólo va a reemplazar lo que hay en la base de datos. Ahí vamos. Muy bien, entonces algunas cosas sobre
lo que hizo Entity Framework. Uno, cuando recuperamos
nuestros registros, realmente lo
recuperamos. Y hay esta característica
llamada camiones que se habilita en un recuperarlo
así con camiones, cualquier cambio que
realice a cualquiera de las propiedades son los valores. Simplemente puedes llamar a Guardar cambios. Y automáticamente
sabrá que esto fue cambiado porque estaba
rastreando los valores. Entonces una vez que se ejecuta esta línea, sabe
que este registro no
es una cita sin cotización sucia. Entonces cuando veas si GnG
es mirar este registro y ejecutar los cambios
que se hicieron, menos eso es
lo que pasa, ¿verdad? Hay otras formas
porque puedes recuperar datos sin seguimiento. Entonces lo que sucede es que cuando tienes
cientos de registros probablemente no quieras
rastrear porque puede causar problemas de rendimiento. Por lo que verías que las personas se
ponen como más seguimiento de
sus consultas. Pero eso suele ser más para las aplicaciones que alcanzan
que mantienen estado. Hasta ahora una API no
hay realmente, realmente no
hay ningún
estado que se recupere. Y eso es sólo un momento
enseñable. Solo te estoy ayudando a entender qué es el
seguimiento y por qué esto fue capaz de
funcionar así así
sin que llamemos a
db dot update. Muy bien. Entonces eso es más o menos para nosotros
armar la salida. que puedas pensar todas las salidas que quizá
quieras configurar. Pero por no, ese
es lo suficientemente bueno.
8. Explora el método POST: Nuestro chico. Así que echemos un vistazo a la
creación de nuestro método post. Así que solo para hacer esto de manera
sencilla y rápida, solo
voy a copiar el método puts y
pegarlo de nuevo. Y vamos a
ver un puesto de trapeador, post. Este punto final no está dispuesto
a tener ningún parámetro en él. Por lo que sólo va a
ser cortar el carrito de compras. Y entonces vamos a tomar este espirómetro y sólo estamos esperando la carga útil en el cuerpo de
la solicitud, ¿verdad? Para que el
objeto del carrito de compras es lo que esperamos
obtener dos bases de datos Editor
en cuanto al código, no
tenemos que hacer ningún cheques. Todo lo que tenemos que hacer es agregar este
artículo del carrito de compras a la base de datos. Sólo voy a decir
db dot carrito de compras. O en realidad podría
simplemente decir db dot odd. Y entonces solo le damos
ese objeto de carrito de compras. Y luego guardamos los cambios. Entonces lo que vamos a volver sería una respuesta Creada. Entonces creado tendría
una herramienta uno, ¿verdad? La herramienta uno es el código de estado. Así creado. También se podría decir
algo más como creado a la ruta. me puedas dar el nombre raíz y algunas otras cosas lujosas. Pero simplemente lo
mantendré simple, creado. Y entonces sólo vamos
a devolverle algunos datos. Por lo que sabe que se crea
en el carro de compras slash. Por lo que la respuesta tendrá la slash de punto final
y luego el ID. Entonces básicamente lo que estamos
viendo es si vas a cortar carritos de
compras con el carrito de
compras dot ID, entonces puedes encontrar ese método, encontrar esos datos, lo siento. Entonces devolvemos el objeto
real. Entonces esencialmente creado
y
le estamos diciendo la cadena donde puede
ir para ver los datos creados. Y luego esa es la carga útil de datos
real junto a la ruta a la
que podrías ir. Y eso es esencialmente todo. Así que probemos este viejo. Entonces la codificación de colores es
que una vez más, tenemos nuestro método post aquí. Pruébalo. Oh, y no debería estar dando una idea
cuando estoy creando, pero ya discutimos eso, que sólo estamos manteniendo
las cosas simples aquí por ahora. Probemos con otro
artículo. Esta vez. Quiero cereales, y quiero
dos cajas de cereal. Y aún no ha sido
recogido. Entonces cuando ejecutamos esto, eso representa nuestros
objetos que
luego estaban enviando a la base de datos
y se crea C, se obtiene el ID para y
todo está ahí. Entonces si hago un get
all y ejecuto, entonces voy a ver 123 y nuestro ítem recién creado,
ítem cuatro. Y eso es realmente todo
para todo el método post. Entonces, una vez más,
esperábamos la carga útil, que luego consiguió lo que causará desserializado en este objeto. Y luego lo agregamos a la base de datos y luego
guardamos los cambios. Entonces lo que verías con Entity Framework
Core es que en realidad se
podría decir db dot add, y add toma algún tipo. Realmente no sabe qué
tipo podría intentarse. Pero siempre y cuando esté fuera de
la entidad o mientras pueda encontrarla en el contexto DB y
no obtendrá ningún problema. También verías db dot y luego la tabla específica
y luego ese anuncio, ¿verdad? Así que solo
te estoy mostrando que podrías hacer cualquiera de ellos realmente db
dot añadir carrito de compras. Y entonces sabe que es sólo
guardar los cambios y encontrará la
tabla apropiada para poner en los datos. Y hemos visto que eso funciona. Entonces eso es todo por
nuestro método post.
9. Explora el método de DELETE: Estamos de vuelta y esta
vez vamos a estar mirando el método delete. Por lo que vamos a hacer mapa eliminar. Una vez más, voy
a tomar nuestro PUT y luego solo vamos a
reequipar para ser Borrar. ¿ Está bien? Entonces estoy seguro que sabes lo que es, pero sé que
realmente no importa el orden en
que pongas los métodos. No se fue
falsificado cuál es ejecutado primero
sic en nuestro tercero porque no
es materia No es cuestión del orden cronológico o
el orden del método es justo cuál se
solicita en el que 0.1 cosa que debo
señalar es
que nunca se deben tener dos de los mismos métodos con
el mismo punto final. Así que volvamos a lo bueno. Tenemos múltiples gets, pero nota que cada uno tiene
una dirección de punto final diferente, ¿verdad? Entonces si tuviera que conseguir métodos con
los mismos carros de compras de barra, eso causaría un problema. Pero porque he mapeado
conseguir un Nmap posts, ¿dónde está para
hacerlo bien? Mi post. Y ambos como
cortan el carrito de compras, no causa un choque porque uno está subiendo, uno es post. Entonces si olvidé
cambiar esto y sumar los dos Map pone con el
mismo valor de punto final. Simplemente causaría un problema. En realidad veamos eso. Es bueno ver estos
errores para que sepamos lo estamos diagnosticando cuando nos
enfrentamos a estos retos. Cuando hagas eso y
resuelvas tus cargas, solo
te dirá que odias dejar cargar no está dando
más datos que eso. Si consigues algo como esto, regresa y comprueba y
asegúrate de que no estás
cometiendo ese error. Entonces una solución simple aquí
es decir mapa, eliminar. Y va a tener que retener el mismo punto final porque sí
queremos guía de compras. Yo sí necesitaré el ID de
lo que vamos a eliminar, lo que no necesitamos, sin embargo, son los datos que vamos a eliminar porque siempre podemos usar
el ID para encontrar el registro. Entonces aquí obtenemos el récord. Si no se encuentra, regresamos no encontrado. Y entonces lo que voy
a hacer es simplemente decir db dot. Sería db dot remove. Ahí vamos. A veces
me olvido de estas cosas. Entonces db dot eliminar y
eliminaríamos el registro
que encontramos con ese ID. Guardamos los cambios, así
que solo presiono Guardar. Y lo que sucede es que
hay una característica en Visual Studio 2022
llamada Hot Reload. Entonces esa es esa bola de fuego de aquí. Por lo que en realidad puedes
habilitar que cuando lo
guardes hace una
recarga en caliente automáticamente. Podría incitarte
como me está impulsando. Pero siempre puedes
tocar recarga en caliente. Entonces si no puede simplemente recargarlo, solo se
puede decir reconstruir
y aplicar cambios. Y hará
lo que tenga que hacer en segundo plano mientras
todavía se está ejecutando sin depurar. Y cuando se está ejecutando
sin depurar, tendría esta ventana de
consola abierta. Así que a veces
podrías intentar algo, simplemente no
estoy funcionando correctamente. Simplemente revise la ventana de la
consola. Es posible que tengas que
cerrarlo y luego empezar de nuevo. De cualquier manera, Hot
Reload nos permite simplemente recargar nuestro doc Swagger. Sé que estamos viendo o
eliminando el punto final correctamente. Entonces si lo pruebo
y luego trato de eliminar un registro con el ID
para el cual es el que
acabamos de crear. Y eso lo ejecutamos. Ya vemos, estamos devolviendo
que todo el contenido. Entonces eliminar es otro punto
final para el que no
puedes devolver
contenido, ¿verdad? Está perfectamente bien. La ventana de la consola, mientras
estamos en modo desarrollo, verías esas
consultas siendo escupidas en esto en la consola. Y eso podría ser
útil para que
veas qué se genera al ejecutar estos
comandos de EF Core pie derecho, aunque no necesariamente
necesitamos enfocarnos en eso. Y en este punto, tenemos nuestra
API de multitud en funcionamiento. Ahora, cuando volvamos,
simplemente limpiaremos nuestro código y haremos que esto parezca un
poco más presentable.
10. Prueba API con Swagger: Muy bien, así que
volvamos a ponernos a prueba esto. Así que sólo voy a correr sin depurar los un
poco más rápido. Y solo vamos a usar la herramienta
swagger para probar esta API. Y ahora una alternativa a
Swagger habría sido como cartero o algo
parecido a eso. Pero la saga es capaz, así que la usaremos ahora mismo. Entonces cuando ampliemos nuestro get, eso implica que vamos a
estar volviendo a subir. Colección verá la muestra, el objeto de muestra de lo que
vamos a estar recuperando. Y observe las llaves cuadradas, los representa que
será una matriz de objetos. Tomemos, pruébalo y ejecutemos qué punto
realmente va en
consultas la base de datos, y hay todos los autos de muestra que
habríamos ingresado ¿verdad? Ahora si traté de conseguir por ID, déjame probar esa. Así que pruébalo todo. Dice
dame la idea, le
daré diez. Y recuperamos la respuesta 200 con
el auto con el DNI diez. Lo intento con un 100. No tengo 100 autos. Entonces esta vez me
compraron eso para los cuatro porque no
pudo encontrar ese auto. Mala idea, ¿verdad? Se puede prestar atención para
liderar las URL de respuesta. A saber el, esto es lo que
llamamos la URL base porque
ese es el servidor. Y entonces este sería el camino, y entonces ese será nuestro valor
id pasando, ¿verdad? Entonces es bueno prestar
atención a estas cosas porque cuando estamos escribiendo
código para interactuar con la API, tenemos que imitar este tipo de
URL para que verifique que
todo lo consigue por ID funciona. Probemos con el Pulitzer. Si traté de modificar
auto con ID1, hagámoslo en una cadena, cadena, cadena,
cadena, cadena, cadena. Así que permítanme primero
recuperar
el auto con el ID1 para que podamos ver
cómo se veía. Entonces ese es el auto con el ID uno y tomamos nuestra copia
rápida del mismo. Es un Honda Fit, el ABC de Vinny. Ahora, cuando ejecuto esto, noto que tendría que poner en todos los detalles y
tender a actualizar el ancho. Entonces si dejo los valores predeterminados
y hago clic en
Ejecutar, me va a decir que no hay contenido, lo
que significa que fue exitoso. Si intento recuperar
este auto de nuevo, entonces voy a ver
que no está funcionando. Vamos a poner el cordón. Y mi capullo. Esto es, estos son mis errores tontos. Por lo que en realidad mezcló las tareas que
debería haber estado asignando. Registrar el valor está
entrando a través de coche. Entonces me disculpo por eso. Se compensa que tengo en mi recarga
caliente en Save, así que debería poder simplemente
volver atrás e intentarlo de nuevo. Entonces eso es ejecuta. Estamos viendo una Honda
Fit y todo. Y luego cuando
intenté ejecutar aquí, obtengo la herramienta para. Entonces no, estoy viendo, ahí vamos. Así que ahora estamos viendo todo
cambiado a una cuerda. Mis tontos errores chicos. Entonces eso funciona. Y es por eso que
las pruebas son importantes. Muy bien, así que
déjame volver a mi carga útil original y
luego ejecutar de nuevo. Y entonces podemos
verificar que ahora
vemos los datos originales,
correcto, con buen aspecto. Entonces el final
es el delete. Entonces, ¿cuál
querría eliminar? Permítanos seguir el yo
no soy no quiero ver a qué
tipo de auto no me gusta. Lo que voy a eliminar. El que
menos me gusta en esta lista sería el
auto con el ID cuatro. Será demasiado pequeño para mi gusto. Por lo que ahí obtenemos
la herramienta para eso sugiere que se
completó con éxito. Entonces si vuelvo y ejecuto, ya no
hay un
auto con el IED cuatro. Así mismo, nuestro código funciona.
11. Revisión de API: Muy bien chicos, Así que la
última escucha nos dejó con nuestra API de trabajo que hace operaciones crud
básicas. Lo que no queremos
es el código de acceso. No queremos las cotizaciones de
pronóstico. Fui a quitar eso. También voy a quitar
Record en la parte inferior. Y ahora mismo, todo lo que tenemos es el código que
sabemos que absolutamente necesitamos. Sepa que hay diferentes
formas en las que puede organizar su API mínima
porque podría crear métodos a los que
obstruye el código. Podrías ponerlo en una clase diferente y luego
llamarlo como middleware. Hay número de
formas de hacerlo. Realmente no voy a meterme en todas esas formas, ¿verdad? No. Pero al menos al
final de este ejercicio, sabrás
crear API usando el
estilo de codificación mínimo que puede hacer multitud contra la base de datos.