Introducción
Paginar resultados parece simple: agregas .Skip(offset).Take(pageSize) y listo. Pero cuando la tabla tiene 10 millones de registros, el usuario está en la página 5.000, la base de datos es Oracle 11g o el cliente exige scroll infinito sin duplicados — esa simplicidad desaparece rápidamente.
La paginación es una de las decisiones arquitectónicas de mayor impacto en APIs REST, y la elección equivocada puede significar consultas de 8 segundos, resultados inconsistentes o un backend que se bloquea bajo carga. Existen al menos cinco estrategias distintas, cada una con trade-offs claros: Offset, Keyset (Seek), Cursor de base de datos, Token opaco y Time-based. Cada base de datos — SQL Server, Oracle y PostgreSQL — implementa estas estrategias con sintaxis y comportamiento ligeramente distintos.
En este artículo vas a entender en profundidad cuándo usar cada estrategia, cómo la implementa cada base de datos y cómo codificar todo con EF Core 8.0+ en C#. Si quieres una visión más amplia de los cuellos de botella de lectura y escritura en bases de datos, lee también el artículo Cuello de Botella en Bases de Datos: Mensajería y Paginación.
Requisitos previos: C# intermedio, EF Core básico, familiaridad con SQL. También se recomienda el artículo sobre programación asíncrona con C#.
📦 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.
Por Qué la Paginación Equivocada Destruye el Rendimiento
Antes de ver las estrategias, vale la pena entender qué ocurre internamente en cada base de datos cuando paginas:
El Problema del OFFSET Profundo
| |
La base de datos no “salta” mágicamente a la fila 99.981. Necesita:
- Ordenar (o usar el índice de ordenamiento)
- Recorrer 99.980 filas y descartarlas
- Devolver las 20 siguientes
El costo crece linealmente con el offset. Para OFFSET 0 el costo es casi cero; para OFFSET 1.000.000 el costo puede ser de segundos. Este es el problema de la paginación tardía, y aparece en cualquier base de datos.
Por Qué el Ordenamiento Estable Es Obligatorio
| |
Sin OrderBy, la base de datos puede devolver los 20 ítems en cualquier orden, y corres el riesgo de ver los mismos registros en páginas distintas o de saltarte registros. Esto es especialmente crítico en Oracle, que por defecto tiene un comportamiento de ordenamiento menos predecible que SQL Server.
Estrategia 1: Offset Pagination (SKIP / TAKE)
Cuándo Usar
- Interfaces con números de página visibles (página 1, 2, 3…)
- Reportes que requieren totales exactos
- Volúmenes pequeños o medianos (hasta ~100 mil registros en la tabla)
- Cuando el usuario necesita saltar directamente a cualquier página
El SQL de Cada Base de Datos
| |
💡 Consejo: El provider Oracle.EntityFrameworkCore detecta automáticamente la versión de Oracle y genera la sintaxis correcta (con FETCH FIRST para 12c+ o ROWNUM para 11g). No necesitas escribir SQL raw para eso.
Implementación con EF Core 8
| |
⚠️ Atención: Para tablas con más de 500 mil filas, LongCountAsync() por sí solo puede ser lento (table scan). Una estrategia común es cachear el total durante 30–60 segundos, o usar una columna de conteo materializada.
Estrategia 2: Keyset Pagination (Seek / WHERE-based)
Cuándo Usar
- APIs REST con scroll infinito o token de “siguiente página”
- Tablas con millones de registros donde el OFFSET se degrada
- Feeds de datos en tiempo real donde se insertan ítems nuevos constantemente
- Exportación asíncrona de grandes volúmenes
Cómo Funciona
En lugar de decir “salta N filas”, dices “dame los registros después de este punto de referencia”. La base de datos usa el índice directamente para posicionarse en el cursor, sin recorrer los registros anteriores.
| |
El TOP 21 (o LIMIT 21) es intencional: se busca un registro extra para saber si existe una página siguiente, sin ejecutar un COUNT.
Índice Obligatorio para Keyset
| |
Sin este índice, la base de datos vuelve a hacer un full scan incluso con el WHERE de keyset.
Implementación con EF Core 8
| |
El token generado es opaco para el cliente — no sabe qué contiene, solo lo pasa a la siguiente llamada. Esto permite cambiar la implementación interna sin romper a los clientes.
Estrategia 3: Cursor de Base de Datos (Server-Side Cursor)
Qué Es un Cursor de Base de Datos y Cuándo Usarlo
Un cursor de base de datos es distinto del cursor de keyset. Aquí, la propia base de datos mantiene una posición de lectura abierta entre llamadas. El servidor reserva recursos (memoria, locks o snapshot) para ese conjunto de resultados mientras el cliente obtiene bloques.
Es la estrategia ideal para:
- Exportaciones largas donde el cliente consume datos en bloques durante segundos o minutos
- Procesamiento ETL fila por fila sin cargar todo en memoria
- Streaming de datos vía WebSocket o Server-Sent Events
- Situaciones en las que el conjunto de resultados no puede cambiar durante la lectura (consistencia de snapshot)
⚠️ Atención: Los cursores de base de datos consumen recursos del servidor mientras están abiertos. En SQL Server y Oracle, los cursores mal gestionados (dejados abiertos) causan presión de memoria e incluso bloqueos. PostgreSQL maneja mejor los cursores dentro de transacciones, pero aun así requiere cuidado.
PostgreSQL: DECLARE CURSOR (el más completo)
PostgreSQL tiene el soporte más rico para cursores server-side. Para usarlos con EF Core, necesitas ejecutar SQL raw dentro de una transacción, porque los cursores de PostgreSQL solo existen dentro del alcance de una transacción:
| |
SQL Server: Cursor FAST_FORWARD vía SQL Raw
SQL Server soporta cursores T-SQL, pero para APIs REST el patrón más eficiente es usar IAsyncEnumerable con AsAsyncEnumerable() de EF Core o un cursor vía ADO.NET directamente:
| |
💡 Consejo: AsAsyncEnumerable() en EF Core se implementa como un DataReader que permanece abierto mientras se consume el IAsyncEnumerable. Internamente funciona como un cursor de base de datos implícito. La diferencia con un cursor SQL explícito es que el DataReader no permite pausar la lectura y retomarla más tarde en una nueva conexión.
Oracle: REF CURSOR y SYS_REFCURSOR
En Oracle, el equivalente es el REF CURSOR, normalmente expuesto mediante una stored procedure. Con el provider Oracle.EntityFrameworkCore, puedes ejecutarlo así:
| |
Estrategia 4: Time-based Pagination
Cuándo Usar
- Datos con dimensión temporal natural (logs, eventos, transacciones)
- APIs de auditoría o historial con filtros de ventana de tiempo
- Cuando el cliente quiere datos de una hora específica (ej.: “pedidos de ayer”)
- Integración con sistemas de streaming (Kafka, Event Sourcing)
Implementación
La paginación time-based es una forma especializada de keyset, con la columna de fecha como cursor principal. La diferencia es que el cliente elige la ventana de tiempo explícitamente:
| |
💡 Consejo: La gran ventaja de la paginación time-based frente al keyset puro es que el cliente puede elegir ventanas inmutables (ej.: “todo el día 2025-01-01”), lo que permite cachear agresivamente esas ventanas en el servidor, ya que el contenido no cambia después de que la ventana se cierra.
Estrategia 5: Token Opaco y Enlaces HATEOAS
Cuándo Usar
- APIs públicas donde no quieres exponer detalles de implementación al cliente
- Cuando la estrategia de paginación puede cambiar sin romper a los clientes
- APIs que necesitan HATEOAS (enlaces de página siguiente/anterior en la respuesta)
El token opaco encapsula internamente cualquier estrategia de cursor:
| |
Comparativo: Qué Estrategia Usar en Cada Situación
| Criterio | Offset | Keyset / Seek | Cursor Server-Side | Time-based | Token Opaco |
|---|---|---|---|---|---|
| Total de registros | ✅ Sí | ❌ No | ❌ No | ⚠️ Por ventana | ❌ No |
| Saltar páginas | ✅ Directo | ❌ Solo secuencial | ❌ Solo secuencial | ✅ Por ventana | ❌ Solo secuencial |
| Rendimiento en páginas tardías | ❌ Se degrada | ✅ Constante | ✅ Constante | ✅ Constante | ✅ Constante |
| Registros nuevos entre páginas | ❌ Drift | ✅ Consistente | ✅ Snapshot | ✅ Ventana fija | ✅ Consistente |
| Complejidad de implementación | ⭐ Simple | ⭐⭐ Media | ⭐⭐⭐ Alta | ⭐⭐ Media | ⭐⭐ Media |
| Recursos del servidor | Bajo | Bajo | 🔴 Alto (cursor abierto) | Bajo | Bajo |
| Soporte nativo EF Core | ✅ Completo | ✅ Con Where personalizado | ⚠️ SQL Raw / ADO | ✅ Con Where personalizado | ✅ Sobre keyset |
| SQL Server | ✅ OFFSET FETCH | ✅ WHERE seek | ✅ Cursor FAST_FORWARD | ✅ WHERE range | ✅ |
| Oracle | ✅ 12c+ / ROWNUM 11g | ✅ WHERE seek | ✅ REF CURSOR | ✅ WHERE range | ✅ |
| PostgreSQL | ✅ LIMIT OFFSET | ✅ WHERE seek | ✅ DECLARE CURSOR | ✅ WHERE range | ✅ |
| Ideal para | UI clásica | APIs / mobile | ETL / streaming | Auditoría / logs | APIs públicas |
Índices: La Base de Toda Paginación
Ninguna estrategia de paginación funciona bien sin los índices correctos. Para cada base de datos:
| |
⚠️ Atención Oracle: Oracle no soporta columnas INCLUDE en índices regulares (a diferencia de SQL Server y PostgreSQL). Para índices covering en Oracle, usa Composite Indexes o Index-Organized Tables (IOT) en tablas con alto volumen de lectura.
Middleware de Paginación Reutilizable para ASP.NET Core
Para APIs REST con múltiples endpoints, crear un middleware de paginación evita la duplicación:
| |
Consejos y Buenas Prácticas
- Nunca devuelvas sin Take/Limit: Aplica siempre un límite máximo en la capa de servicio, independientemente de lo que envió el cliente. Exponlo mediante la validación de la solicitud.
- Keyset requiere una clave compuesta estable: Usa siempre
(columna_ordenamiento, id_unico)como cursor compuesto. La columna de ordenamiento sola puede tener duplicados; elIdgarantiza unicidad y estabilidad. - Cursor de base de datos: ciérralo siempre: Para cursores server-side (
DECLAREde PostgreSQL,REF CURSORde Oracle), usatry/finallypara garantizar elCLOSE. Un cursor abierto en Oracle o SQL Server consume recursos del servidor indefinidamente. - Documenta el tipo de paginación en OpenAPI: Indica en Swagger qué estrategia usa cada endpoint — los clientes necesitan saber si pueden saltar páginas o solo avanzar secuencialmente.
- Versiona la estrategia de paginación: Si cambias de Offset a Keyset en un endpoint existente, versiona la API (
/v2/pedidos) para no romper a los clientes que dependen del campototalPaginas. - Monitorea las consultas lentas: Habilita Query Store (SQL Server), AWR (Oracle) o
pg_stat_statements(PostgreSQL) para capturar consultas de paginación que superen los SLAs. - Prefiere proyecciones con Select(): Nunca devuelvas la entidad completa en endpoints de listado. Selecciona solo los campos necesarios para reducir I/O y asignación de memoria.
Conclusión
Paginar datos en APIs REST con C# y EF Core 8 va mucho más allá de .Skip().Take(). Cada estrategia — Offset, Keyset, Cursor server-side, Time-based y Token opaco — existe por una razón y atiende escenarios distintos. La elección equivocada resulta en consultas lentas, inconsistencias de datos o consumo innecesario de recursos de la base de datos.
El camino más seguro es: empezar con Offset para interfaces simples con volúmenes controlados, migrar a Keyset cuando la tabla crezca y el offset empiece a degradarse, usar Cursor server-side solo para streaming y ETL con una gestión cuidadosa del ciclo de vida, y Time-based para datos con dimensión temporal natural.
SQL Server, Oracle y PostgreSQL soportan todas estas estrategias — las diferencias están en la sintaxis y en los detalles de implementación, pero EF Core 8 abstrae la mayoría de ellas. Lo que EF Core no hace por ti es crear los índices correctos: eso siempre es tu responsabilidad.
Si llegaste hasta aquí buscando entender cómo los cuellos de botella de la base de datos afectan no solo la lectura sino también la escritura masiva, continúa con el artículo Cuello de Botella en Bases de Datos: Mensajería y Paginación, que cubre la solución con mensajería (RabbitMQ y Azure Service Bus) para el lado de la escritura.
Lee También
- EF Core 8 Fluent API: Mapeo, ORM y Desacoplamiento
- EF Core Migrations: Multiproyecto, Secrets y Scaffolding
- Full-Text Search en API REST: C#, SQL Server y PostgreSQL
- Arquitectura de Software: GoF, Patrones y Microservicios
- Diseño de API REST: Verbos HTTP y Parameter Binding
- Cuello de Botella en Bases de Datos: Mensajería y Paginación
- Programación Asíncrona en C#: async/await y Threads
- Paralelismo en C#: Parallel, PLINQ y Tasks en la Práctica
- Worker y Background Service en .NET: Alto Volumen
Referencias
- EF Core — Consulta de datos (Microsoft Docs) — Documentación oficial sobre consultas con EF Core
- EF Core — Paginación — Guía oficial de paginación en EF Core (Offset y Keyset)
- PostgreSQL — Cursors — Documentación oficial de cursores en PostgreSQL
- SQL Server — Cursor T-SQL — Referencia de cursores T-SQL en SQL Server
- Oracle — REF CURSOR — Documentación oficial de REF CURSOR en Oracle PL/SQL
- Use the PostgreSQL pg_stat_statements — Monitoreo de consultas lentas en PostgreSQL
- Repositorio blog-zocateli-sample — Pagination — Código fuente completo de los ejemplos de este artículo

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.