Transcrições
1. Apresentação: Olá e bem-vindo ao meu curso, desenvolvimento mínimo de
API
ASP.net Core. Sou seu instrutor de guerra Williams e sou engenheiro de
software e palestrante e
tenho feito isso nos últimos 12 anos. Neste curso, vamos entender
como
desenvolvemos entender
como
desenvolvemos APIs mínimas
usando dotnet seis, vamos entender todos os verbos da API
funcionam sequela inteira, light e Entity Framework
Core combinado para nos
dar um lugar para armazenar
e recuperar dados. Também analisaremos a
injeção de dependência e
documentos completos de swagger nos ajudam a
interagir com nossa API. Faça este curso usará
Visual Studio 2022 e sequelas para dotnet. E o Visual Studio 2022 é
necessário para usar dotnet six. É um IDE totalmente caracterizado
e extensível, e é muito poderoso
e nos permite fazer muito mais pelo desenvolvimento. Então, sem mais delongas,
vamos começar.
2. Visão de API: Ei pessoal, bem-vindos
ao início desta nova seção em
que estaremos trabalhando em uma API RESTful para
complementar nosso aplicativo móvel. Então, nós analisamos todos os
conceitos básicos de Maui já. Mas agora queremos criar
um aplicativo real. E, de um modo geral, os aplicativos
móveis se comunicam
com a APA, e é
por isso que muitos deles exigem acesso
à Internet. Agora, se você não estiver tão familiarizado
com o que é uma API, vou
orientá-lo por alguns dos conceitos básicos agora. E se você realmente quiser se aprofundar em mais detalhes você pode conferir meus outros
cursos onde eu levo você através do toque
com design de API. Mas, para este curso
, será
simples o suficiente para que
possamos colocar uma API em funcionamento
e ver
como podemos consumir e interagir com essa API
por meio de nosso aplicativo móvel. Agora estamos criando
uma API RESTful. E o pulso é um acrônimo para Representational
State Transfer. Essencialmente, é um padrão
aberto que
permite que qualquer tipo de cliente possa
interagir com algum endpoint e acessar alguns, o que chamaremos de recursos de TI. Por exemplo, vamos pegar um
aplicativo como o Facebook. Somos facebook em
nosso celular, ou se estiver na nossa Internet, nossos navegadores de Internet,
nós o temos em vários dispositivos e
temos aplicativos para Android, para iOS, etc. O fato é que cada um
desses aplicativos não é viável,
construído do zero. Na verdade, está apenas
interagindo com uma API que o Facebook desenvolveu
e continua desenvolvendo. E é por isso que quando
você recebe atualizações, o que talvez o que eles fazem
fique em alguma coisa, a API e eles
precisam atualizar a maneira como o up interage com essa API. Mas, essencialmente, a
inteligência repousa na APA. E, por ser
um padrão aberto, não
importa se
é um dispositivo Android ou um dispositivo Windows, seu celular ou seu relógio móvel ou
seu smartwatch. Todos eles podem interagir com
essas APIs padrão abertas ou serviço
web que geralmente está serviço
web que geralmente conformidade com o resto do estilo
arquitetônico. Quando falamos de
APIs e APIs repousantes,
há certos
conceitos com os quais queremos ter
certeza de que estamos
confortáveis. Um deles é uniforme, o
que significa que existe uma
maneira padrão de formular seus URLs
e atender a essas chamadas. Ainda é menor. Portanto, você geralmente não
descobre que cookies e outros arquivos são gerados no dispositivo para
suportar a API. A chamada é feita quando eu
chamo isso de terminado, ele esquece disso. Não há nada realmente
segurado, certo? É armazenável em cache, o
que significa que às vezes você tem inflamação que está
sempre sendo solicitada. Então, em vez de ir
ao banco de dados ou ao
armazenamento de dados, toda vez, colocamos um dinheiro lá para que a API possa responder
mais rapidamente com inflamação
acessada com mais frequência e geralmente
não muda muito. Está em camadas. Portanto, você tem
partes e camadas diferentes para a API para restringir o que pode ser feito em diferentes níveis. Ou o recurso geralmente
representa bits de dados ou um objeto entre o banco de dados e o aplicativo
cliente. E, de um
modo geral, quando você está nomeando seus endpoints da
API RESTful, você quer ser autodescritivo. Então, se é um ponto final para lidar com a
inflamação pessoal, então você quer ter certeza
de dizer inflamação da pessoa. Então, esses são apenas princípios. Em seguida, temos
os métodos HTTP. Agora temos métodos diferentes
nas formas de get,
put, post, delete. Esses são os mais populares que você verá sendo usados. Existem outros. Mas, de um modo geral, quando estamos lidando
com um Datastore, queremos
realizar operações. Geralmente chamamos isso de operações de
multidão. Queremos criar
dados no banco de dados, queríamos recuperar os
dados no banco de dados. Queremos
fazer alterações nele ou atualizá-lo, e queremos
removê-lo ou excluí-lo. Então veja o DIU. Portanto, obtenha as alças da
recuperação quando quiser visualizar o registro
ou um monte de registros. Colocando solicitação I GET, put é o u, que é atualização. Você também tem patch, mas esse é um tópico
para outro momento. Coloque o mais
fácil de ser implementado, estaremos trabalhando com isso
para nossos propósitos aqui. Mas enviamos
solicitações PUT sempre que quisermos
atualizar os dados. Temos a solicitação de postagem
sempre que queremos criar dados. E então temos as solicitações de
exclusão, que eu acho que são
autoexplicativas, se não as mais
autoexplicativas, uma delas todas, então
temos a resposta HTTP. Então, esses foram os pedidos
que acabamos de ver. A resposta é o que
o servidor envia de volta. Então, geralmente temos um XX
e XX significa apenas número, números como 100,
entre cento, cento e noventa e nove. O eixo x representa
qualquer coisa de 00 a 99100. Os códigos de status
geralmente falam sobre comunicação em
protocolos de transferência para 100. Geralmente atinge o sucesso
na operação. 300s era que
houve um redirecionamento. 400 mostra que talvez houvesse algum data center ruim
ou do cliente. Portanto, o usuário mid recebe dados que o
servidor não pôde processar. E então nós diríamos que foi ruim, um pedido ruim ou você
solicitou algo que não pôde ser encontrado
como um erro 404. Tenho certeza de que todos podem se identificar
com um erro de fluoróforo. E então temos o erro 500, que significa que o servidor
está onde o problema estava. Os dados entraram, mas
talvez você não tenha chamado esse
problema de conectividade de banco de dados ou o servidor estava pronto, então a API responderia
com uma resposta 500. Portanto, essas são
citações de resposta gerais e é muito importante obter esses
direitos em um bom design de API. Então, tudo isso para ver que
nossa API servirá como um ponto de interação entre nosso aplicativo móvel e
algum banco de dados central. Tudo o que fazemos
no aplicativo móvel, queremos que ele flua
pela API porque é aí que
estará a inteligência
real e é nisso que vamos começar
essa jornada. Então, nesta seção,
estamos iniciando o design da API e vamos
analisar o básico, fazendo o suficiente para colocá-lo
em funcionamento e entendê-lo mais uma vez, se você quiser mais detalhes, você pode conferir esse guia de desenvolvimento da API ASP.net
Core final do
curso. Você pode verificar
tudo o que precisa saber sobre o
design adequado da API do zero. Neste curso, estamos
mantendo isso simples. Então, na próxima lição,
vamos configurar nosso projeto de API e
fazer a bola rolar.
3. Projeto de configuração: Tudo bem pessoal,
bem-vindos de volta. Então, vamos pular direto para ele. Vamos abrir
nosso Visual Studio 2022 e vamos continuar
criando um novo projeto, mas quero uma solução vazia. Então eu prefiro começar
com uma solução vazia. Então essa é
uma solução em branco em vez disso, para que eu possa dar
um nome à solução e depois adicionar os
projetos. Então, vamos trabalhar em um aplicativo
móvel de carrinho de compras, certo? Então, lista de carrinho de compras, então vou
dizer lista de carrinho de compras. Esse é o nome
da solução. Assim, podemos ir em frente
e criar isso. Agora, uma vez que tivermos a solução, vou criar
um novo projeto. Então, vou apenas
diretamente a solução, Adicionar novo projeto. E, em seguida, podemos adicionar
projetos de API. Só vou
procurar mais uma vez pela API. E depois vou
usar uma API da Web
ASP.net Core C-sharp . E então vou chamar a API de
pontos
da lista do carrinho de compras . Em seguida, apertamos Next. E agora aqui estão algumas opções
interessantes para nós. E como eu disse,
quero mantê-lo forma
relativamente simples,
simples para nós. Primeiro, vamos
usar dotnet Core seis agora com o Visual
Studio 2022 preview, você pode voltar para cinco, que no momento
desta gravação
atingiu o fim da vida praticamente para você provavelmente não
quero ir lá. Dotnet Core de três pontos um
ainda tem suporte a longo prazo, assim como dotnet six e
dotnet sete estão em versão prévia. Por razões de estabilidade, vou prosseguir com dotnet seis. E podemos colocar um tipo de
autenticação. Mas, por enquanto, vamos escolher nenhum porque faremos
isso manualmente mais tarde. Podemos configurar para HTTPS, não
precisamos de mais escuros. Agora, aqui é onde
fica interessante. Podemos optar por usar
controladores ou podemos desmarcar, para que possamos usar o mínimo de APIs. Tradicionalmente,
sempre usaríamos controladores, mas acho que esse
seria um bom momento para tentar ver a aparência da API
mínima. Especialmente porque este é
realmente um aplicativo leve, mas pode
crescer em nós de qualquer maneira. Então, vou desmarcar
esse controle de uso para que
possamos usar o mínimo de APIs,
deixar o suporte a APIs abertas. E, em seguida, a próxima opção que é bastante interessante, é se queremos ou não
usar instruções de nível superior. Assim, com dotnet six, as instruções de
nível superior
teriam sido como a função principal e o namespace
principal e assim por diante. Então, certas pessoas
teriam dito que preferem
vê-lo feito em seis, introduziu classes de
estilo mínimas onde você não precisa necessariamente ser
tão explícito no topo. Então você pode, você pode escolher
qual deles você quer. Não vou usar as declarações de nível superior
porque gosto delas assim. E vou apenas clicar em Criar. Tudo bem, agora temos nosso projeto de
API criado. Então, se eu for para program.cs, observe que se você está acostumado
a ver a pasta controladores
no desenvolvimento da API, você não a verá aqui
porque desmarcamos os controladores dos EUA. Se você optar por usar controles, sem problema, você deve ser
capaz de acompanhar bem. Mas porque estamos
fazendo o mínimo de APIs ou escolhi os modelos mínimos de
API. O
que acontece é que vamos
ver tudo acontecendo
aqui naquele program.cs. Então, uma vez que um programa
é executado, ele cria todas as
dependências necessárias. E então ele vai direto
para executar o código ou saber qual codificação é
executada e, em seguida, ele é executado. Portanto, a API ficará lá
e aguardará solicitações e tudo está sendo executado em nosso program.cs praticamente. Eu só vou executar
isso para ter certeza de
que está pronto e funciona. E ele lançará este navegador
nos mostrando nosso documento Swagger. Portanto, como escolhemos o suporte a APIs
abertas, nós automaticamente temos
swagger incorporado em nossa API. Assim que executarmos isso,
veremos a documentação. Portanto, quanto mais
habilidades de endpoints, mais
deste documento se expande
automaticamente. Então é isso para nós criar. Quando voltarmos,
configuraremos a política do curso.
4. Configure a política CORS: Tudo bem pessoal, então
nesta lição estamos configurando nossa política de curso. E eu costumo fazer isso como
uma das primeiras coisas. Sempre que eu crio uma API, por quê? Bem, a API por design deve ser consumida
por outros clientes. Outros clientes que podem não estar
necessariamente no
mesmo servidor que a APA. Nenhum carro é um termo de
segurança geral para qualquer aplicativo
hospedado na Internet. E, de um modo geral,
essa política
ditaria que recursos diferentes são solicitações
diferentes, em vez disso, podem ser facilitadas
pelo aplicativo que está sendo solicitado. Tudo isso para ver. A política do curso
nos permite rejeitar solicitações de determinadas fontes, pois todas as
fontes são solicitações baixas. Então, quando temos o
celular em outro lugar, ou 60 milhões de
aplicativos móveis em todo o mundo e nossas APIs
em um servidor em algum lugar. Precisaríamos ter uma política de
curso para dizer, bem, eu não sei, não
consigo acompanhar
60 milhões de solicitações e
60 milhões de telefones celulares. Então, vou permitir que
alguém fale comigo. Claro, podemos adicionar outra
segurança em outro nível. Mas, por enquanto, usaremos política
do curso para
garantir que possamos facilitar solicitações provenientes de
aplicativos móveis após o fato, certo? Vamos até isso é o que linhas sete no program.cs. E, como eu disse
na última lição, não
optei por usar
as declarações de nível superior. Então, ele só chega direto
ao ponto, certo? Ele só inicia o
código porque já sabe que é
o program.cs, então não precisa
declarar int, void, classe de programa,
etc, etc. Então, não classe void,
sabe o que eu vi? Então, vamos entrar nisso. Então, dizemos que construtor pontos
serviços, ponto, adicione carros. Bem ali está. E o que vamos
fazer aqui é configurar algumas opções que
orientarão a configuração. Tudo bem, então dissemos Opções
e, em seguida, usamos aparelhos encaracolados. E deixe-me fazer
isso um pouco maior. Certifique-se de que podemos ver
me dar um pouco mais realista. Isso garante que todos possamos ver o que está acontecendo claramente. Tudo bem, então crie os
serviços de pontos que adicionam CORS
na Web ou opções. E então, dentro de nossas
opções, haverá opções, ponto, adição, política. Portanto, esta é a nossa política do curso. Temos que dar um nome a ele. Então, vou dizer um baixo tudo porque não estou disposto a
colocar nenhuma restrição. Então, sim, literalmente
vai ser Olá a todos. E então vou
iniciar outra expressão lambda. Basta ver um Lambda. E então isso é como
uma função de construtor, então vou apenas dizer um ponto e então posso dizer
permitir qualquer cabeçalho. Então isso significa qualquer tipo
de solicitação que
entra , é puxada, etc. Embora tenha começado,
veja qualquer origem. Onde quer que esteja,
originando, sendo as
solicitações são baixas, e então eu posso ver um baixo, qualquer método realmente
permite que qualquer método
é o método HTTP que está entrando no
cabeçalho é diferente. Peço desculpas, o cabeçalho está acima
partes do corpo da solicitação. E às vezes certos
rebatedores podem ser milícias. Então, vamos seguir qualquer cabeçalho, permitir, qualquer método, etc. E lá vamos nós. Então essa é a política
que configuramos. Não, precisamos deixar
o middleware, então é aqui que
construímos nossos serviços. Mas então o
middleware começa
na declaração acima aqui. E ele notou que a
variável aqui muda, certo? É, ou o
nome do objeto muda, está ativo em vez de
pontos do Builder, serviços ou qualquer coisa. E então o que
precisamos fazer é informar o AppBuilder
que ele deve usar núcleos. Então eu costumo colocar isso
embaixo disso. Então, vou
dizer que use núcleos. Portanto, use o
middleware cors e
aplique a política que foi
criada chamada de baixa. Tudo bem, então observe erros de digitação nesse ponto porque
isso é uma corda mágica. Então você pode acabar depurando
nada se sentir derramado esses dois
carrinho para a direita. Então, é isso mesmo para
configurar nossa política de curso. Posso parar por aqui porque não
há realmente nenhuma maneira tangível de validar
isso neste momento. Fora de talvez
executar a API, tentando hospedá-la
em algum lugar e depois
tentar acessá-la de
outra máquina. Então essa é realmente
nossa política de curso. Já expliquei por que
precisamos disso para fazer isso. Então, quando voltarmos,
continuaremos construindo nossa API.
5. Configure o banco de dados SQLite: Oi pessoal, bem-vindos de volta. Neste episódio, vamos
construir nosso banco de dados. Normalmente,
é claro,
para um aplicativo que será dimensionado
para uso grande, você deseja usar um banco de dados de nível
empresarial como Oracle ou
Microsoft SQL Server. E, em seguida, a principal ferramenta de mapeamento
relacional de objetos, ou a biblioteca que dotnet Core nos dá a
interação com o banco de dados. O carro-chefe é o
Entity Framework Core. Saiba que ele tem conectores
para muitos outros bancos de dados, então não estou dizendo que
você
precisa usar o banco de dados que
estou prestes a usar, mas estou mantendo
isso simples o suficiente, mas vou explicar o conceito geral
para você para que você possa apreciar por que estou
tomando essas decisões. Então, para este curso, vou usar um banco de dados de
sequelas
que ficará dentro da
pasta com a APA. Mas, mais uma vez, em um aplicativo de
nível empresarial, você gostaria de se conectar a
algum servidor remoto para um banco de dados de nível empresarial,
como o Microsoft SQL Server. Então, para colocar o Entity
Framework em nosso projeto, vou clicar com o botão direito
do mouse no projeto e depois
ir para pacotes NuGet. E então vamos
para
Browse e vou
procurar pelo Microsoft dot Entity
Framework Core, luz de sequela. Mais uma vez, se você quiser
usar um banco de dados diferente, talvez você já
saiba como
conectá-lo ao SQL Server. Então você apenas procura Microsoft, mas o Entity
Framework Core, e veria
os diferentes morrem para o SQL Server, para o meu SQL, etc. Então, de um
modo geral, o nome é consistente onde você apenas
diz Entity Framework, Core, duct e o
engenheiro de banco de dados, você prefere. Então você encontrará
as bibliotecas. Alguém para baixar. Entity Framework Core
faz luz de sequela, e isso virá com
algumas bibliotecas adicionais. Então deixe-me ir em frente e
baixar e instalar isso e aceitar
qualquer coisa que surgir. Para isso, também
precisarei de outra biblioteca, que é Microsoft dot data
dot sequel light dot core. Então eu posso ir em frente
e pegar esse. E isso me permite fazer
outras operações importantes. Vou em frente e instalarei isso. Agora vamos voltar para o nosso program.cs e, em seguida,
começar a conectar isso. Então, vou colocar algumas configurações e depois orientá-lo por elas. Então, o que estamos fazendo aqui é
que estamos configurando uma pasta. Tudo bem pessoal, então
vamos voltar para
o nosso program.cs. E vou colocar
algumas
linhas de configuração e, em seguida,
orientá-lo sobre o que
está acontecendo quando estou configurando o caminho do banco de dados. Portanto, o caminho
do banco de dados vai para a pasta raiz e criar um arquivo chamado carrinho de
compras dot db. Então a cadeia de conexão que estou chamando
um con para abreviar, é igual a uma nova conexão
SQL lite. É claro que, à medida que você avança, você precisará incluir algumas referências
ausentes usando. Então, basta incluí-los
como você os vê. E a fonte de dados será igual
ao caminho do banco de dados. E então dizemos que crie
serviços no contexto do banco de dados. E temos o contexto de banco de dados do
carrinho de compras, que tem uma linha vermelha
porque ainda não existe, mas vá em frente e
coloque-o independentemente. E então colocamos
a opção de que estamos usando a sequela ITE, e essa é a nossa conexão. Tudo bem, para que possamos
criar esse arquivo. Vou apenas controlar pontos e vou gerar isso
em um novo arquivo. Então, temos o contexto DB do carrinho de
compras. Agora vou primeiro
conhecer esse público e depois vou torná-lo
herdado do contexto de banco de dados. Então, uma vez que você fizer isso, é
claro que está faltando, faltando usando
referência de acordo. Então, agora que tenho
esses contextos
DVI, quero nosso construtor. E então esse
construtor inicializará nosso tick no banco de dados, opções de contexto de banco
de dados. E essas opções se
tomavam como seu tipo. Vamos chamar isso Opções e depois passaremos
isso para a base, certo? Então, essencialmente, o que
estamos fazendo é injetar as opções que vêm
do nosso program.cs. E essas seriam as
opções aqui, você vê luz. E eles estavam apenas passando
para a base, que é o contexto de banco de dados
que estamos usando. Cql ITE. Tudo bem? Não, só
precisamos de uma mesa. Então, vou dizer adereço. E então vou
criar um novo tipo de dados. Vou chamá-lo de carrinho
de compras. E vamos chamar isso de
carrinhos de compras. Tudo bem, então, se estamos criando um
aplicativo móvel, pense nisso. Você está criando um aplicativo
móvel para ajudar
as pessoas a compilar o que
querem quando vão às compras. Isso é essencialmente o que
estamos fazendo aqui, certo? Então, mais tarde, à medida que o aplicativo evolui, podemos querer
colocar como alguma maneira de
identificar a qual registro do
carrinho de compras pertence, a qual usuário ou qual usuário tem esses
interesses em dois. Mas, como eu disse, estou
mantendo isso muito simples. Neste ponto, à medida que
evoluímos, podemos colocar coisas mais extravagantes. E eu coloquei isso
no lugar errado, que não deveria estar
no construtor. Peço desculpas, isso deve
ser depois do construtor. Lá vamos nós. Portanto, essa é a propriedade
no contexto do EB. Dentro do Framework Core, terei que fazer é colocar
nas propriedades. E, na verdade, esse deve ser um conjunto
DB do tipo carrinho de compras. Então me perguntando por que
parece tão estranho. Portanto, o conjunto de banco de dados do tipo carrinho compras
obtém, não
é um carrinho de compras é um tipo de dados que precisamos. Então, vou apenas criar isso. E vou gerar
essa classe em um novo arquivo. Então agora temos esse arquivo de carrinho de
compras. Eu posso apenas pressionar F 12 com ele selecionado e ele
saltará para sua definição. Não, o que um carrinho de
compras tem? Não, a maioria das entidades,
e eu diria que todas as entidades do seu banco de dados devem sempre
começar com o NAD. Tudo bem? Poderíamos ter
nome do item, nome do item. Tudo bem, como estou
nisso corretamente, estou aqui tentando
pegar atalhos, mas é como meu,
meus sentidos de programação são formigamento. Primeiro, quando você está adicionando
algo a um carrinho de compras, você provavelmente usaria
digitar o nome do item. Você provavelmente
digitaria a quantidade que você espera pegar. E talvez você queira definir um sinalizador para ver se ele
está selecionado ou não. Você pegou ou não? Então, aqui está uma string
para o nome do item. E então temos int
para a quantidade. Ou pode ser o dobro para a quantidade porque você
poderia dizer 1.5 ou algo assim. Oh não, você pode escolher o tipo de dados
apropriado, então quantidade e um
booleano que diz ser. Então esses são nossos
tipos de dados, certo? Saiba que temos aquela
tigela que eu estava correndo. Então agora que eu tenho o modelo
básico para aparência da minha
entrada no carrinho de compras. Ele diz, pule de volta para o contexto do banco de dados do carrinho de
compras. E o que vou
fazer é substituir o método para criação de
modelos. Então, quando você escreve
a palavra substituir, ela perguntará o que
você gostaria de substituir? E estamos substituindo
uma criação não modelo, e então ela só
gerará tudo isso para nós, então precisamos dessa primeira linha. Depois fui ver uma entidade de pontos do
ModelBuilder, aquele carrinho de compras. E então eu quero
dizer que isso tem dados. Então, nesse caso, o que
estou fazendo é semear o banco de dados com alguns dados para que, quando
executarmos nossa API para verificar, veremos os dados lá, certo? Assim, os dados usam uma coleção de objetos de qualquer tipo que você
esteja especificando aqui. Então eu diria que novo carrinho de
compras e, em seguida, daria isso uma identificação de um é
pego seria igual a quedas. E o nome do item seria, vamos ver, sabão e
isso é uma string. E então o final
seria quantidade. E precisamos de três barras de
sabão, por exemplo, certo? Então, só vai levar
uma coleção praticamente. Assim, podemos apenas vírgula, separa esses objetos
quantos objetos você quiser. Obviamente, cada um deve
ter um ID diferente, pois id será automaticamente visto como uma chave primária
no banco de dados. Então, vamos misturar um pouco. Vamos conhecer esse verdadeiro. E isso seria criado e
devemos pegar dois
pães. E este pode permanecer quedas, e este deve ser shampoo. Só estou
inventando isso à medida que vou junto,
pois não é a lista de compras da Mariel. Lá vamos nós. Portanto, temos três itens
que queremos semear em nossa tabela de banco de dados
quando nosso aplicativo for executado. E nós conectamos praticamente
tudo para ter um banco de dados no momento, em tempo de execução, certo? Então, o que vou fazer é ir para pacotes
NuGet e instalar mais
um pacote, pelo
menos por nulo. E esta seria ferramentas de encaixe do
Entity Framework
Core que nos
darão acesso a determinados
comandos que podemos executar porque precisamos criar
a tabela no banco de dados. Vamos em frente e pegaremos
as ferramentas, instalaremos isso. E se você olhar,
você pode conferir meu curso Entity Framework Core se você não estiver tão familiarizado,
não tão confortável com o
Entity Framework Core. Mas, em poucas palavras, isso nos permite executar esses
comandos onde podemos adicionar uma migração e
atualizá-la para serem switches, que vamos
nos concentrar agora. Então, vamos para Ferramentas e vá para o gerenciador de pacotes NuGet
e iniciamos esse console. E então vou dizer
adicionar migração de hífen. E então vou dizer
criar banco de dados. E então pressionamos Enter, deixe-o pensar sobre isso um pouco. Então, uma vez feito isso, obtemos nosso arquivo de migração, que eu não
vou entrar nos detalhes, mas em poucas palavras está vendo criar tabela e
inserir os dados. E nós tínhamos semeado três
registros, certo? Então, o próximo comando
seria atualizar o banco de dados hífen. Se o banco de dados não existir, ele irá em frente e
criará e, em seguida, seguirá em frente e colocará
todos os registros. Então, neste momento, nosso
banco de dados deve existir. Você pode ir em frente, construir
e executar e apenas testá-lo. Mas é claro que ainda não
construímos o ponto final. Então, quando
voltarmos, criaremos o endpoint da API
que nos permite consultar ou recuperar esses registros que sabemos que estão
no banco de dados.
6. Explore métodos de GET: Oi pessoal, bem-vindos de volta.
Então, acabamos de configurar nosso banco de dados agora
queremos configurar nossos primeiros endpoints para que possamos
ver o que está no banco de dados. Porque quando o banco de dados foi criado em tempo de execução
na criação modal, queríamos ver
esses registros,
portanto, pelo menos esses registros devem estar no
banco de dados e tudo o que
queremos pelo menos recuperar eles
e veja como a API funciona. Então, o que vamos
fazer é seguir o modelo que nos
foi dado. Sim, são
previsões meteorológicas e sim, os dados são inversor estático em termos de
ser apenas esse array. Mas o princípio por trás como vamos ler
nosso código é o mesmo. Abaixo ou previsão do tempo logo acima da execução de pontos do aplicativo. O que vou fazer é
escrever pontos, esfregar, pegar. Tudo bem, então o que
acontece é que, para todos os métodos que
você gostaria de usar, você pode ver um mapa e, em
seguida, o tipo de método. Então, queremos obter,
obter meu
PUT, postar ou excluir, etc, certo? Então, à medida que passamos por eles, você verá esse
tipo de padrões. Então vamos ver o esfregão chegar, e então temos que
dar o endereço. Então, para obter a previsão do tempo, você precisa ver a URL
ou as previsões do logotipo de
barra do URL do servidor. Queremos obter os itens do carrinho de
compras. Nós diríamos cortar em nossa
corda, cortar cartões de compras. Tudo bem? E então o que queremos
fazer é fazer um assíncrono. Então ficamos praticamente tão assíncronos e precisamos da nossa representação
do nosso banco de dados. Então, vou entrar em
colapso qualquer coisa que não
seja absolutamente necessária. Para que possamos ver a maior parte do que precisamos ver em
um único tiro, certo? Precisamos de alguma representação
do nosso banco de dados. Então, vou ter que ver o banco de dados
assíncrono criar um objeto. Só vou chamá-lo de dB. E então criamos
uma seta do Lambda. E então podemos escrever
nosso código praticamente. Tudo bem. Então, vou mover isso para baixo e terminar com um ponto e vírgula. E então nosso
código de função estará
nesta seção
do método, certo? Então, vou dizer um banco de dados estranho. Carrinho de compras de pontos, carrinhos de compras
universitários. Tudo bem. Lista. Então, praticamente estou dizendo
selecionar estrela dessa tabela. Tudo bem? E praticamente isso é
o que ele vai fazer. Então, vamos rever isso, veja isso legal e limpo. Então, se você não estivesse
acostumado com APIs mínimas
e está acostumado a
controladores, você sabe o que, como você teria um
arquivo grande para realmente apenas essa linha de código com método antigo
e tudo mais. Então esta é uma boa maneira
sucinta de ver. Quando você atinge esse endpoint, obtenha uma cópia do banco de dados do nosso construtor
de serviços, consulte e retorne, seja qual for. Então isso é realmente
tudo o que precisamos fazer. Tudo bem, então
vamos testar os dedos dos pés. Vou apenas
ir em frente e correr. Tudo bem, então agora
vamos testar isso. Vou apenas seguir em frente
e executar o projeto da API. E imediatamente você
notará que temos nossos novos
endpoints, certo? Então, temos nosso endpoint GET. Podemos expandir isso
e podemos vê-lo, experimentá-lo e, em seguida,
podemos executar. Portanto, neste momento, ele deve
atingir o método que vai para o banco de dados e
recupera nossos registros. Excelente, tudo bem, então agora
sabemos que uma ou API, sim, está sendo executada em nosso banco de dados
foi criada e os
registros estão lá em três, podemos recuperá-los e interagir com nosso
banco de dados por meio de nossa API. Então, antes de sairmos, vou implementar
o outro tipo de GetMethod. Então eu consigo recuperar
dados, certo? Normalmente, você quer todos os dados
ou quer alguns, alguns dos dados. E a forma como determinei
a soma seria alguma. Então, ME SOMA. Mas a maneira como você determina qual subconjunto dos dados
desejados seria por meio algum parâmetro fornecido e seguida, você executa uma consulta
com base no parâmetro. Tudo isso para ver
dificuldade em uma APA, você tem dois tipos de portões. Antes de qualquer outro tipo de portão, você tem o Git, que
retorna tudo. E então você obtém por algum identificador
único que geralmente deve
retornar um ou retornar nada se ele
não puder ser encontrado, certo? Então, tudo
o que vou fazer é copiar e colar esse método getter. Vou modificar o
URL e vou ver a barra do carrinho de
compras
e depois colocar um modelo usando
chaves e dizer id. Então, espero que, quando
você chamar esse endpoint, você vai
forneça algum valor de id, o que significa que você deseja o
registro com esse ID. Agora,
neste cabeçalho delegado aqui, vou adicionar um parâmetro para facilitar
a coleta do ID. Então, vou dizer int id, vírgula carrinho de compras DB context. Sabemos que isso já
é fornecido pelo, pelo sistema. Portanto, isso não vem
do usuário, mas estamos facilitando o valor de id de entrada
do usuário aqui. Em seguida, nossa consulta
terá uma aparência diferente. Não vamos ver cartões
de compras estranhos. Vá para o banco de dados
e encontre um coletor. E então eu darei a ID. E então eu posso
qualificar isso um pouco. Não, porque ele
vai encontrá-lo e devolvê-lo ou não queremos
encontrá-lo e devolvê-lo. Ou queremos talvez
retornar não telefonado. Então eu posso ver que é carrinho de compras. Então essa é a minha maneira de ver é o que foi
recuperado aqui, um objeto de carrinho de compras. Tudo bem? E eu posso fazer uma
expressão lambda e vou apenas quebrar linhas para que não
seja tão confuso. Então, vamos ver. Eu gostaria de
retornar um resultado do tipo, ok, com os dados que
você solicitou, que seria o objeto do carrinho de
compras que foi recuperado. E tenho certeza, tenho certeza que se você está fazendo
discurso aqui familiarizado com C-sharp básico. Então, expressão lambda, não
lambdas ou uma operação ternária. Oh meu, sinto muito por isso. Então, a operação ternária seria uma operação lógica onde
você vê o que é, qual é a lógica que estou
avaliando? É verdade? Isso é falso? Faça isso. Foi encontrado e é um objeto do tipo carrinho de
compras, então, ok, estamos devolvendo isso. Caso contrário, o budista vê
os resultados começam não telefonados. E isso daria 404
que discutimos antes. Agora, outro que eu
provavelmente gostaria de fazer
agora, enquanto estamos aqui, é o que se eu quisesse encontrar todos os itens que foram
apanhados rapidamente, certo. Então o problema é que
as APIs de prisão são suas, você pode usá-las, como você pode criar
tudo o que quiser. Você só se certifica de seguir os padrões. Então eu posso criar outro
importante aqui para ver pego. Então, se eles chamarem esse
endpoint, é suposto retornar itens que
foram retirados. Porque lembre-se
onde quer que a flor você veja a pegada
ou não pegou. Então, se for apanhado, só eles devem
voltar aqui. Isso vai
mostrar tudo. E este só vai
trazer de volta um item. Tudo bem, até agora pego, o que eu vou fazer é dizer carrinhos de
compras db dot ponto onde. E então colocamos
nossa expressão Lambda
e nossa condição em que ele é apanhado. Tudo bem? E porque é booleano, posso deixá-lo assim. E então eu apenas disse a
Pirataria para listar, que é a nossa declaração de execução para ou se a declaração do curso. E é isso. E praticamente nós acabamos de
criar três pontos finais em poucos
minutos, em questão de minutos. Então, uma vez que você chegar a tudo, quer receber apenas itens
retirados. Eu não quero obter algo
especificamente pela Adi, então deixe-me executar isso rapidamente
para que possamos avaliar ou trabalhar. Tudo bem, então temos arrogância, já
testamos também
se preocupa com essa. Sabemos que temos
pelo menos um item que foi
retirado era verdade alguém para
experimentá-lo e executar. E eu não deveria recuperar
tudo em vez disso, eu só recebo o único item que é pego,
seu verdadeiro Excelente. E então, se eu quiser um por ID, posso ver tentar tudo feito. Eu forneço apenas o ID de um. O registro que recebo o Buck
tem o ID de um, certo? Se eu forneci ID de dez, sabendo que não sei
o que pedi dez que estou recebendo isso para todas as
quatro respostas não encontradas. Então, tudo isso é que as
respostas funcionam, certo? Observe que quando
ele foi bem sucedido, recuperamos um acorde de 200. Tudo bem, então essa é a
resposta da chave O para 100 está bem. Então, quando você quer ser específico, você pode ver os resultados tão bem. Se você, contanto
que você devolva algo, ele estará
ativado automaticamente. Certo? Então, é realmente isso para nós
criar ou obter endpoints.
7. Explore o método de execução: Tudo bem pessoal, então estamos
seguindo em nossa aventura e vamos seguir
para o método put, certo? Então, o que temos até agora seria obter
métodos que podemos recuperar, mas e se precisássemos que eles sejam editados? Talvez eu tenha cometido um erro
quando criei o item, algo assim, certo? Então eu preciso colocar o método PUT. Então, o put praticamente
pega os novos dados e, em seguida, diz que o banco substituiu os dados
antigos por esses novos dados. Isso é essencialmente tudo o
que acontece nas saídas. Então, para aumentar nosso endpoint, vou dizer
as portas do mapa de pontos. E como eu disse, você
terá mapa atualizado. E então o método que você quer praticamente
depois, certo? Agora vamos colocar nosso padrão de
string ou nosso URL. Então, normalmente, a porta se
parece com eles em termos de como esse
modelo se parece. Então, estamos recebendo o mesmo código de barra de carrinho de
compras, certo? E então vemos que é
sink e int id. Então vamos pegar um objeto do tipo
que estamos atualizando. Então, em outras palavras, vamos atualizar
um item de carrinho de compras. Então isso significa que se você está
me enviando um registro para atualizar
no meu banco de dados, obviamente você precisa me
enviar o registro que deseja substituir. Esse registro seria esse ID, quais são os dados que
você deseja substituir? Essencialmente, isso é tudo o que é. Então eu tenho que colocar um parâmetro do tipo carrinho de compras,
carrinho de compras. Portanto, lembre-se, id está chegando
através do modelo, mas a porta a ser solicitada
geralmente enviaria os dados não estão no parâmetro é como o que seria parte
da solicitação, o corpo. Então, veremos isso
em alguns int id, carrinho de
compras, carrinhos de compras. E, claro, precisamos de
alguma representação do nosso contexto de banco de dados. E este é apenas
um grande delegado. E então nós ponto-e-vírgula
esse parêntese certo. Agora, o que eu quero fazer? A primeira coisa é que quero
ter certeza de que o que você está tentando atualizar
realmente exista. Se não existir, então eu
realmente não consigo encontrar um registro que você está
tentando atualizar. Então, vou fazer algo
como o que fiz aqui. Fui ver um peso, o método de encontrar, mas antes disso tenho que
atribuí-lo em algum lugar. Então var nos permite ver o registro é igual a olhar para carrinhos de
compras e encontrar o registro com
esse ID, certo? E, na verdade, deixe-me voltar um pouco
mais cedo, remover esta linha. O
que acontece é que vamos
ter várias coisas fazendo. Então, ao contrário dos outros em
que havia
uma linha única, teremos várias coisas fazendo, então nosso delegado realmente não pode apenas nos
permitir colocar várias linhas. Então eu tenho que colocar chaves
encaracoladas em vez
desse corpo delegado. E vou fechar isso. E então, dentro
dessas chaves, agora
posso colocar as várias
linhas de código que eu quero. Então aqui posso ver var record é igual a
carrinhos de compras db dot que acham assíncronos. E então eu posso acabar
com o ponto e vírgula. Tudo bem? Portanto, é um
estilo diferente de codificação. É um pouco
mais funcional do que processual, como você provavelmente
estaria acostumado com ambos. É apenas uma questão de
prática tornar-se permanente. Então eu queria ver
se um registro e geralmente gosto de verificar
o negativo primeiro. Portanto, se o registro for nulo
e você puder verificar se há nulo vendo equivalente a nulo ou você pode realmente ver que é nulo. Aquele provavelmente
leria um pouco melhor. Se for nulo, vou apenas retornar
resultados, pontos não encontrados. Não consegui encontrar o registro que você disse que está
tentando abri-lo? Não. Se ele for além dessa parte, vamos
querer fazer essa atualização. Então eu saí para ver um recorde de
pontos e depois vou
ter que fazer xixi e ficar legal
por meio de cada método, desculpe, cada propriedade que veio
e não estar nisso. Então, registre aqui
o que está no banco de dados. carrinho de compras aqui representa os dados do carrinho de compras recebidos, a carga útil, o
corpo da solicitação com os novos dados. Não sei se você
muda o nome. Não sei o que mudar. Então, para estar no lado seguro
depois de atualizar tudo. Então, se você está acostumado a SQL e
atualizar instruções no SQL, você sabe que precisa
mudar cada coisa dentro de uma instrução SQL
apenas para ter certeza, certo? Então, ele é pego, é pego. O que mais nós tínhamos? Nós tínhamos quantidade. Acho que não temos nada que seja global.
Não é possível atualizar o ID. Tudo bem, gostaríamos de
atualizar o ID do registro. Então, depois de termos feito
todas essas alterações, o que gostaríamos de
fazer é esperar, db dot save muda um coletor, então podemos retornar. Portanto, sempre que fazemos uma solicitação HTTP que não necessariamente tem
nada para retornar, o que vemos não é conteúdo. Então, é o broto de Solon. Não vou voltar. Ok, mas após a operação de
atualização, eu realmente não
preciso devolver os dados que você acabou de me dar
porque você já os tem. Então eu diria que nenhum conteúdo, o que praticamente significa que
eu não tenho nada para retornar. Mas esta é uma ferramenta
para, lá vamos nós. Então, basicamente diz,
não tenho nada para voltar para você, mas sua operação foi boa. Tudo é bom para ir
nesse ponto, certo? Então, vamos testar
nossa operação. Então eu só vou
rodar sem depuração. E swagger está na bola
com a codificação de cores, então ela fica em azul e depois
colocamos laranja. Posso experimentá-lo. Ninguém. Verei que você no ID
entra no parâmetro. Eu também estava vendo que o restante dos dados vai para
o corpo da solicitação. Então aqui é onde eu digo que quero atualizar o registro com o ID1. E então quais são os dados que
eu quero enviar? Então, essas são coisas arriscadas. E no meu curso completo de API de
ponta a ponta, eu aponto
os perigos de ter certos campos expostos na
vida PUT e postar endpoints. Você pode passar por esse curso. Mas, mais uma vez, estou mantendo
isso simples aqui, certo? Mas normalmente você
gostaria de usar esse valor de ID ou pode escrever o código como fizemos para não dois pontos para o
valor de id que está sendo preso. Então, digamos que eu mude
esses valores, certo? Então grave com o ID1,
vamos olhar para ele. Não. Então, se eu for para o get, experimente e diga
Mostre-me registro com o ID1. Vai
me mostrar sabonete ID1 item. Então a quantidade três
grande top é falsa. Não vou mudar
nada neste corpo de solicitação. Esse corpo de solicitação representa
os mesmos campos e valores
correspondentes
que esperariam para entrada do
nosso carrinho de compras. Então, se eu pressionar Executar, o que acontecerá é que para
todos os quatro foi bem-sucedido. E se eu voltar e recuperar
esse registro com ID1, vou
executar isso novamente. Agora vamos
vê-lo parecendo exatamente o que acabamos de enviar
como um corpo de solicitação. Então, se eu quiser mudar isso para zumbido e pegar
dez casas, certo? Executa. Tudo o que ele faz é levar
tudo aqui. E a ideia é que
ele só
substituirá o que está no banco de dados. Lá vamos nós. Tudo bem, então algumas coisas sobre
o que o Entity Framework fez. Primeiro, quando recuperamos
nossos registros, nós realmente os recuperamos. E há esse recurso
chamado caminhão que está habilitado em um recuperá-lo
assim com caminhões, quaisquer alterações que
você fizer em qualquer uma
das propriedades são os valores. Você pode simplesmente chamar Salvar alterações. E
saberá automaticamente que isso foi alterado porque ele estava
rastreando os valores. Então, uma vez que esta linha é executada, ela sabe que esse registro não
está aspas sem aspas sujas. Então, quando você vê se o GnG
está olhando para esse registro e executa as alterações
que foram feitas, praticamente é isso
que acontece, certo? Existem outras maneiras
porque você pode recuperar dados sem rastreamento. Então, o que acontece é que, quando você tem
centenas de registros provavelmente não quer
rastrear porque isso pode causar problemas de desempenho. Então você veria as pessoas
colocadas como mais rastreando
suas consultas. Mas isso geralmente é mais para aplicativos que atingem
esse estado de manutenção. Até agora, uma API não
existe realmente, não
há realmente nenhum
estado que seja recuperado. E isso é apenas um momento
ensinável. Só estou ajudando você a entender o que é o
rastreamento e por que
isso
funcionou assim sem chamarmos
db dot update. Tudo bem. Então, isso é praticamente para nós
montar a saída. Assim, você pode pensar todas as saídas que
você pode querer configurar. Mas, para não,
esse é bom o suficiente.
8. Explore o método de POST: Nosso cara. Então, vamos ver a
criação do nosso método de postagem. Então, apenas para fazer isso de forma
simples e rápida, vou copiar o método puts e
colá-lo novamente. E vamos
ver um post de esfregão, postar. Este endpoint não está
disposto a ter nenhum parâmetro nele. Então, só vai
ser um carrinho de compras de barra. E então vamos pegar este espirômetro e só estamos aguardando a carga útil no corpo
da solicitação, certo? Portanto, esse
objeto de carrinho de compras é o que esperamos obter dois bancos de dados do Editor
em termos do código, não
precisamos fazer nenhuma verificação. Tudo o que precisamos fazer é adicionar este
item de carrinho de compras ao banco de dados. Vou dizer carrinho de compras
db dot. Ou eu poderia, na verdade,
apenas dizer db dot estranho. E então nós apenas damos
esse objeto de carrinho de compras. E então salvamos as alterações. Então, o que vamos retornar seria uma resposta Created. Então, criado teria
uma ferramenta uma, certo? A ferramenta 1 é o código de status. Então criado. Você também pode dizer
algo mais como criado para rota. Então você pode me dar o nome da raiz e outras coisas extravagantes. Mas vou
mantê-lo simples, criado. E então vamos
devolver alguns dados a ele. Então, ele sabe que ele foi criado
no carrinho de compras de barra. Portanto, a resposta terá a barra do endpoint
e, em seguida, o ID. Então, basicamente, o que estamos
vendo é se você for cortar carrinhos de
compras com o ID do ponto do carrinho de
compras, então você pode encontrar esse método, encontrar esses dados, desculpe. Em seguida, retornamos o objeto
real. Então, essencialmente criado
e estamos dizendo a string para onde ela pode
ir para ver os dados criados. E então essa é a carga útil de dados
real junto com a rota para
a qual você poderia ir. E é essencialmente isso. Então, vamos testar este antigo. Então, codificação por cores é
que, mais uma vez, temos nosso método post aqui. Experimente. Ah, e eu não deveria estar fornecendo uma ideia
quando estou criando, mas já discutimos isso,
que estamos apenas mantendo
as coisas simples aqui por enquanto. Vamos tentar outro
item. Desta vez. Quero cereais, e quero
duas caixas de cereais. E ainda não foi
apanhado. Então, quando executamos isso,
isso representa nossos
objetos que estavam enviando para o banco de dados
e C é criado, ele obtém o ID para e
tudo está lá. Então, se eu fizer um get
all e executar, verei 123 e nosso item recém-criado,
item quatro. E é isso mesmo
para todos os métodos de post. Então, mais uma vez,
esperamos pela carga útil, que então obteve o que causará desserialização nesse objeto. E então nós o adicionamos
ao banco de dados e depois
salvamos as alterações. Então, o que você veria com Entity Framework
Core é que você poderia realmente dizer db dot add, e add leva algum tipo. Ele realmente não sabe que
tipo pode ser tentado. Mas desde que esteja fora
da entidade ou desde que ela possa encontrá-la no contexto
do banco de dados e você
não terá nenhum problema. Você também veria db dot e , em seguida, a tabela específica
e, em seguida, esse anúncio, certo? Então, eu só estou mostrando que
você poderia fazer qualquer um realmente db
dot adicionar carrinho de compras. E então ele sabe que é apenas
salvar as alterações e ele encontrará a
tabela apropriada para colocar nos dados. E vimos que isso funciona. Então é isso para o
nosso método de postagem.
9. Explore o método de DELETE: Estamos de volta e desta
vez vamos
analisar o método de exclusão. Então, vamos fazer a exclusão do mapa. Mais uma vez, vou
pegar nosso PUT e , em seguida, vamos ser
adaptados para ser Delete. Tudo bem? Então, tenho certeza que você sabe o que é, mas sei que não
importa a ordem em
que você coloca os métodos. Não foi
falsificado qual executado primeiro
sic no nosso terceiro porque não importa Não
é uma questão da ordem cronológica ou
a ordem do método é exatamente qual é
solicitado em que 0.1 coisa que devo
salientar é que você nunca deve ter dois
dos mesmos métodos com
o mesmo endpoint. Então, vamos voltar para o bem. Temos várias obtenções, mas observe que cada um tem um
endereço de endpoint diferente, certo? Então, se eu tivesse que obter métodos com os mesmos carrinhos de compras, isso causaria um problema. Mas porque eu mapeei
as postagens de um Nmap, onde é que é para
acertar? Minha postagem. E ambos como
cortar o carrinho de compras, isso não causa um acidente porque um está entrando, um é postar. Então, se eu esqueci de
mudar isso e adicionar as duas colocações de mapa com o
mesmo valor de ponto final. Isso só causaria um problema. Vamos, na verdade, olhar para isso. É bom ver esses
erros para que saibamos o que estamos diagnosticando quando nos
deparamos com esses desafios. Quando você faz isso e
resolve suas cargas, ele apenas dirá
que o ódio falhar carregar não está dando
mais dados do que isso. Se você conseguir algo assim, volte e verifique e
certifique-se de que você não está
cometendo esse erro. Então, uma simples correção aqui
é dizer mapa, excluir. E vai ter que manter o mesmo endpoint porque
queremos um guia de compras. Vou precisar do ID do
que vamos excluir, o que não precisamos, no entanto, são os dados que vamos excluir porque sempre podemos usar
o ID para encontrar o registro. Então, aqui temos o registro. Se não for encontrado, retornaremos não encontrados. E então o que vou
fazer é apenas dizer db dot. Seria db dot remove. Lá vamos nós. Às vezes
eu esqueço essas coisas. Então, db dot remove e
removeríamos o registro
que encontramos com esse ID. Nós salvamos as alterações, então
eu apenas pressiono Salvar. E o que acontece é que
há um recurso no Visual Studio 2022
chamado Hot Reload. Então essa é aquela bola de fogo aqui. Assim, você pode realmente
habilitar isso ao
salvá-lo , faça um Hot
Recarregar automaticamente. Pode te levar
como se estivesse me motivando. Mas você sempre pode
apenas tocar em recarga quente. Então, se ele não puder simplesmente recarregá-lo, você pode simplesmente dizer reconstruir
e aplicar alterações. E ele fará o que
precisa fazer em segundo plano enquanto você
ainda estiver executando sem depuração. E quando você estiver executando
sem depuração, você teria essa janela
do console aberta. Então, às vezes você
pode tentar algo, eu simplesmente não estou funcionando corretamente. Basta verificar a janela
do console. Talvez seja necessário
fechá-lo e depois começar de novo. De qualquer forma, Hot
Reload nos permite recarregar nosso documento Swagger. Sei que estamos vendo ou
excluindo o endpoint corretamente. Então, se eu experimentar
e tentar excluir um registro com o ID
para o qual é o que
acabamos de criar. E nós executamos isso. Vemos, estamos retornando
esse todo o conteúdo. Então, excluir é outro ponto
final para o qual você não
pode retornar
conteúdo, certo? Está perfeitamente bom. A janela do console, enquanto
estamos no modo de desenvolvimento, você veria essas
consultas sendo cuspidas nisso no console. E isso pode ser
útil para você ver o que é gerado quando você executa esses
comandos do EF Core com o pé direito, embora não
precisemos necessariamente nos concentrar nisso. E, neste momento, temos nossa
API de multidão em funcionamento. Agora, quando voltarmos,
vamos limpar nosso código e fazer com que isso pareça um
pouco mais apresentável.
10. API de teste com o Swagger: Tudo bem, então
vamos voltar e vamos testar isso. Então eu só vou rodar sem depurá-los um
pouco mais rapidamente. E vamos usar a ferramenta
swagger para testar essa API. E agora uma alternativa ao
Swagger teria sido como carteiro ou algo
parecido com isso. Mas a saga é capaz, então vamos usá-la agora. Então, quando expandirmos nosso get, isso implica que vamos voltar
a subir. coleção verá a amostra, o objeto de amostra do que
estaremos recebendo de volta. E observe as chaves quadradas, as representações de que
será uma matriz de objetos. Vamos pegar, experimentá-lo e
executar em que ponto ele realmente vai em
consultas no banco de dados, e há todos os carros de amostra que
teríamos inserido certo? Agora, se eu tentei obter por ID, deixe-me tentar esse. Então experimente tudo. Diz me
dar a ideia, vou dar dez. E recebemos de volta a resposta 200 com
o carro com o ID dez. Eu tento com um 100. Eu não tenho 100 carros. Então desta vez eu
compro isso para todos os quatro porque ele não
conseguiu encontrar aquele carro. Má ideia, certo? Você pode prestar atenção para
liderar os URLs de resposta. Ou seja, isso é o que
chamamos de URL base porque
esse é o servidor. E então esse seria o caminho, e então esse será o nosso valor
id passando, certo? Portanto, é bom prestar
atenção a essas coisas porque quando estamos escrevendo
código para interagir com a API, temos que imitar esses tipos de URLs para que verifique se
tudo obtém por ID funciona. Vamos tentar o Pulitzer. Se eu tentei modificar o
carro com ID1, vamos transformá-lo em uma string, string,
string, string, string. Então, deixe-me primeiro
recuperar o carro com o ID1 para
que possamos ver como era. Então esse é o carro com o ID 1 e pegamos nossa cópia
rápida dele. É um Honda Fit, ABC do Vinny. Agora, quando eu executo isso, percebo que teria que colocar todos os detalhes e
tendem a atualizar a largura. Então, se eu deixar os padrões
e clicar em Executar, ele não
me dirá nenhum conteúdo, o que significa que foi bem-sucedido. Se eu tentar recuperar
esse carro
novamente, verei
que ele não está funcionando. Vamos definir o cabo. E meu amigo. Isto é, esses são meus erros bobos. Então, na verdade, misturou as atribuições que eu
deveria ter atribuído. Registre que o valor está
chegando através do carro. Então peço desculpas por isso. Maquiagem que tenho na minha recarga
quente no Save, então eu deveria ser capaz de
voltar e tentar novamente. Então isso é executado. Estamos vendo um Honda
Fit e tudo mais. E então, quando
tentei executar aqui, recebo a ferramenta para. Então, não, estou vendo, lá vamos nós. Então, agora estamos vendo tudo
mudado para uma string. Meu engano bobo pessoal. Então isso funciona. E é por isso que o
teste é importante. Tudo bem, então
deixe-me voltar para minha carga original e, em
seguida, executar novamente. E então podemos
verificar se agora
vemos os dados originais,
certo, com boa aparência. Em seguida, o final
é a exclusão. Então, qual deles
eu gostaria de excluir? Deixe-nos continuar o eu
não sou , não quero ver que
tipo de carro eu não gosto. O que vou excluir. O que eu
menos gosto
nesta lista seria o
carro com a ID quatro. Vai ser pequeno demais para o meu gosto. Então, lá temos
a ferramenta para isso sugere que ela foi
concluída com sucesso. Então, se eu voltar e executar, não
há mais um
carro com o IED quatro. Assim, nosso código funciona.
11. Revisão da API: Certo pessoal, então a
última escuta nos deixou com nossa API de trabalho que faz operações crud
básicas. O que não queremos
é o código de acesso. Não queremos as cotações de
previsão. Fui remover isso. Também vou remover o
Record na parte inferior. E agora, tudo o que temos é o código que sabemos que
precisamos absolutamente. Saiba que existem
maneiras diferentes de organizar
sua API mínima
porque você pode sua API mínima
porque você pode criar métodos para os quais
obstrui o código. Você poderia colocá-lo em uma classe diferente e depois
chamá-lo de middleware. Existem várias
maneiras de fazer isso. Eu realmente não vou entrar em todas essas maneiras, certo? Não. Mas pelo menos no
final deste exercício, você saberá como
criar API usando o
estilo de codificação mínimo que pode fazer multidão contra o banco de dados.