Performance
Em performance e escala, o que se espera não é micro-otimização: é saber medir, achar o gargalo de verdade e não criar os problemas clássicos que derrubam API sob carga.
Meça antes de otimizar
Palpite de gargalo erra mais do que acerta. A ordem que sigo:
- Métricas de produção: latência p95 e p99 por endpoint, não a média. Ver Observabilidade.
- Tracing da requisição lenta: quase sempre o tempo está no banco ou numa chamada externa, não no C#.
- Profiling quando o tempo está mesmo no processo:
dotnet-trace,dotnet-counters, o profiler do Visual Studio ou do Rider. - Benchmark para comparar duas implementações: BenchmarkDotNet, nunca
Stopwatchnum loop.
[MemoryDiagnoser]
public class SerializacaoBenchmark
{
private readonly Pedido _pedido = PedidoDeExemplo.Criar();
[Benchmark(Baseline = true)]
public string Newtonsoft() => JsonConvert.SerializeObject(_pedido);
[Benchmark]
public string SystemTextJson() => JsonSerializer.Serialize(_pedido);
}
async/await sem armadilhas
async não deixa nada mais rápido; libera a thread enquanto espera I/O, e é isso que deixa o servidor atender mais requisições ao mesmo tempo.
- Nunca bloqueie:
.Result,.Wait()eGetAwaiter().GetResult()seguram a thread. Sob carga, o pool esgota e a API para de responder (thread pool starvation), mesmo com CPU sobrando. - Repasse o
CancellationTokenaté a última chamada. - Paralelize I/O independente:
// Sequencial: 300 ms + 200 ms
var cliente = await clientes.BuscarAsync(id, ct);
var limite = await credito.ConsultarAsync(id, ct);
// Em paralelo: ~300 ms
var clienteTask = clientes.BuscarAsync(id, ct);
var limiteTask = credito.ConsultarAsync(id, ct);
await Task.WhenAll(clienteTask, limiteTask);
Cuidado: o mesmo DbContext não aceita duas consultas ao mesmo tempo. Paralelismo vale para chamadas a serviços diferentes.
- CPU pesada não é async: cálculo longo bloqueia do mesmo jeito. Leve para um worker ou uma fila.
Os gargalos mais comuns em API .NET
- Consulta sem índice ou N+1. Ver EF Core e SQL.
- Carregar demais: entidade inteira para mostrar três campos, lista sem paginação.
- Chamada externa sem timeout: uma dependência lenta prende todas as threads. Ver Integração com APIs externas.
new HttpClient()por requisição: esgota sockets. UseIHttpClientFactory.- Log demais em produção: nível Debug serializando objetos grandes em cada requisição.
- Falta de cache em dado lido mil vezes e alterado uma. Ver Cache.
Alocação e GC
Em API comum, alocação raramente é o gargalo. Em ponto quente (parsing, serialização, alto volume), vale:
StringBuilderpara concatenar em loop.Span<T>eReadOnlySpan<char>para fatiar sem copiar.ArrayPool<T>.Sharedpara buffers temporários grandes.- Evitar LINQ em laço muito quente; um
forsimples aloca menos. [MemoryDiagnoser]no BenchmarkDotNet mostra quanto cada versão aloca.
Resposta HTTP
- Compressão:
AddResponseCompression(), se o proxy na frente já não comprime. - Output cache: resposta inteira em cache no servidor, nativo desde o .NET 7.
builder.Services.AddOutputCache(o => o.AddPolicy("catalogo", p => p.Expire(TimeSpan.FromSeconds(30))));
app.UseOutputCache();
app.MapGet("/produtos", ListarProdutos).CacheOutput("catalogo");
Teste de carga
Antes de uma data de pico, não depois. k6 (scripts em JavaScript) e NBomber (em C#) são os mais usados. Defina a meta antes: “500 requisições por segundo com p95 abaixo de 300 ms”. Teste de carga sem meta é só um gráfico bonito.
O que perguntam em entrevista
- Diferença entre concorrência e paralelismo, e o que o
asyncresolve. - O que é thread pool starvation e como acontece.
- Como você investiga um endpoint que ficou lento em produção.
- Quando usar
Task.WhenAll. - Por que não instanciar
HttpClienta cada requisição.