Introducción

Todo desarrollador .NET que trabaja con aplicaciones medianas o grandes ya se ha topado con al menos uno de estos escenarios: una rutina nocturna que necesita grabar 50 mil pedidos en la base de datos, una consulta de informe que trae 300 mil registros de una sola vez y congela la aplicación, o una API que tarda 8 segundos en responder porque EF Core está ejecutando 10 mil INSERT individuales en secuencia.

SQL Server y Oracle son bases de datos robustas y maduras, pero ninguna de las dos fue diseñada para recibir miles de escrituras en ráfaga, ni para devolver cientos de miles de filas de una sola vez sin costo. En la mayoría de los casos, el problema no es la base de datos — es la forma en que la aplicación C# interactúa con ella.

En este artículo exploro las dos caras del cuello de botella: escritura masiva y lectura de grandes volúmenes. Para cada una, verás la causa raíz, las particularidades de SQL Server y Oracle con EF Core 8.0+, y la solución práctica — mensajería para escrituras y paginación eficiente para lecturas. Todo el código está listo para producción y es compatible con .NET 8/9.

Requisitos previos: Conocimientos básicos de C# y EF Core. Recomiendo leer el artículo sobre programación asíncrona con C# antes de continuar.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.


El Cuello de Botella de la Escritura: Por Qué Grabar Miles de Registros Duele

El Costo Real de Cada INSERT

Cuando guardas una lista de entidades con EF Core de la forma más común, ocurre algo así:

1
2
3
4
5
6
// ❌ Enfoque ingenuo — InsertOne a la vez
foreach (var pedido in listaDe50MilPedidos)
{
    await context.Pedidos.AddAsync(pedido);
    await context.SaveChangesAsync(); // PROBLEMA: ¡1 roundtrip por registro!
}

Cada SaveChangesAsync() dentro del bucle representa:

  1. Una transacción abierta → confirmada → cerrada en la base de datos
  2. Un roundtrip de red (latencia de 1–5ms por llamada)
  3. El log de la base de datos siendo escrito en cada operación
  4. Locks de fila asignados y liberados 50 mil veces

Para 50.000 pedidos con 2ms de latencia por roundtrip, son 100 segundos de procesamiento de I/O puro. Y ese es el mejor escenario, sin contención.

Particularidades: SQL Server vs Oracle

Aunque la solución es parecida en ambas bases de datos, hay diferencias importantes:

AspectoSQL ServerOracle
Bulk insert nativoBULK INSERT / SqlBulkCopyODP.NET BulkCopy / INSERT ALL
Tamaño máximo de lote por defecto1.000 filas por INSERTDepende de ArrayBindCount
Sequences / IdentityIDENTITY o SEQUENCESolo SEQUENCE (obligatorio)
Rollback de bulkPuede ser mínimamente registradoSiempre registrado (redo log)
Provider EF CoreMicrosoft.EntityFrameworkCore.SqlServerOracle.EntityFrameworkCore

En Oracle, un detalle crítico es que el provider oficial (Oracle.EntityFrameworkCore 8.x) exige configurar la generación de claves vía SEQUENCE + TRIGGER (o GENERATED ALWAYS AS IDENTITY en Oracle 12c+). Ignorar esto en escrituras masivas generará N llamadas extra a la base de datos solo para obtener los IDs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Oracle: configuración correcta en OnModelCreating
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Pedido>(entity =>
    {
        entity.HasKey(e => e.Id);

        // Oracle 12c+: identity nativo, evita un roundtrip extra por ID
        entity.Property(e => e.Id)
              .UseIdentityColumn();

        // Alternativa para Oracle 11g/legado
        // entity.Property(e => e.Id)
        //       .HasDefaultValueSql("SEQ_PEDIDOS.NEXTVAL");
    });
}

La Solución Inmediata: SaveChanges por Lotes con EF Core 8

Antes de introducir colas, la primera optimización es sacar SaveChangesAsync() del bucle y usar chunks para no sobrecargar el contexto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// ✅ Mejor: batch por chunk + 1 SaveChanges por lote
public async Task GravarPedidosEmLoteAsync(
    IEnumerable<Pedido> pedidos,
    CancellationToken ct = default)
{
    const int tamanhoLote = 500;

    foreach (var chunk in pedidos.Chunk(tamanhoLote))
    {
        await context.Pedidos.AddRangeAsync(chunk, ct);
        await context.SaveChangesAsync(ct);

        // Limpiar el ChangeTracker para no acumular entidades en memoria
        context.ChangeTracker.Clear();
    }
}

💡 Consejo: El método Chunk() fue introducido en .NET 6. Combinado con ChangeTracker.Clear(), evita que el contexto de EF Core crezca indefinidamente al rastrear decenas de miles de entidades.

ExecuteInsertAsync y BulkInsert en EF Core 8

EF Core 7 trajo ExecuteUpdateAsync y ExecuteDeleteAsync. EF Core 8 mejoró el soporte para operaciones en lote. Para escenarios de altísimo rendimiento, usa la biblioteca EFCore.BulkExtensions:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// ✅ BulkInsert para SQL Server y Oracle (vía EFCore.BulkExtensions)
// dotnet add package EFCore.BulkExtensions
public async Task BulkInsertPedidosAsync(
    List<Pedido> pedidos,
    CancellationToken ct = default)
{
    var bulkConfig = new BulkConfig
    {
        BatchSize = 1000,
        UseTempDB = true,              // SQL Server: tabla temporal para staging
        SetOutputIdentity = true,      // Rellena los IDs generados por la base de datos
        PreserveInsertOrder = true
    };

    await context.BulkInsertAsync(pedidos, bulkConfig, cancellationToken: ct);
}

Con BulkInsert, 50.000 registros que tardaban 100 segundos con SaveChanges individuales se graban en 2–4 segundos en SQL Server, y en 3–6 segundos en Oracle.


Mensajería: La Solución Arquitectónica para Escrituras Masivas

Optimizar el INSERT en sí trata el síntoma, pero no la causa raíz. El verdadero problema es que la aplicación intenta procesar un volumen enorme de forma síncrona, bloqueando el hilo y la request mientras graba. La solución arquitectónica correcta es desacoplar la recepción de la grabación usando una cola de mensajes.

Cómo la Mensajería Resuelve el Problema

En lugar de grabar directamente en la base de datos al recibir los datos, la aplicación:

  1. Publica los registros en una cola (RabbitMQ, Azure Service Bus, etc.) — operación rápida (~1ms por mensaje)
  2. Responde inmediatamente al cliente con 202 Accepted
  3. Un Consumer separado lee la cola en lotes y graba en la base de datos con bulk insert

Arquitectura de mensajería para escritura masiva en la base de datos

Esta separación trae beneficios más allá del rendimiento:

  • Resiliencia: si la base de datos cae temporalmente, los mensajes permanecen en la cola. No hay pérdida de datos.
  • Control de flujo: el consumer puede procesar a la velocidad que la base de datos soporta
  • Backpressure natural: la cola absorbe picos de carga
  • Observabilidad: puedes monitorear el tamaño de la cola y saber exactamente el backlog pendiente

Implementación con RabbitMQ.Client

La biblioteca oficial RabbitMQ.Client es 100% open source (Apache 2.0) y ofrece acceso directo al protocolo AMQP. Combinada con el BackgroundService de .NET, implemento un consumer que acumula mensajes en un lote y graba todo de una vez con BulkInsert.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
// dotnet add package RabbitMQ.Client
// dotnet add package EFCore.BulkExtensions

// --- Mensaje ---
public record PedidoCriadoMessage(
    Guid Id,
    string ClienteId,
    decimal Valor,
    DateTime DataCriacao);

// --- Producer ---
public class PedidoProducer(IConnection connection)
{
    private const string QueueName = "pedidos-queue";

    public async Task PublicarAsync(
        PedidoCriadoMessage mensagem,
        CancellationToken ct = default)
    {
        await using var channel = await connection.CreateChannelAsync(cancellationToken: ct);

        await channel.QueueDeclareAsync(
            queue: QueueName,
            durable: true,
            exclusive: false,
            autoDelete: false,
            cancellationToken: ct);

        var json = JsonSerializer.SerializeToUtf8Bytes(mensagem);
        var props = new BasicProperties { DeliveryMode = DeliveryModes.Persistent };

        await channel.BasicPublishAsync(
            exchange: string.Empty,
            routingKey: QueueName,
            mandatory: false,
            basicProperties: props,
            body: json,
            cancellationToken: ct);
    }
}

// --- Consumer por lotes (BackgroundService) ---
public class PedidoConsumerWorker(
    IConnection connection,
    IServiceScopeFactory scopeFactory,
    ILogger<PedidoConsumerWorker> logger) : BackgroundService
{
    private const string QueueName = "pedidos-queue";
    private const int TamanhoLote = 500;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await using var channel = await connection.CreateChannelAsync(cancellationToken: ct);

        await channel.QueueDeclareAsync(
            queue: QueueName, durable: true,
            exclusive: false, autoDelete: false,
            cancellationToken: ct);

        // Backpressure: limita los mensajes en vuelo para no sobrecargar la memoria
        await channel.BasicQosAsync(
            prefetchSize: 0,
            prefetchCount: TamanhoLote + 100,
            global: false,
            cancellationToken: ct);

        var lote = new List<(ulong Tag, PedidoCriadoMessage Msg)>();

        var consumer = new AsyncEventingBasicConsumer(channel);
        consumer.ReceivedAsync += async (_, ea) =>
        {
            var msg = JsonSerializer.Deserialize<PedidoCriadoMessage>(ea.Body.Span)!;
            lote.Add((ea.DeliveryTag, msg));

            if (lote.Count >= TamanhoLote)
                await ProcessarLoteAsync(channel, lote, ct);
        };

        await channel.BasicConsumeAsync(
            queue: QueueName,
            autoAck: false,
            consumer: consumer,
            cancellationToken: ct);

        // Timer de flush: fuerza el procesamiento aunque el lote no esté lleno
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(5));
        while (await timer.WaitForNextTickAsync(ct))
        {
            if (lote.Count > 0)
                await ProcessarLoteAsync(channel, lote, ct);
        }
    }

    private async Task ProcessarLoteAsync(
        IChannel channel,
        List<(ulong Tag, PedidoCriadoMessage Msg)> lote,
        CancellationToken ct)
    {
        var snapshot = lote.ToList();
        lote.Clear();

        var pedidos = snapshot.Select(x => new Pedido
        {
            Id           = x.Msg.Id,
            ClienteId    = x.Msg.ClienteId,
            Valor        = x.Msg.Valor,
            DataCriacao  = x.Msg.DataCriacao
        }).ToList();

        using var scope    = scopeFactory.CreateScope();
        var dbContext       = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        var bulkConfig      = new BulkConfig { BatchSize = 500 };

        await dbContext.BulkInsertAsync(pedidos, bulkConfig, cancellationToken: ct);

        // ACK múltiple: confirma todo el lote de una sola vez
        await channel.BasicAckAsync(
            deliveryTag: snapshot[^1].Tag,
            multiple: true,
            cancellationToken: ct);

        logger.LogInformation("Lote de {Count} pedidos grabado", pedidos.Count);
    }
}

Registro en Program.cs

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Program.cs
// dotnet add package RabbitMQ.Client
builder.Services.AddSingleton<IConnection>(_ =>
{
    var factory = new ConnectionFactory
    {
        HostName = "localhost",
        UserName = "guest",
        Password = "guest"
    };
    // CreateConnectionAsync devuelve Task — lo resuelvo aquí para el contenedor de DI
    return factory.CreateConnectionAsync().GetAwaiter().GetResult();
});

builder.Services.AddScoped<PedidoProducer>();
builder.Services.AddHostedService<PedidoConsumerWorker>();

⚠️ Atención: En Oracle, el BulkInsert de EFCore.BulkExtensions requiere el Oracle Data Provider for .NET (ODP.NET). Asegúrate de registrar el provider correcto y de que las sequences estén configuradas correctamente en el modelo, o el bulk insert fallará con un error de constraint de clave primaria.


RabbitMQ vs Azure Service Bus: ¿Cuál Elegir?

Ambas opciones resuelven el mismo problema — desacoplar la producción y el consumo de mensajes — pero con modelos operativos y económicos muy distintos. La elección depende de tu contexto: infraestructura propia vs nube gestionada, costo variable vs fijo, y el grado de control que deseas.

CriterioRabbitMQAzure Service Bus
TipoOpen source (MPL 2.0), self-hostedPaaS gestionado por Microsoft
ProtocoloAMQP 0-9-1 (nativo), AMQP 1.0, MQTT, STOMPAMQP 1.0
HospedajeContenedor propio, VM, KubernetesAzure (sin infra que gestionar)
CostoInfraestructura + operación (tu equipo)Pago por uso (~$0,10/millón de ops)
ColasQueues, Exchanges, BindingsQueues y Topics/Subscriptions
Tamaño máximo de mensaje128 MB (por defecto)256 KB (Standard) / 100 MB (Premium)
Retención de mensajesHasta llenar el disco / TTL configurable14 días (máximo)
Dead-letter queue✅ Configurable✅ Nativo
Sesiones (orden garantizado)✅ Vía x-single-active-consumer✅ Service Bus Sessions
Retry automáticoManual (Dead-letter + requeue)Nativo (MaxDeliveryCount)
Escalabilidad horizontalManual (cluster Erlang)Automática
Biblioteca .NETRabbitMQ.Client (Apache 2.0)Azure.Messaging.ServiceBus (MIT)
Ideal paraOn-premises, multi-cloud, costo controladoEcosistema Azure, equipo pequeño, SLA garantizado

Implementación Equivalente con Azure Service Bus

Para migrar de RabbitMQ a Azure Service Bus en un entorno Azure, el patrón producer/consumer es similar, usando Azure.Messaging.ServiceBus:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
// dotnet add package Azure.Messaging.ServiceBus

// --- Producer con envío por lotes nativo ---
public class PedidoServiceBusProducer(ServiceBusSender sender)
{
    public async Task PublicarLoteAsync(
        IEnumerable<PedidoCriadoMessage> mensagens,
        CancellationToken ct = default)
    {
        // ServiceBusMessageBatch respeta el límite de tamaño automáticamente
        using var batch = await sender.CreateMessageBatchAsync(ct);

        foreach (var msg in mensagens)
        {
            var sbMsg = new ServiceBusMessage(
                BinaryData.FromObjectAsJson(msg))
            {
                ContentType = "application/json",
                MessageId   = msg.Id.ToString()
            };

            if (!batch.TryAddMessage(sbMsg))
                throw new InvalidOperationException(
                    $"El mensaje {msg.Id} excede el límite del lote");
        }

        await sender.SendMessagesAsync(batch, ct);
    }
}

// --- Consumer con BackgroundService ---
public class PedidoServiceBusWorker(
    ServiceBusProcessor processor,
    IServiceScopeFactory scopeFactory,
    ILogger<PedidoServiceBusWorker> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        processor.ProcessMessageAsync += async args =>
        {
            var msg = args.Message.Body
                          .ToObjectFromJson<PedidoCriadoMessage>();

            using var scope   = scopeFactory.CreateScope();
            var dbContext      = scope.ServiceProvider
                                      .GetRequiredService<AppDbContext>();
            var pedido         = new Pedido
            {
                Id          = msg.Id,
                ClienteId   = msg.ClienteId,
                Valor       = msg.Valor,
                DataCriacao = msg.DataCriacao
            };

            await dbContext.BulkInsertAsync(
                new List<Pedido> { pedido },
                cancellationToken: ct);

            // Confirma el procesamiento — lo elimina de la cola
            await args.CompleteMessageAsync(args.Message, ct);
        };

        processor.ProcessErrorAsync += args =>
        {
            logger.LogError(args.Exception,
                "Error al procesar el mensaje de Service Bus");
            return Task.CompletedTask;
        };

        await processor.StartProcessingAsync(ct);
        await Task.Delay(Timeout.Infinite, ct);
    }

    public override async Task StopAsync(CancellationToken ct)
    {
        await processor.StopProcessingAsync(ct);
        await base.StopAsync(ct);
    }
}

// Program.cs
builder.Services.AddSingleton(provider =>
{
    var client = new ServiceBusClient(
        "Endpoint=sb://meu-namespace.servicebus.windows.net/;...");
    return client.CreateSender("pedidos-queue");
});

builder.Services.AddSingleton(provider =>
{
    var client = new ServiceBusClient(
        "Endpoint=sb://meu-namespace.servicebus.windows.net/;...");
    return client.CreateProcessor("pedidos-queue", new ServiceBusProcessorOptions
    {
        MaxConcurrentCalls   = 4,   // Paralelismo en el consumer
        AutoCompleteMessages = false // Control manual de ACK
    });
});

builder.Services.AddHostedService<PedidoServiceBusWorker>();

💡 Consejo: En producción en Azure, prefiere la autenticación vía Managed Identity en lugar de una connection string, usando new ServiceBusClient("meu-namespace.servicebus.windows.net", new DefaultAzureCredential()). Esto elimina secretos de la configuración.


El Cuello de Botella de la Lectura: Por Qué Traer Todo de Una Vez Es Peligroso

El Problema de la Consulta Sin Límite

1
2
3
4
5
// ❌ NUNCA hagas esto en producción con tablas grandes
var todosPedidos = await context.Pedidos
    .Include(p => p.Itens)
    .Include(p => p.Cliente)
    .ToListAsync(); // ¡Puede traer 500 mil registros a la memoria!

Esta consulta aparentemente inocente puede:

  • Consumir gigabytes de RAM en el servidor de la aplicación
  • Bloquear la base de datos con un table scan prolongado
  • Generar timeouts en entornos de alta concurrencia
  • Saturar la red entre la aplicación y la base de datos con tráfico innecesario
  • Asfixiar el GC de .NET con objetos grandes que deben ir al LOH (Large Object Heap)

En Oracle, un aspecto adicional es el uso de ROWNUM (Oracle 11g) vs FETCH FIRST … ROWS ONLY (Oracle 12c+), lo que afecta cómo se expresa la paginación en SQL. El provider Oracle.EntityFrameworkCore lo abstrae, pero es importante entender lo que se está generando.

Tipos de Paginación: Offset vs Keyset (Cursor)

📖 Artículo dedicado: Para una guía completa de todas las estrategias de paginación (Offset, Keyset, Server-Side Cursor, Time-based y Opaque Token) con SQL Server, Oracle y PostgreSQL — incluido código EF Core 8+ para cada combinación —, consulta: Paginación en APIs REST con C# y EF Core: Guía Práctica. Esta sección presenta los conceptos esenciales; el artículo enlazado profundiza en cuándo y por qué usar cada enfoque.

Existen dos estrategias principales de paginación, y cada una tiene casos de uso distintos:

CaracterísticaOffset PaginationKeyset (Cursor) Pagination
SQL generadoOFFSET N ROWS FETCH NEXT MWHERE id > :lastId
Rendimiento en las primeras páginas✅ Rápido✅ Rápido
Rendimiento en páginas tardías❌ Lento (el scan crece)✅ Constante
Soporte a salto de página✅ Directo❌ Solo secuencial
Registros nuevos entre páginas❌ Puede duplicar/omitir✅ Consistente
Caso de uso idealUI con números de páginaScroll infinito / APIs

Offset Pagination: Simple y Adecuada para UIs

La paginación por offset es la más conocida, y EF Core la genera correctamente para SQL Server y Oracle:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// Modelo de request estandarizado
public record PaginacaoRequest(int Pagina = 1, int TamanhoPagina = 20)
{
    // Garantiza límites seguros
    public int TamanhoSeguro => Math.Min(Math.Max(TamanhoPagina, 1), 100);
    public int OffsetSeguro  => (Math.Max(Pagina, 1) - 1) * TamanhoSeguro;
}

// Modelo de respuesta estandarizado
public record PaginaResultado<T>(
    IReadOnlyList<T> Dados,
    int PaginaAtual,
    int TamanhoPagina,
    long TotalRegistros,
    int TotalPaginas);

// Servicio de consulta paginada
public class PedidoQueryService(AppDbContext context)
{
    public async Task<PaginaResultado<PedidoResumoDto>> ListarPedidosAsync(
        PaginacaoRequest paginacao,
        string? clienteId = null,
        CancellationToken ct = default)
    {
        // Construir la query base con filtros opcionales
        var query = context.Pedidos
            .AsNoTracking()           // Lectura: ¡siempre AsNoTracking!
            .Where(p => clienteId == null || p.ClienteId == clienteId);

        // COUNT separado para el total (EF Core 8 lo optimiza)
        var total = await query.LongCountAsync(ct);

        // Datos de la página
        var dados = await query
            .OrderBy(p => p.DataCriacao)   // OrderBy obligatorio para paginación consistente
            .Skip(paginacao.OffsetSeguro)
            .Take(paginacao.TamanhoSeguro)
            .Select(p => new PedidoResumoDto(   // Projection: solo los campos necesarios
                p.Id,
                p.ClienteId,
                p.Valor,
                p.DataCriacao,
                p.Status))
            .ToListAsync(ct);

        return new PaginaResultado<PedidoResumoDto>(
            Dados: dados,
            PaginaAtual: paginacao.Pagina,
            TamanhoPagina: paginacao.TamanhoSeguro,
            TotalRegistros: total,
            TotalPaginas: (int)Math.Ceiling(total / (double)paginacao.TamanhoSeguro));
    }
}

💡 Consejo: Usa siempre .Select() con proyección (DTO o record); nunca devuelvas la entidad completa en consultas de listado. Esto reduce el volumen de datos transferidos y evita cargar navegaciones innecesarias.

SQL Generado: SQL Server vs Oracle

EF Core 8 genera SQL correcto y optimizado para ambas bases de datos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
-- SQL Server (generado por EF Core 8)
SELECT p.Id, p.ClienteId, p.Valor, p.DataCriacao, p.Status
FROM Pedidos AS p
WHERE p.ClienteId = N'cliente-123'
ORDER BY p.DataCriacao
OFFSET 40 ROWS FETCH NEXT 20 ROWS ONLY;

-- Oracle 12c+ (generado por Oracle.EntityFrameworkCore 8)
SELECT p.Id, p.ClienteId, p.Valor, p.DataCriacao, p.Status
FROM Pedidos p
WHERE p.ClienteId = :clienteId_0
ORDER BY p.DataCriacao
OFFSET 40 ROWS FETCH NEXT 20 ROWS ONLY;

⚠️ Atención: Para Oracle 11g (sin FETCH FIRST), el provider genera una consulta con ROWNUM anidado, que puede tener costo adicional en tablas muy grandes. Considera migrar a Oracle 12c+ o usar vistas materializadas para informes pesados.


Keyset Pagination: Alto Rendimiento para Scroll Infinito y APIs

Cuando el usuario navega a la página 500 de un resultado con 10 mil ítems, la base de datos necesita hacer un scan de 10.000 filas solo para saltar las primeras 9.980. Con keyset pagination, usas el valor de la última fila obtenida como punto de partida de la siguiente consulta:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// Request con cursor (keyset)
public record KeysetRequest(
    Guid? UltimoId = null,
    DateTime? UltimaDataCriacao = null,
    int Limite = 20);

// Resultado con cursor para la próxima página
public record KeysetResultado<T>(
    IReadOnlyList<T> Dados,
    bool TemProximaPagina,
    Guid? ProximoCursorId,
    DateTime? ProximoCursorData);

public class PedidoKeysetService(AppDbContext context)
{
    public async Task<KeysetResultado<PedidoResumoDto>> ListarComCursorAsync(
        KeysetRequest request,
        CancellationToken ct = default)
    {
        // Filtro de keyset: busca registros "después" del cursor
        // Usando (DataCriacao, Id) como clave compuesta para estabilidad
        var query = context.Pedidos
            .AsNoTracking()
            .Where(p =>
                request.UltimaDataCriacao == null ||
                p.DataCriacao > request.UltimaDataCriacao ||
                (p.DataCriacao == request.UltimaDataCriacao &&
                 p.Id.CompareTo(request.UltimoId!.Value) > 0))
            .OrderBy(p => p.DataCriacao)
            .ThenBy(p => p.Id);

        // Busca Limite + 1 para saber si hay próxima página
        var dados = await query
            .Take(request.Limite + 1)
            .Select(p => new PedidoResumoDto(p.Id, p.ClienteId, p.Valor, p.DataCriacao, p.Status))
            .ToListAsync(ct);

        var temProxima = dados.Count > request.Limite;
        if (temProxima) dados.RemoveAt(dados.Count - 1); // Elimina el ítem extra

        var ultimo = dados.LastOrDefault();

        return new KeysetResultado<PedidoResumoDto>(
            Dados: dados,
            TemProximaPagina: temProxima,
            ProximoCursorId: ultimo?.Id,
            ProximoCursorData: ultimo?.DataCriacao);
    }
}

Este patrón mantiene un rendimiento constante independientemente del número de página, porque el SQL generado usa un WHERE indexado simple en lugar de OFFSET.

1
2
3
4
5
6
-- SQL generado (SQL Server / Oracle)
SELECT TOP(21) p.Id, p.ClienteId, p.Valor, p.DataCriacao, p.Status
FROM Pedidos AS p
WHERE p.DataCriacao > '2025-06-01'
   OR (p.DataCriacao = '2025-06-01' AND p.Id > 'abc-123')
ORDER BY p.DataCriacao, p.Id;

💡 Consejo: Crea un índice compuesto en las columnas del keyset para garantizar que la consulta use un index seek en lugar de un table scan:

1
2
3
4
5
-- SQL Server
CREATE INDEX IX_Pedidos_Keyset ON Pedidos (DataCriacao, Id) INCLUDE (ClienteId, Valor, Status);

-- Oracle
CREATE INDEX IX_Pedidos_Keyset ON Pedidos (DataCriacao, Id);

Uniendo Todo: La Arquitectura Completa

Con ambas soluciones combinadas, la arquitectura de la aplicación queda así:

  • Escritura: la API recibe → publica en la cola → responde 202 Accepted → el Consumer procesa en lotes con BulkInsert
  • Lectura: la API recibe una request paginada → ejecuta la consulta con Skip/Take (offset) o WHERE (keyset) → devuelve solo los datos necesarios
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Endpoint ASP.NET Core — escritura asíncrona
app.MapPost("/pedidos/lote", async (
    [FromBody] List<CriarPedidoRequest> requests,
    PedidoService service,
    CancellationToken ct) =>
{
    var ids = await Task.WhenAll(
        requests.Select(r => service.CriarPedidoAsync(r, ct)));

    // 202 Accepted: los pedidos fueron encolados, no necesariamente grabados
    return Results.Accepted("/pedidos/status", new { Ids = ids });
});

// Endpoint ASP.NET Core — lectura paginada
app.MapGet("/pedidos", async (
    [AsParameters] PaginacaoRequest paginacao,
    [FromQuery] string? clienteId,
    PedidoQueryService queryService,
    CancellationToken ct) =>
{
    var resultado = await queryService.ListarPedidosAsync(paginacao, clienteId, ct);
    return Results.Ok(resultado);
});

Consejos y Buenas Prácticas

  • Índices adecuados: Toda columna usada en OrderBy, Where o cursor de keyset debe tener un índice. En Oracle, usa índices basados en funciones para columnas con transformaciones (ej.: UPPER(nome)).
  • AsNoTracking siempre en lecturas: Desactiva el Change Tracker en consultas de lectura, reduciendo el uso de memoria y CPU hasta en un 30%.
  • Evita Count() en tablas grandes: Para keyset pagination, no necesitas el total de registros. Para offset, considera cachear el total durante algunos segundos.
  • Define timeouts explícitos: Configura context.Database.SetCommandTimeout(30) o usa WithTimeout por consulta para evitar que consultas largas bloqueen la aplicación indefinidamente.
  • Monitorea el tamaño de la cola: Configura alertas para cuando la cola supere N mensajes — es la señal de que el consumer no está dando abasto con el volumen.
  • Usa IAsyncEnumerable para streaming: Para exportaciones CSV o procesamiento de grandes volúmenes que no necesitan paginación, usa AsAsyncEnumerable() para procesar fila por fila sin cargar todo en la memoria:
1
2
3
4
5
6
7
8
// Streaming con IAsyncEnumerable — sin cargar todo en la memoria
await foreach (var pedido in context.Pedidos
    .AsNoTracking()
    .AsAsyncEnumerable()
    .WithCancellation(ct))
{
    await exportador.EscreverLinhaAsync(pedido, ct);
}
  • Transacciones explícitas para consistencia: Al usar BulkInsert con varias tablas (ej.: grabar Pedido e ItensPedido juntos), envuelve la operación en una transacción explícita para garantizar la atomicidad.

Conclusión

Los cuellos de botella en bases de datos con EF Core rara vez son culpa de la base de datos en sí. En la inmensa mayoría de los casos, el problema está en cómo la aplicación interactúa con ella: insertar un registro a la vez en lugar de por lotes, y traer todo el resultado en lugar de paginar.

La combinación de mensajería (RabbitMQ o Azure Service Bus) para desacoplar escrituras masivas y paginación eficiente (offset para UIs, keyset para APIs y scroll infinito) resuelve ambos cuellos de botella de forma elegante, escalable y resiliente. Con EF Core 8.0+ y las técnicas presentadas aquí, puedes soportar volúmenes mucho mayores sin cambiar la estructura de la base de datos, solo ajustando la forma en que la aplicación se comunica con ella.

El siguiente paso natural es la observabilidad: instrumentar consultas lentas con Application Performance Monitoring (APM), crear alertas para consultas que superen N segundos y mapear índices faltantes vía Query Store (SQL Server) o AWR (Oracle).


Lee También


Referencias