DEV Community: Guilherme Govaski

Content-Type e as diferenças entre x-www-form-urlencoded e JSON

Guilherme Govaski — Fri, 14 Mar 2025 14:35:47 +0000

Ao trabalhar com APIs e comunicação entre cliente e servidor, existe um header muito importante para comunicação entre as duas partes, este é o Content-Type. O Content-Type é usado para informar ao receptor o tipo de dados que estão sendo trafegados na rede. Os dois formatos mais comuns para o envio de dados simples em uma requisição HTTP são os: application/json e application/x-www-form-urlencoded.

Características

Content-Type: application/json

É um formato baseado em JSON (JavaScript Object Notation), muito utilizado para a comunicação e a troca de dados entre APIs. O JSON surgiu como uma alternativa ao tradicional XML. O JSON segue a sintaxe do JavaScript, tornando possível o envio de estruturas complexas como objetos e arrays, tornando mais fácil a legibilidade.

Exemplo de requisição HTTP usando Content-Type: application/json

POST /api/usuarios HTTP/1.1
Host: exemplo.com
Content-Type: application/json

{
  "id": 1253
  "nome": "João Silva",
  "email": "joao@example.com",
  "idade": 30,
  "endereço": {
    "rua": "Barão da Cidade",
    "Número": 782
    "bairro": "Mimoso Jacarandá",
    "cidade": "São Paulo",
    "Estado": "São Paulo"
  },
  "numeros_de_telefone": [
    { "id": 1432, "DDD": 41, "numero": 981843617 },
    { "id": 1433, "DDD": 27, "numero": 974272074 }
  ]
}

Content-Type: application/x-wwww-form-urlencoded

É o formato padrão para envio de dados através de formulários HTML. Os dados são codificados em estrutura de URL como chaves e valores, exemplo: "nome=Jonas&idade=28". Quando precisamos utilizar objetos complexos de dados, a legibilidade do conteúdo fica um pouco prejudicada.

Exemplo de requisição HTTP usando Content-Type: application/x-wwww-form-urlencoded

POST /api/usuarios HTTP/1.1
Host: exemplo.com
Content-Type: application/x-wwww-form-urlencoded

id=1253&nome=João Silva&email=joao@example.com&idade=30&endereço.rua=Barão da Cidade&endereço.Número=782&endereço.bairro=Mimoso Jacarandá&endereço.cidade=São Paulo&endereço.Estado=São Paulo&numeros_de_telefone[0].id=1432&numeros_de_telefone[0].DDD=41&numeros_de_telefone[0].numero=981843617&numeros_de_telefone[1].id=1433&numeros_de_telefone[1].DDD=27&numeros_de_telefone[1].numero=974272074

Vantagens de um relacionado ao outro

aplication/json

Melhor suporte a estruturas complexas.
Facilita a manipulação e a serialização de objetos em diversas linguagens de programação.
Padrão amplamente utilizado em APIs RESTful.

application/x-www-form-urlencoded

Simples e leve para pequenos conjuntos de dados.
Nativo para formulários HTML sem necessidade de JavaScript.
Bem suportado em servidores web e frameworks.

Resumo

O header Content-Type é essencial na comunicação entre cliente e servidor, pois informa o tipo de dados trafegados. Os formatos mais comuns são application/json e application/x-www-form-urlencoded. O application/json é ideal para APIs RESTful, oferecendo suporte a estruturas complexas e facilitando a leitura e manipulação dos dados. Já o application/x-www-form-urlencoded é amplamente utilizado em formulários HTML, sendo mais leve e simples para pequenos conjuntos de dados. A escolha entre os dois depende do contexto e da necessidade da aplicação.

Co-autor: @afariaflp
Link: https://dev.to/afariaflp/content-type-e-as-diferencas-entre-x-www-form-urlencoded-e-json-537f

Default interface methods no C#

Guilherme Govaski — Mon, 05 Aug 2024 04:35:58 +0000

Interfaces com métodos padrões se trata da capacidade de adicionar assinaturas de métodos em uma interface com um corpo definido (com um comportamento padrão ou mesmo um corpo vazio) fazendo com que as classes que implementam essa interface não tenham a obrigatoriedade de implementar esse novo método adicionado na interface.

Imagine o seguinte cenário genérico:

Temos uma interface IAnimal que contém métodos comuns que simulam comportamentos comuns de todos os animais.

public interface IAnimal 
{
  void MakeSound();
  void Eat();
  void Sleep();
}

Temos 3 classes que representam animais terrestres e que implementam a interface IAnimal.

public class Dog : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }
}

public class Cat : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {
    }
}

public class Rabbit : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }
}

E também temos uma outra classe de um animal voador, que também implementa a interface IAnimal.

public class Bird : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }

    public void Fly() 
    {    
    }
}

Agora, digamos que precisamos adicionar um novo método "Run" na nossa interface IAnimal, porém não queremos que ela tenha uma implementação concreta na classe do animal voador "Bird", somente nas classes dos animais terrestres.

Podemos fazer dessa forma, adicionando um corpo ao método dentro da interface:

public interface IAnimal 
{
  void MakeSound();
  void Eat();
  void Sleep();
  public void Run() 
  {    
  }
}

Agora nossas classes que representam animais terrestres, podem implementar esse novo método.

public class Dog : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }

    public void Run() 
    {
        Console.WriteLine("Running...");
    }
}

public class Cat : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {
    }

    public void Run() 
    {
        Console.WriteLine("Running...");
    }
}

public class Rabbit : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }

    public void Run() 
    {
        Console.WriteLine("Running...");
    }
}

Enquanto nossa classe que representa um animal voador "Bird" não precisará fazer essa implementação, então ela permanece assim:

public class Bird : IAnimal
{
    public void Eat()
    {        
    }

    public void MakeSound()
    {        
    }

    public void Sleep()
    {        
    }

    public void Fly() 
    {    
    }
}

Como você viu, pode ser muito útil utilizar esse recurso, porém fique atento para acabar não poluindo a interface ou mesmo quebrando o princípio SRP (Single Responsability Principle) ao adicionar métodos demasiadamente ou métodos que não fazem parte do contexto da interface.

5 dicas para montar consultas mais performáticas com o LINQ

Guilherme Govaski — Thu, 07 Mar 2024 00:36:11 +0000

Quando se trata de consultas ao banco de dados, é sempre necessário atentar a performance, pois consultas lentas podem acarretar uma pior experiência para o usuário, principalmente em cenários mais sensíveis onde a performance se torna crítica. Aqui estão algumas dicas para melhor uso do LINQ para fazer consultas em bancos de dados.

1. Uso do AsNoTracking

Você pode usar o método AsNoTracking do LINQ para que a entidade que você está consultando não seja rastreada e nem mantida em cache no DbContext ou ObjectContext, eliminando carga extra do Entity Framework para gerenciar o estado daquela entidade em memória. Exemplo:

var user = await dbContext.Users
                   .FirstOrDefault(user => user.Id == Id)
                   .AsNoTracking();

2. Filtrar somente o que será usado

Você deve filtrar somente os dados que você realmente irá usar, diminuindo a complexidade da consulta e evitando transferência de dados desnecessários entre o banco de dados e sua aplicação. Com o LINQ, você pode usar o método Select e instanciar um objeto anônimo para filtrar somente os dados desejados. Exemplo:

var users = await dbContext.Users
                    .Where(user => user. Age >= 18)
                    .Select(u => new { u.Name, u.Email, u.Age })
                    .ToListAsync();

3. Paginação dos dados

Quando uma consulta ao banco retorna MUITOS dados, é interessante limitar a quantidade de registros, por questões de performance. Você pode utilizar a abordagem da paginação, trazendo uma quantidade de dados específica durante uma consulta. Exemplo:

public async Task<List<LoginsAuditViewModel>> GetAllLoginsAuditAsync(int page, int pageSize) 
  {
    var currentPage = (page - 1) * pageSize;

    var loginsAudit = await dbContext.LoginsAudit
                              .Skip(currentPage)
                              .Take(pageSize);

    return loginsAudit;
  }

4. TryGetNonEnumeratedCount para obter o número total de elementos

O método TryGetNonEnumeratedCount do LINQ tenta buscar o número total de elementos de uma coleção sem necessariamente iterar individualmente sobre cada elemento para determinar isso, o que pode ser útil em cenários que você deseja saber o número total de elementos e ao mesmo sabe que possui muitos elementos. Exemplo:

dbContext.Users.TryGetNonEnumeratedCount(out var count);

5. Use o IQueryable para consultas complexas

Quando você tem uma consulta que faz muitos filtros e possui condicionais para filtrar os dados, você pode transformar a sua consulta em um IQueryable, que será executado diretamente no banco de dados com todos os filtros em uma só consulta. Isso pode ser útil para evitar transferência de dados desnecessários do banco de dados e para evitar o uso mais intenso de processamento para aplicar os filtros em memória. Exemplo:

if (condition1)
{
    queryable = queryable.Where(...);
}

if (condition2)
{
    queryable = queryable.Where(...);
}

if (condition3)
{
    queryable = queryable.Where(...);
}