Transcrições
1. 1. INTRODUÇÃO: Oi pessoal. Este é um tutorial sobre a API
mínima no dotnet six. Agora, antes de começar
este tutorial, vou explicar um
pouco do que você pode esperar e o que eles não
esperam neste tutorial. Então, o que você pode esperar
é que eu
mostre como criamos
APIs no dotnet. Tudo bem, é do seu jeito. Após a morte, mostrarei como
você cria, pode criar uma
API mínima no dotnet six. Para isso, vou
criar um novo projeto, então vamos
começar do zero. Assim, você pode ver
tudo o que é necessário para criar uma API mínima, o que não é muito,
daí o nome mínimo. Vou mostrar
um pouco sobre a injeção de dependência
e a API mínima. Além disso, mostrarei como
você pode criar uma API mínima assíncrona. Portanto, o que não se pode esperar é uma explicação detalhada sobre a
API e as APIs em geral. Espero que você tenha algum
conhecimento sobre isso, porque eu não
vou te contar. Além disso, este não é um tutorial
para C Sharp para iniciantes. Se você não tem
conhecimento suficiente sobre o C-Sharp, eu recomendo que você
siga um curso básico antes de iniciar
este tutorial. Então, com isso, vamos começar.
2. 2. Requisitos: Antes de começar o
tutorial ou curso, costumo dizer
às pessoas quais tipos de requisitos devem ser
seguidos pelo tutorial ou curso. Nesse caso, usarei versão
comunitária do
Visual Studio 2022, que é gratuita e fácil de
baixar da Internet. Outro requisito é o conhecimento
básico de C Sharp. Se você é
iniciante ou C-Sharp, ou nunca programou
em C Sharp antes, não é
aconselhável
seguir suas pontuações. Outra coisa que você
deve saber é a injeção
de dependência. Você deve conhecer a ideia básica da injeção de dependência,
como ela funciona, como configurá-la
em seus programas, como usá-la. E o último
requisito é assíncrono. Pelo menos não
prejudicou o termo. E você sabe um pouco sobre o que ele faz e
por que é usado. Então, se você atender a esses
requisitos, comece.
3. 3. API NET 5: Como eu disse antes,
vamos dar uma olhada
nessas cinco APIs antes de
começarmos com a API mínima
da Netflix para adultos. Então, na minha tela, tenho a API
Adult Net Five aberta. Esse é o projeto.
Tem uma solução. Ele tem um projeto como todo
aplicativo dotnet que você cria. O que mais se destaca
são os controladores de pastas. Dentro dos controladores,
existem classes, neste caso uma, que
é o controlador real. Quando abrimos um controlador, você pode ver determinados métodos,
atributos e propriedades. Ao abrir um controlador, você verá a classe pública, o nome do
controlador, que herda do controlador. Esse é um código estruturado, então é isso que a Microsoft
oferece quando você cria uma nova API
e está tudo bem. Não vou criar
um
aplicativo de busca de dotnet totalmente novo para pequenas informações. Não há um
construtor e
também há um método chamado
de ação. Agora, isso normalmente é a API
dotnet five. Ele tem uma pasta controladores, que contém as classes, que são os controladores dentro das ações do controlador. E cada ação tem certos tipos de
retorno ou não. Além disso, temos que
mudar as coisas, o program.cs e depois as startups. Sim. As coisas de Epstein são para a configuração
do seu Programa, que também está no dotnet six. Portanto, isso não é algo para o qual
vamos dizer adeus. O que dizemos adeus
é que a startup startup dot cs é basicamente a configuração
do seu projeto. Aqui você pode configurar se
deseja usar swagger ou injeção de dependência ou
algum tipo de registro
ou qualquer outra coisa, você pode configurar seu
contexto de banco de dados se tiver um com Entity Framework e muito mais, isso será movido
para o program.cs. E o program.cs
é como, você sabe, todo aplicativo dotnet
tem um arquivo de programa dot cs. É aqui que o
aplicativo realmente começa. Se eu deveria executar isso, ele funciona como uma API normal. Ele foi criado, inicia seu navegador
padrão e você tem a API e pode
experimentá-la se quiser. Bem, tudo isso é legal e outras coisas. Mas não é isso que
vamos criar. Vamos criar uma API CICS de rede
adulta. Essa é a maneira antiga. Talvez isso seja familiar. Eu só queria
te mostrar por precaução. Agora vamos criar a API da Netflix para
adultos.
4. 4. Crie a nova API: Agora sabemos como o Dotnet
Five Old Way funciona. Vamos criar uma nova
API no dotnet six. A primeira coisa que você
precisa fazer, é claro, é inicializar o Visual Studio. Normalmente, você terá alguns projetos recentes ou os
removerá todos para
esta demonstração. Mas, para criar a API, você cria um novo projeto. Quando você clica nele
, ele carrega todos os modelos e você pode selecionar o
modelo desejado. No lado esquerdo, tenho alguns
modelos de projetos recentes que já contêm o
tipo de projeto que eu quero criar. Mas, para se divertir,
vamos procurá-la. Quero criar uma API. Então, na
caixa de pesquisa, eu digito API. Alguns
resultados estão aparecendo. As duas primeiras são a API Web Core do
asp.net e a terceira também. Há uma diferença muito
grande. A grande diferença é
que são os idiomas. O primeiro é C nítido, o segundo é Fá nítido
e o terceiro não é, na verdade, a API. É o aplicativo web asp.net Core. Eu quero criar uma API, então vou selecionar a primeira
porque quero criá-la em C-Sharp
e não em Fá nítido. Além disso, no texto, você
vê Linux, macOS, Windows, nuvem,
servidores, web, API da web. Então, isso basicamente
significa que você também pode executar essa API em Linux
e macOS, se quiser. Clique em Avançar. Agora eu preciso dar a
ele um nome de projeto. Vou usar apenas um nome de demonstração, mas sempre pense no nome que você deseja
dar, porque ele quer ser algo que o lembre do
que você está criando. Vou chamar isso de demonstração
mínima da API. Vou manter o local que
não é o padrão, qual é o
repositório em algum lugar? Bem, o fisher studio armazena
seus projetos por padrão. E o nome da solução também
será igual ao nome do projeto. Eu clico em Avançar. Cada projeto tem suas próprias
informações adicionais. Nesse caso, a API
precisa de alguns extras. Se você criar um aplicativo de
console, você só precisará
selecionar a estrutura. Nesse caso, preciso
selecionar mais algumas opções. Nesse caso, usarei
a estrutura donut six. Se eu abrir, posso
selecionar dotnet five, que também diz fora do suporte Se eu clicar na rede para cães cinco, você verá que algumas opções
desaparecerão abaixo. Essas opções têm tudo a
ver com a API mínima. Portanto, let five não
suporta API mínima
e, portanto, preciso
selecionar dotnet six ou superior. Eu quero configurá-lo para HTPS, é
claro, habilitado para mais escuro. Eu tenho o Docker
instalado nesta máquina, mas não vou
habilitá-lo no momento. Em seguida, tem uma
caixa de seleção que diz usar controladores e
marcar, usar o mínimo de APIs. Se você começar com
isso pela primeira vez, isso será verificado. Se você mantiver isso marcado, obterá a queda de
largura para controlar isso, o que não é algo que
queríamos desta vez porque queremos
criar uma API mínima. Então, queremos nos livrar
dos controladores. Então, vou manter isso desmarcado
Habilitar suporte ao OpenAPI. É um nome chique para arrogância. Mantenha-o ativado. Porque dessa forma, podemos testar
nossa API quando a executamos. Não use as declarações
de nível superior. Isso também é algo para
dotnet six e superior. Você pode selecioná-lo ou não. Vou mantê-lo desmarcado
para este tutorial. Se você estiver satisfeito com suas
configurações, selecione Criar.
5. 5. Arquivos e pastas: Agora temos que
descartar a API CICS criada e temos o
Visual Studio aberto. E vamos dar uma
olhada mais de perto
na estrutura
de pastas desses novos projetos. Vamos ampliar esse explorador de
soluções. Novamente, temos nossa
solução e nossos projetos, e esses são os
arquivos e pastas do andaime. Não vou falar
sobre todos eles em profundidade. Eu só quero mostrar que
as coisas que Jason ainda estão disponíveis e
só há um arquivo de classe, o program.cs, os
controladores de pasta sumiram e o startup.js também
não está disponível. Então, se você abrir o program.cs, verá que tudo
está configurado nesse arquivo. Agora você tem um
construtor onde ele cria o aplicativo web e a forma de criar, ou você pode adicionar serviços ao
seu aplicativo. Isso também significa que, para a planilha de
pensão e o contexto do seu banco registros e outras coisas, você
precisará ao
criar sua API. Você também verá que
todo o andaime sobre a previsão do tempo também está colocado neste ponto c.
do programa. Sim. Tudo o que estava em classes
diferentes e em um controlador agora é colocado
nesse arquivo específico. Aqui você pode ver o resumo
do tipo de tipo de clima. Abaixo. É um mapa obtido, que na verdade é um mapeamento para um ponto final específico
da sua API. Na verdade, esse código estava no
controlador em dotnet five. Isso agora está em um arquivo. Ele tem um corpo de
expressão lambda que é na verdade, a função que
retornará a previsão, que simplesmente não é
a previsão real. Portanto, este é seu primeiro exemplo
da API mínima de que
tudo está em um arquivo. E com os mapeamentos,
você pode criar os diferentes
endpoints da sua API. Inicie este aplicativo. Podemos ver o que ele faz. Inicie o navegador padrão
e você verá o swinger. E isso parece exatamente o mesmo que com o aplicativo
dotnet porque aqui eu tenho
meu terminal para a previsão do tempo.
Eu posso experimentá-lo. Eu posso executar. Do lado de fora.
Nada mudou, mas por dentro muita coisa
mudou porque agora eu não
tenho mais controladores. Eu tenho apenas um
banco de arquivos e configuro, crio e gerencio toda a minha API.
6. 6. Mapeamento — Preparações: Portanto, esse é o
suporte básico de informações e códigos para a
API no dotnet six. A próxima etapa é
criar mais mapeamentos. Temos um mapeamento para diferentes métodos de solicitações
HTTP. Nesse caso,
quero usar o get
the post para excluir
isso para atualização. Então, antes de fazer isso, criarei algumas camadas
extras e preparativos antes de
entrar nas outras métricas. Então, primeiro vou criar uma
nova classe para um filme. O Dish criará um
ID, que é um int. Quero criar um título. Então, eu posso realmente
nomear o filme. E eu quero dar a ele uma classificação, que também é um
número inteiro, com classificação de 1 a 5. Em seguida, quero criar uma lista filme sombrio
que acabei de criar. E eu quero usar o filme. Id é um. A classificação é, vamos dar cinco. E o título é Trek. Não é um filme. Classificação Id2. Um. O título é decepção. Novo. Ideia. Três. A classificação é três. O título é, você pergunta só
porque é muito antigo. E, novamente, o novo ID para classificação é um e o título
é The Green Lantern. E por último, mas não
menos importante, o id é cinco. A classificação é cinco. O título é a matriz. Agora, ele me dá uma linha vermelha e diz que
as declarações de alto nível devem prosseguir. Declarações de namespace. Vamos mover isso. Vamos mover
isso um pouco para o topo e o erro desaparecerá. Tudo bem, então agora também
vamos excluir os mapas e os registros internos. Mantenha o aplicativo Dot em execução. Se você remover esse, o aplicativo não será executado. E é muito importante, eu realmente não entendo mais,
abduzir John
não está atrasado nas integrais da última
linha, mas também removeu os resumos porque não os usaremos mais e temos uma aplicação
muito clara. Então essa é a preparação. E agora vamos criar os mapeamentos
começando por obter, que é o mais simples.
7. 7. Mapa: Tudo bem, então o
primeiro mapeamento que
vamos criar é o Get, que também são os
métodos de solicitação, HTTP GET. Essa é a
mais simples porque a API
receberá uma solicitação
externa para retornar alguns dados. E esses dados são exatamente
o que queremos devolver. A primeira coisa que precisamos fazer
é criar mapas de pontos de aplicativos. Isso significa que queremos
criar uma solicitação HTTP get. No dotnet five, tivemos que
adicionar alguns atributos para dizer à API que é um
GET ou post ou qualquer outra coisa. Não precisamos mais fazer isso. Podemos simplesmente criar um mapa de pontos do
aplicativo, obter. Certifique-se de criar
os novos mapeamentos e todos os outros tipos de mapeamentos
acima do ponto de execução do aplicativo. Não os crie abaixo deles. Mapa. Obtenha. O primeiro parâmetro
é o padrão. O padrão é,
na verdade, o endpoint da API outros aplicativos podem
apontar para obter os dados. Nesse caso, quero
chamá-lo de filmes, mas é uma API. Então, vou colocar a API na frente
para que saibamos que são dados. Nós obtemos de uma API. Vamos adicionar outra
barra na frente. O segundo parâmetro
é o aprendizado delegado
ou, neste caso, o corpo
da expressão lambda, que executa porque para
retornar filmes neste caso. Então, vou começar com
uma função anônima, criar registros e
dizer resultados de retorno. Ok, então o chamador sabe que receberá um código de
status de 200, o que significa que está tudo bem. Desculpe-me. 204 significa que está tudo bem. Ele foi executado, mas
você não retornou os dados. Nesse caso, serão 200 porque vou
devolver os filmes. E não se esqueça do
ponto e vírgula no final. Esse é basicamente o mapeamento de API mais
simples. Você vai conseguir. O mapa de pontos obtém, este é o endpoint
API slash movies. O corpo retorna os resultados, ok? E o perímetro são filmes,
que é a lista de filmes. Posso começar agora com
a API e vamos criar e iniciar o navegador
padrão. A previsão do tempo acabou. Agora vemos os filmes de corte da API. Eu posso clicar nele para abrir,
experimentar, executar. E eu tenho isso. Esses são meus filmes. Então esse é o mapa. Obtenha o mais simples. E vamos passar para
algo diferente. Vamos pegar um filme por ID, que também é uma solicitação GET. A propósito, um
parâmetro na URL.
8. 8. Mapa GET com parâmetro: Então, o próximo é o mapa
com um perímetro, neste caso a identificação de um filme. O que eu quero criar é você pode obter um único
filme da API fornecendo uma ID no ponto final, é muito semelhante ao que
o mapa anterior obtém. Então, eu posso realmente
copiar e colar isso. E a única coisa que vou mudar é adicionar
um
ID de colchetes no ponto final
dos filmes, e precisa haver uma
barra na frente dele. Agora eu crio um
endpoint que diz filmes de
API e o
ID de um filme. E a próxima parte é que,
em uma função anônima, incluirei o perímetro
neste caso id. A API notará que
há um parâmetro extra
e, em seguida, apontará, ele tentará analisar esse
perímetro para um número inteiro, e então eu poderei
usá-lo em meus métodos. Nesse caso, retorne
os resultados, ok? Filmes gravados, identificação única
é igual a fornecer uma identificação. É basicamente isso. Eu posso iniciar a API agora. Vejo uma segunda API de endpoint, filmes,
ID de colchetes e colchetes. Eu posso abri-lo,
testá-lo para identificação, vou escolher executá-lo. E aí temos nosso
filme com ID to. Eu posso mudar o ID
para quatro, executar, e vou ver o filme
com um ID para este caso, normalmente, o Lanterna Verde.
9. 9. POST de mapas: Então, a próxima parte é
sobre a postagem. Em alguns casos, você deseja publicar dados dos
clientes na API. E para preparar a API
para uma solicitação de postagem, vamos mapear a postagem. Para criar isso, simplesmente criamos um novo mapa de pontos, map boast. E tem o mesmo ponto final. Ou para começar filmes. E é isso porque
eu queria enviar um filme para os filmes da API do
endpoint. Em um breve
mapeamento do ID, tivemos que criar um
parâmetro na URL. Nesse caso, substituiu
o endpoint como S, neste caso, filmes da API. Mas vou adicionar o tipo de classe Movie com um nome na
lista de parâmetros do meu corpo. Nesse caso, a
API sabe que quando o endpoint de filmes da API com os
métodos de solicitação de postagem é chamado, deve
haver um objeto
no corpo que represente
a classe Movie. Eu fui aos pontos. Posso continuar neste caso, posso dizer filmes,
imprimir e publicar filmes. E é isso. Normalmente, com um chefe, você não retorna dados e
talvez apenas um objeto criado. Para fins de demonstração, usarei uma devolução e devolverei
todos os filmes. Então você pode ver que o filme foi adicionado
à lista de filmes. Então, retorne os resultados. Ok. Não esqueça o ponto e vírgula
no final da linha. E vamos começar. Então, agora eu tenho três
endpoints para obter. Uma postagem e o pós-teste,
aquele que acabamos de criar. Eu posso abri-lo. Eu posso dizer que experimente. E o corpo da solicitação é
basicamente adjacente. Bem, os IDs geralmente são
criados sozinhos. No meu caso, isso não acontece. Então, adicionarei meu próprio ID
e usarei o ICD-9. O título é The Muppets
e a classificação é cinco. É isso. Isso é o que será
publicado na minha API. Eu executo. E
o código é 200, que são os resultados, mas tudo bem. E no final está a CID-9, a classificação dos Muppets em cinco. Então, agora eu publiquei
dados na API. Se eu retornasse ao endpoint de filmes
da API, mas para os
métodos de solicitações GET, eu executo esse. Vou ver novamente os Muppets porque não precisei
desligar minha API. Então, ainda está na memória
na lista quando eu desligo a API e eles começaram a
reiniciar o ICD-9, os Muppets desaparecerão.
10. 10. DELETE de mapas: Agora criamos três
terminais para um gás, peguem minha identidade e me vangloriem. O próximo momento
será a exclusão. Este enviará
uma solicitação de exclusão para
a API para que a API saiba que
algo será excluído. A exclusão do mapa, que é o mapeamento do
ponto final a ser excluído, é bastante semelhante
à anterior. Vou criar um mapa
do aplicativo, excluir. E o ponto final
será o mesmo da postagem e
do primeiro GET que criamos. E por trás disso, criarei
o perímetro para ID e farei com
que
ele seja um número inteiro igual ao portão por ID. Não há conflito entre esses dois
pontos finais porque eles são separados pelos métodos de solicitação de obtenção e
exclusão. Portanto, se eu enviar um método de
solicitação GET com um id no ponto final, receberei e verei o
filme com um determinado ID. Se eu usar o mesmo URL ou endpoints e enviá-los com um
método de solicitação de exclusão para a API, esse filme específico
será excluído. adicionarei o ID na lista de
parâmetros. Então eu posso usá-lo no meu corpo. E isso é basicamente de conhecimento
comum. Se você estiver trabalhando
com C-Sharp, filme, remova filmes, selecione
e encontre o ID. E é isso. Essa é forma
normal de excluir
um item por meio de uma API. Você não devolve nada. O cliente receberá
200 meninas, o que é bom ou 204 ou erros como 400, 500. Isso é tudo que você precisa
saber do lado do cliente. Mas, no nosso caso, queremos
ver se isso realmente funciona. Então, vou devolver
os resultados. Ok. Filmes. Tudo bem. É isso. Vamos testá-lo. Vou iniciar a API. O navegador padrão
está abrindo novamente. E agora você verá
os endpoints para obter, obter a postagem e excluir. Para conseguir, vou expandir os
leads, vou experimentar. E vamos excluir o
filme com o ID dois. Não tenho ideia de que filme é
esse, mas tudo bem, executa. E nesse caso, vejo que o primeiro
é Shrek com id um, e o segundo é
jaws com ID três, e o ID dois foi excluído. É assim que eu excluo o trabalho.
11. 11. Mapa: O último mapeamento que vamos
criar é a atualização. Ou melhor, o pé
está sendo usado para indicar que você deseja alterar
um objeto ou valor existente. A saída é, na verdade, a
mesma de se gabar, exceto que você
altera meu mapa de pôster. Então, nesse caso,
mapeie os dois pontos finais. Apenas filmes da API e eu
adicionarei o filme
na lista de parâmetros. Se quiser atualizar
um objeto existente, você precisa saber
onde encontrá-lo. Então, eu estou assumindo que a identidade
foi preenchida do filme. Nesse caso, preciso obter o objeto existente
da lista. Encontrado. O
filme é o ID de ponto único do filme. E agora eu posso alterar
o conteúdo
do arquivo em movimento. Então, por exemplo a classificação de
movimento é igual à classificação do filme que
está sendo exibida na API. E é isso. Normalmente, você
tem o Entity Framework para
lidar com as mudanças e a equipe, mas neste caso, Justin list, agora
posso dizer que retorna os resultados. Ok, filmes. Tudo bem, e vamos começar. Vamos ver se funciona. Eu ouço minhas botas
e expandi uma. Experimente. Vamos mudar
o título do segundo filme. Posso deixar um vazio porque não
estou atualizando isso. E a classificação está definida como cinco. Vamos executá-lo. Devolvendo todos os
filmes. E aqui vamos nós. Id2 é o título, inception. Eu configurei isso para
um aleatório e agora é cinco. E isso conclui
o pedido de atualização.
12. 12. Adicionando a injeção de dependência: Então, agora discutimos as necessidades básicas da
API no dotnet six. Precisamos falar sobre
a configuração geral e como podemos criar
endpoints por meio de mapeamentos. próximo item da lista é a injeção de
dependência, algo que nós, como desenvolvedores,
usamos muito em nosso código. E uma API amino também
aceita o padrão
de injeção de dependência. E como podemos fazer isso é quase o mesmo que no dotnet. Ótimo. Só não faça isso em uma startup porque
ela não existe. Agora temos que
configurá-lo no program.cs. Então, primeiro de tudo, fiz algumas alterações no meu aplicativo. Vamos examinar isso
primeiro antes de
explicar como você pode usar a injeção de
dependência. Então, este é meu aplicativo e eu crio uma nova lógica de pasta. E dentro da pasta
há dois arquivos, dossiê
do filme e o ponto da superfície
do filme. Então aí está o
filme que diz sim. Na verdade, filme de objeto que estava anteriormente
no program.cs, mas eu o mudei para este arquivo. E os servidores de filmes
são uma classe que cuida de tudo para filmes. Quando eu abri isso,
há uma lista privada de filmes que contém os mesmos
filmes e o program.cs. E existem alguns
métodos nesse caso:
excluir, obter tudo, obter
por ID e inserir. Eu removi a atualização porque só quero
mantê-la curta e simples. O program.cs
foi limpo. Aqui eu inicializo o
serviço de filmes em uma variável. Vamos renomear isso para propósitos
óbvios. renomeei para
serviço de filmes quando era pequeno. E mudei todos os componentes dos terminais com
o serviço de filmes em vez de uma lista de filmes porque isso não está mais aqui. Então, removi a
classe Movie e a lista de filmes desse arquivo e
os movi para a lógica da pasta. Ok, Cool. Para criar a injeção de penitência, precisamos de uma interface. Nesse caso, quero criar uma interface
do serviço de filmes. Há menos métodos públicos que precisam estar na
interface. Primeiro, vou criar uma nova interface
na lógica do arquivo e chamá-la de serviço de filmes. E vou apenas copiar, excluir e, pelo
menos, mover. E depois mova-o. Boa, má ideia e inserções. Tudo bem, e esses são vazios. Tudo bem? Eles têm interface. Agora vou conectar a interface com
a classe Movie Service.
E eles o adicionaram. Então, agora eu tenho uma
interface conectada à classe de serviço de filmes. Volto ao program.cs e vou começar a
procurar o serviço builder dot, especialmente porque é aí que configuramos nossa injeção de
dependência. Então, o que eu costumo
fazer é procurar o anúncio
e, abaixo disso, digitar o escopo
dos serviços de preenchimento. Tudo bem, mova o serviço e conecte-o à classe de serviço de
filmes. É isso. Agora configuramos nossa injeção de dependência
para o serviço de filmes. Mas como vamos
usá-lo em nossos endpoints? Basicamente, você o coloca na lista
de parâmetros da função. Vamos começar com
o mais simples, o map.get ou map get rich tem um
endpoint de filmes da API, uma lista de parâmetros vazia e um retorno que também apareceu. Militares, chamem todos, amigão. Serão muito simples
porque vou injetar a interface na lista de
parâmetros do corpo. Então, neste caso,
I Movie Service, darei um nome,
Movie Service. Isso dá um erro. Agora, posso deixar isso da mesma forma porque eles
são individuais. Eu injetei o
serviço iMovie em meu método. Como funciona
com o segundo, que é o intestino médio, e eu posso obter um filme
por ID, muito simples, int id comma i movie
service. E isso funciona. Você pode simplesmente colocar a injeção de penitência atrás
da lista de parâmetros das consultas do ponto final ou de
outras partes da ação. O mesmo vale para o post. Tenho aqui um filme
que está sendo postado por um cliente na API
coma movie service, movie service e delete. O mesmo que o portão por identificação. Já dá a dica, talvez você queira que o
iMovie sirva. Eu quero. E agora está pronto. Posso remover a realização
do serviço de filmes. E ainda funciona se
eu pressionar F5 agora, ele iniciará a API. E você pode ver se realmente
funcionou. Eu ainda vejo todo
o meu endpoint aqui. E vamos tentar
secar, executar. E eu ainda vejo todos os meus filmes. Vamos tentar nos gabar, experimentar. Eu tenho nove Muppets, e
a classificação é cinco. Executa. Como você pode ver, os Muppets foram
adicionados a essa lista. Obviamente, esse
não é o melhor
exemplo de injeção de dependência
porque estou usando, configurando a injeção de
dependência e usando-a diretamente. Normalmente, está em todo
lugar e tudo bem. Mas como
injeção de dependência, em poucas palavras.
13. 13. Fazendo isso ASYNC: último capítulo deste curso
trata de transformar a API em um coletor com o objetivo de que a API possa lidar com várias solicitações ao
mesmo tempo. E isso torna a API um
pouco mais rápida para tornar suas ações e métodos assíncronos Precisamos mudar
um pouco as metas e é muito fácil. Na verdade, não
dá muito trabalho. A primeira coisa que quero fazer
é acessar a interface e
preparar tudo para cantar. Então, vou adicionar tarefas
a todos os métodos. Nesse caso, a lista de tarefas está se movendo. Estou me mudando. E mude a voz para o crepúsculo. Tudo bem, isso é fácil. Agora vá para a superfície e
você verá que ela quebra porque a implementação
do serviço não é mais a
mesma da interface. Então, vamos mudar isso
também rapidamente. Novamente, isso é
algo que você deve saber antes de
começar este curso, e eu preciso tornar tudo assíncrono,
caso contrário, não funcionará. Então, isso é apenas uma ação de
copiar e colar. Porque esta é uma demonstração sobre como
fazer algo assíncrono. Normalmente, algo dentro do
método deve estar disponível. Bem, esse não é o caso, mas eu faço com que todos os métodos
assíncronos os aguardem na API, que é o objetivo
desta demonstração. Tudo bem, então agora tudo está
preparado para tarefas assíncronas. Eu volto para o program.cs. Aqui você pode ver
que nada mudou. Não há
avisos nem erros. Mas se eu passar o mouse, basta pegar tudo, você
verá que está disponível. Então, eu posso digitar
aqui e esperar. Sobre a dívida não
funciona porque certa forma, ela sempre precisa ser usada dentro de um método assíncrono e esse método ou o
corpo não é assíncrono. Então, para torná-lo assíncrono, basta digitar async aqui
e então ele funciona. Agora vejo que o serviço de filmes dot insert também
está disponível. Então nós fizemos esse também. Portanto, posso tornar tudo
assíncrono apenas adicionando async a todas as expressões lambda
e tornando os métodos de
serviço de filme. Vou esperar. É isso. Agora eu inicio a API
e ela continua a mesma. Não mudou nada. Vamos executar o
get para experimentá-lo,
executa . E eu tenho isso. Também posso fazer isso com
o outro endpoint. Mas acho que você entendeu. É assim que você torna
a API mínima assíncrona.
14. 14. Conclusão: Bem, isso conclui nossa API
mínima em dotnet six. É uma ótima maneira de criar APIs
menores com menos garotas. E ele não se desfez? Eu gosto de menos código. A desvantagem é que, se você
tem uma API muito grande, tem um arquivo grande
com todos os endpoints. Então, o que acontece é que
as pessoas vão
distribuir os diferentes terminais
em arquivos diferentes. E então, basicamente, criar controladores novamente, realmente
não funciona. Acho que sim se você tiver pequenas
APIs e microsserviços, mas não para
projetos maiores, onde você tem uma API muito grande que
lida com muitas solicitações. Obrigado por assistir. Espero que você tenha
aprendido alguma coisa. Se você tiver alguma
dúvida, é só me
avisar nos comentários
ou me mandar uma mensagem. Não se esqueça de me seguir para mais tutoriais
em um futuro próximo. Obrigado e adeus.