C# e .NET: o que há de novo para desenvolvedores web

O ecossistema .NET nunca esteve tão vibrante para desenvolvedores web. Com o lançamento do .NET 8 (LTS) em novembro de 2023 e a subsequente chegada do .NET 9 (Current) em novembro de 2024, a Microsoft consolidou uma plataforma unificada, performática e moderna. Este artigo explora as principais novidades que impactam diretamente o dia a dia de quem constrói aplicações web com C# e .NET, desde a renderização interativa com Blazor até APIs enxutas com Minimal APIs, passando por melhorias significativas em desempenho, segurança e produtividade.

1. O Ecossistema .NET 8 e 9: Uma Nova Era para Web

O .NET 8 é uma versão LTS (Long-Term Support) com três anos de suporte, ideal para aplicações corporativas que exigem estabilidade. Já o .NET 9, como versão Current, tem suporte de 18 meses e traz inovações mais rápidas para quem busca estar na vanguarda. A principal mudança é a unificação definitiva do ASP.NET Core, que agora atende igualmente bem a aplicações web tradicionais, APIs REST e Blazor.

O destaque técnico é a compilação AOT (Ahead-of-Time). Com ela, sua aplicação web pode ser publicada como um binário nativo, reduzindo drasticamente o tempo de inicialização e o consumo de memória. Veja como publicar uma API com AOT:

dotnet publish -c Release -r win-x64 --self-contained -p:PublishAot=true

O resultado é uma aplicação que inicia em milissegundos, ideal para ambientes serverless e containers.

2. Blazor: Renderização Interativa sem JavaScript (ou com ele)

O Blazor evoluiu para oferecer três modelos de hospedagem, agora unificados sob o conceito de "Blazor United" ou "Auto". O desenvolvedor pode escolher entre:

  • Blazor WebAssembly: execução no navegador via WebAssembly, ideal para aplicações offline ou que exigem processamento no cliente.
  • Blazor Server: renderização no servidor com conexão SignalR, excelente para intranets e aplicações com baixa latência de rede.
  • Blazor Auto (United): combina os dois anteriores, começando com Server para carregamento instantâneo e migrando para WebAssembly em segundo plano.

A reutilização de componentes é um dos pontos fortes. Um componente Razor pode ser usado em qualquer modelo de hospedagem sem alterações. A interoperabilidade com JavaScript também foi simplificada:

@code {
    [JSInvokable]
    public static Task<string> ObterDadosDoServidor()
    {
        return Task.FromResult("Dados processados no servidor!");
    }
}

Para chamar esse método do JavaScript, basta usar DotNet.invokeMethodAsync('App', 'ObterDadosDoServidor').

3. Minimal APIs vs Controllers: Novas Abordagens para APIs REST

As Minimal APIs, introduzidas no .NET 6, amadureceram no .NET 8 e 9. Elas oferecem uma sintaxe extremamente enxuta, ideal para microsserviços e endpoints simples. Veja um exemplo completo de uma API de tarefas:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var tarefas = new List<string>();

app.MapGet("/tarefas", () => tarefas);

app.MapPost("/tarefas", (string descricao) =>
{
    tarefas.Add(descricao);
    return Results.Created($"/tarefas/{tarefas.Count - 1}", descricao);
});

app.MapDelete("/tarefas/{id}", (int id) =>
{
    if (id < 0 || id >= tarefas.Count)
        return Results.NotFound();
    tarefas.RemoveAt(id);
    return Results.NoContent();
});

app.Run();

Para APIs mais complexas, com validação e versionamento, os Controllers tradicionais ainda são recomendados. O suporte nativo a OpenAPI (Swagger) funciona perfeitamente em ambas as abordagens.

4. Entity Framework Core 8/9: ORM Moderno e Performático

O Entity Framework Core 8/9 trouxe melhorias significativas em consultas complexas e performance. Agora é possível executar operações em lote com mais eficiência:

using var context = new AppDbContext();
await context.Produtos
    .Where(p => p.Estoque == 0)
    .ExecuteUpdateAsync(setters => setters.SetProperty(p => p.Status, "Indisponivel"));

Essa consulta gera uma única instrução SQL UPDATE, sem carregar entidades na memória. O suporte a tipos de propriedade (owned types) e mapeamento JSON foi expandido, permitindo modelar dados semiestruturados diretamente no banco relacional.

Para tuning de performance, o pooling de contexto e os interceptadores permitem logar ou modificar consultas SQL em tempo real:

optionsBuilder.AddInterceptors(new QueryLoggingInterceptor());

5. Segurança e Autenticação: Identity, JWT e OAuth2

O ASP.NET Core Identity continua sendo a solução padrão para gerenciamento de usuários. No .NET 8/9, a configuração de autenticação JWT foi simplificada:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
        };
    });

A proteção contra ataques web foi reforçada com rate limiting nativo, configurável por política:

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("Api", opt =>
    {
        opt.PermitLimit = 10;
        opt.Window = TimeSpan.FromSeconds(1);
    });
});

6. Ferramentas e Produtividade para Desenvolvedores Web

O Hot Reload permite editar código C# e Razor em tempo real, sem reiniciar a aplicação. Basta executar dotnet watch e as alterações são refletidas instantaneamente no navegador.

O .NET Aspire é uma novidade para orquestração de microsserviços. Ele oferece dashboards de observabilidade, gerenciamento de dependências (Redis, PostgreSQL, RabbitMQ) e provisionamento automático de recursos na nuvem.

O Visual Studio 2022 e a CLI do .NET continuam evoluindo com scaffolding aprimorado para Blazor components e Minimal APIs.

7. Deploy e Cloud: .NET na Nuvem e em Containers

A publicação com AOT gera binários nativos que podem ser empacotados em imagens Docker extremamente leves. Um Dockerfile típico para uma API AOT:

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY ["Api.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish -p:PublishAot=true

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["./Api"]

O suporte nativo a Azure, AWS e Google Cloud permite deploy serverless com Azure Functions, AWS Lambda ou Cloud Run. O monitoramento com OpenTelemetry e Application Insights fornece métricas detalhadas de performance e erros.

Conclusão

O C# e .NET oferecem um ecossistema maduro e inovador para desenvolvimento web. Com Blazor para interfaces interativas, Minimal APIs para serviços enxutos, Entity Framework Core para acesso a dados eficiente e ferramentas como Hot Reload e .NET Aspire, a produtividade do desenvolvedor nunca foi tão alta. A compilação AOT e o suporte nativo a containers tornam o deploy em cloud mais rápido e econômico. Se você ainda não experimentou as novidades do .NET 8 ou 9, este é o momento ideal para migrar ou iniciar novos projetos.

Referências