Conectando Comandos POST: Um Mergulho Profundo por Tim Corey

Introdução aos Comandos POST

Tim começa revisitando as atualizações da interface da lição anterior, observando que o sistema atualmente só suporta requisições GET. Ele explica que esta lição se concentra em habilitar requisições POST para que os usuários possam enviar dados a um servidor, como saída JSON ou dados de formulário.

Ele enfatiza que separar o código da IU do código da biblioteca é a chave. A IU deve gerenciar elementos como menus suspensos, formulários HTML e campos de entrada, enquanto a biblioteca lida com a criação de requisições HTTP, formatação de conteúdo e envio de dados ao servidor.

Tim também observa que este projeto pode servir como um exemplo de portfólio, mas é importante que os desenvolvedores garantam que seu portfólio seja unicamente deles. Ele referencia seu Dev Pass em timcorey.com como uma maneira de aprofundar o entendimento sobre C# e métodos de requisição HTTP.

Entendendo a Configuração Atual

No Visual Studio, Tim demonstra a configuração atual do projeto. A IU permite selecionar um método de requisição (GET ou POST) e inserir uma URL. Atualmente, clicar em 'Go' executa apenas uma requisição GET, exibindo a resposta em uma janela de resultados.

Um pequeno problema que ele aponta é que todo o texto na janela de resultados é destacado após uma requisição GET, o que não é ideal para exibição de informações. Tim corrige isso colocando o foco no elemento de aba em vez da caixa de texto. Isso evita a seleção automática de texto e melhora a experiência do usuário.

Lendo o Menu Suspenso e Determinando a Ação HTTP

Para implementar comandos POST, Tim primeiramente explica como ler a seleção do menu suspenso para determinar o método de requisição HTTP. Ele cria uma variável para armazenar o método de requisição analisado e usa TryParse para converter o valor da string do menu suspenso em uma ação HTTP.

Se o método selecionado for inválido, o sistema exibe uma mensagem de erro ('Verbo HTTP inválido') e não tenta a requisição. Uma vez validado, o método de requisição pode ser usado para determinar se deve realizar uma requisição GET, POST ou outros métodos HTTP como DELETE ou PATCH.

Preparando o Backend para Manipular Requisições POST

O próximo passo é atualizar a biblioteca para lidar com requisições POST. Tim explica que comandos POST diferem de requisições GET porque geralmente requerem um corpo de requisição para enviar dados ao recurso alvo. Esses dados podem ser JSON, dados binários ou dados de formulário.

Tim enfatiza separar responsabilidades da IU do código da biblioteca. A IU passa o conteúdo do corpo como uma string, e a biblioteca o converte para o tipo de conteúdo HTTP correto para a requisição. Este design garante que operações genéricas como formatação de conteúdo sejam tratadas na biblioteca, não na IU.

Criando uma Sobrecarga para Requisições POST

Tim cria uma sobrecarga para CallApiAsync que aceita três parâmetros:

1. URL – o endereço do recurso alvo

2. Ação – o método de requisição HTTP (GET, POST, etc.)

3. Conteúdo – o corpo da requisição como uma string

Isso permite que os desenvolvedores passem saída JSON, dados de formulário ou outros dados codificados diretamente da IU para a biblioteca. Ao lidar com requisições POST desta forma, a mesma biblioteca também pode suportar métodos HTTP futuros, como PUT, PATCH ou DELETE.

Convertendo Conteúdo de String em Conteúdo HTTP

Tim mostra como converter o conteúdo de string da IU em StringContent, que herda do conteúdo HTTP. Ele define a codificação para UTF8 e o tipo de conteúdo para application/json, que é adequado para enviar dados estruturados a um servidor.

Esta etapa garante que o corpo da requisição esteja devidamente formatado antes de ser enviado. Tim destaca que essa separação de preocupações permite que os desenvolvedores usem comandos POST sem se preocupar com cabeçalhos HTTP, codificação ou conversão de conteúdo na IU.

Atualizando a Interface e Testando Requisições POST

Uma vez que a biblioteca está pronta, Tim atualiza a interface para chamar o novo método sobrecarregado. Ele testa requisições POST usando JSONPlaceholder, formatando manualmente o corpo da requisição:

{
  "title": "Este é o meu título",
  "body": "Este é o meu texto de corpo",
  "userId": 3
}

Tim explica que uma requisição POST envia esses dados para o recurso alvo, e a resposta indica sucesso. Inicialmente, ocorre um erro porque o enum de ação HTTP não inclui POST. Adicionar POST resolve isso, permitindo que o sistema envie comandos POST com sucesso.

Lidando com Requisições POST na Biblioteca

Tim demonstra o manuseio de comandos POST na biblioteca usando uma instrução switch no método de requisição HTTP. Para GET, o sistema usa GetAsync; para POST, usa-se PostAsync com o corpo da requisição formatado.

Testar o comando POST retorna uma resposta com um ID (101 no JSONPlaceholder), confirmando que a requisição funcionou. Tim observa que, embora esta API de teste não armazene dados em um banco de dados, é útil para validar a funcionalidade de requisições POST.

Principais Lições e Trabalhos Futuros

Tim resume a lição:

• O menu suspenso agora suporta métodos GET e POST.

• A IU passa o corpo da requisição para a biblioteca.

• A biblioteca converte a string em conteúdo HTTP e executa a requisição HTTP correta.

• Comandos POST retornam respostas válidas, que podem ser exibidas na janela de resultados.

Ele encoraja os aprendizes a implementar comandos PUT, PATCH e DELETE em lições futuras, destacando que a estrutura existente torna a adição de novos métodos HTTP direta.

Tim também aconselha a evitar engenharia excessiva ou adição de código não utilizado, o que poderia resultar em funções desconectadas ou elementos órfãos.

Conclusão

O vídeo de Tim Corey fornece uma abordagem clara e prática para comandos POST em um projeto Clone do Postman. Ao separar responsabilidades da IU do código da biblioteca, convertendo dados de string em conteúdo HTTP e lidando com respostas de forma eficaz, os desenvolvedores ganham experiência prática com métodos de requisição HTTP.

Esta lição não só demonstra o envio de dados para um servidor, mas também estabelece a base para lidar com outros métodos HTTP, cabeçalhos e requisições mais complexas, tornando-se um forte exemplo prático para aprender interações HTTP em C#.