O HttpClient é uma classe fundamental para realizar requisições HTTP em aplicações .NET. Ela permite que você envie e receba dados da web, seja para acessar uma API, baixar arquivos ou se comunicar com um servidor.
O que é o HttpClient?
O HttpClient é uma classe que faz parte do namespace “System.Net.Http” e é amplamente usada para enviar requisições HTTP e receber respostas de um recurso identificado por um URI (Uniform Resource Identifier). Seu uso é bastante simples, mas envolve várias boas práticas que devem ser seguidas para garantir eficiência e evitar vazamentos de recursos.
JsonPlaceholder
Para os nossos exemplos práticos, vamos utilizar o serviço “jsonplaceholder” para realizar nossas requisições. O “jsonplaceholder” é uma API gratuita que simula um servidor REST, permitindo que você pratique suas requisições HTTP sem precisar configurar um backend real. É uma ótima ferramenta para testar e aprender como funcionam as operações com HttpClient. Você pode utilizar essa API para praticar as requisições que vamos ver ao longo do artigo.
Criando uma instância de HttpClient
Antes de realizar qualquer requisição HTTP, é necessário criar uma instância do HttpClient:
HttpClient client = new HttpClient();
É importante destacar que o HttpClient é projetado para ser reutilizado, e criar múltiplas instâncias dele pode levar ao esgotamento de recursos do sistema, como conexões de soquete. Por isso, o ideal é criar uma instância única e reutilizá-la ao longo da aplicação.
Realizando uma requisição GET
Uma das requisições mais comuns em qualquer aplicação web é a requisição GET, usada para obter dados de um servidor. Vamos começar com um exemplo simples de como realizar uma requisição GET:
HttpResponseMessage response = await client.GetAsync("https://jsonplaceholder.typicode.com/posts");
Neste exemplo, o método “GetAsync” é chamado com o URI do recurso que desejamos acessar. O resultado dessa operação é um “HttpResponseMessage”, que contém informações sobre a resposta do servidor, incluindo o status da requisição (se foi bem-sucedida, redirecionada, ou se ocorreu algum erro) e o conteúdo da resposta.
Verificando o status da resposta
Após realizar a requisição, é crucial verificar se ela foi bem-sucedida antes de prosseguir com a leitura do conteúdo:
if (response.IsSuccessStatusCode)
{
// A requisição foi bem-sucedida
}
else
{
// Lidar com erros
}
Lendo o conteúdo da resposta
O próximo passo é ler o conteúdo da resposta. O “HttpResponseMessage” possui uma propriedade “Content”, que oferece métodos para ler o corpo da resposta de diferentes maneiras, sendo a mais comum convertê-lo para uma string:
string responseBody = await response.Content.ReadAsStringAsync();
Tratamento de erros
É importante tratar possíveis erros durante a leitura do conteúdo, como exceções de rede ou falhas no servidor. Isso pode ser feito usando um bloco try-catch e capturando as exceções do tipo “HttpRequestException”, da seguinte forma:
try
{
string responseBody = await response.Content.ReadAsStringAsync();
// Processar o conteúdo
}
catch (HttpRequestException e)
{
Console.WriteLine("Erro na requisição: " + e.Message);
}
Requisição POST com corpo
A requisição POST é amplamente utilizada para enviar dados a um servidor, seja para criar novos recursos, enviar formulários ou realizar outras operações que requerem o envio de informações no corpo da requisição.
var content = new StringContent("{\"title\":\"Título Post\",\"body\":\"Conteúdo do Post\",\"userId\":1}", Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync("https://jsonplaceholder.typicode.com/posts", content);
Neste exemplo, usamos “StringContent” para criar o conteúdo da requisição. Esse conteúdo é enviado junto com o método “PostAsync”. Note que especificamos o encoding e o tipo de mídia (neste caso, JSON), o que é importante para que o servidor entenda como processar os dados enviados. Após isso, podemos realizar o processamento da resposta assim como ensinado anteriormente.
Trafegando objetos
Nos exemplos anteriores vimos como enviar e receber dados em formato textual (JSON). Porém, é comum que tenhamos em nossa aplicação classes que modelam esses dados a serem trafegados, comumente denominadas DTOs (Data Transfer Objects). Utilizando o namespace “System.Net.Http.Json” temos acesso a métodos que nos permitem enviar e receber dados de forma tipada, sem que seja necessário fazer o processo de serialização e deserialização de forma explícita.
Para seguirmos com o uso da API JsonPlaceholder, vamos criar uma classe “Post” que modela esses objetos que desejamos enviar e receber:
public class Post
{
public long UserId { get; set; }
public long Id { get; set; }
public string Title { get; set; }
public string Body { get; set; }
}
Agora, vamos repetir a operação Get da mesma forma feita anteriormente, porém vamos ler o resultado diretamente na forma de uma coleção de “Post”. Para isso, usamos o método “ReadFromJsonAsync”, para o qual especificamos o formato de retorno:
var posts = await response.Content.ReadFromJsonAsync<IEnumerable<Post>>();
Feito isso, a variável “posts” receberá um “IEnumerable” de “Post” contendo os dados retornados.
Para enviar os dados utilizando essa mesma classe “Post” o processo também é semelhante ao que vimos anteriormente. Agora devemos utilizar o método PostAsJsonAsync e passar o objeto como parâmetro:
var post = new Post
{
UserId = 1,
Id = 1,
Title = "Requisições HTTP com HttpClient",
Body = "Aprenda a usar o HttpClient"
};
HttpResponseMessage response = await client.PostAsJsonAsync("https://jsonplaceholder.typicode.com/posts", post);
Caso você esteja consumindo uma API externa, é fundamental consultar a documentação para conhecer o formato correto em que os dados devem ser enviados e recebidos. Dessa forma você conseguirá modelar suas classes corretamente para que sejam serializadas e deserializadas de forma automática.
Enviando headers personalizados
Em requisições HTTP, é comum precisar enviar headers específicos, como um token de autenticação para identificar quem está fazendo a solicitação e verificar se possui permissão de acesso. Para isso, usamos headers personalizados, que podem ser facilmente adicionados ao HttpClient.
client.DefaultRequestHeaders.Add("Authorization", "Bearer SEU-TOKEN-AQUI");
Essa configuração garante que todas as requisições feitas pela instância do HttpClient incluam o token, permitindo ao servidor identificar e autorizar o acesso conforme necessário.
Posteriormente, para acessar os valores dos cabeçalhos, existem propriedades em “DefaultRequestHeaders” para os principais cabeçalhos. Por exemplo:
var token = client.DefaultRequestHeaders.Authorization?.Parameter;
Caso você esteja usando uma mesma instância do HttpClient para realizar diferentes requisições, pode ser necessário limpar os headers de requisições anteriores antes de definir os novos. Para isso, basta usar o método Clear, da seguinte forma:
client.DefaultRequestHeaders.Clear();
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
O HttpClient é uma ferramenta bastante versátil para qualquer aplicação .NET que tenha a necessidade de se comunicar com a web. Ao seguir as boas práticas e entender o seu funcionamento, você pode fazer com que a sua aplicação seja eficiente e confiável ao realizar requisições HTTP. Aproveite os recursos que o HttpClient oferece para construir aplicações robustas, mantendo sempre a segurança e a performance em mente.