El control DataGridView en Windows Forms es un componente fundamental para la visualización y manipulación de datos en formato de cuadrícula. Aunque es altamente configurable y soporta múltiples tipos de fuentes de datos, carece de un mecanismo de paginación nativo. Cuando se trabaja con grandes volúmenes de información, cargar todos los registros simultáneamente degrada el rendimiento de la interfaz. Para solucionar esto, es necesario desarrollar un control de paginación personalizado que gestione la carga de datos por segmentos.

Arquitectura del Control de Paginación

El diseño de un componente de paginación debe priorizar la experiencia del usuario y la eficiencia en el consumo de recursos. Un enfoque modular permite separar la lógica de cálculo de índices, la interacción visual y el enlace de datos.

Cálculo de Índices de Paginación

El núcleo del control reside en su capacidad para determinar qué subconjunto de datos mostrar. En lugar de utilizar parámetros de salida, podemos emplear estructuras de solo lectura para devolver los límites de la página actual, mejorando la legibilidad y evitando efectos secundarios.

public struct PageBounds
{
    public int Start { get; }
    public int End { get; }
    public PageBounds(int start, int end) { Start = start; End = end; }
}

public static class PaginationEngine
{
    public static PageBounds? CalculateBounds(int currentPage, int itemsPerPage, int totalItems)
    {
        if (currentPage < 1 || itemsPerPage <= 0 || totalItems <= 0)
            return null;

        int offset = (currentPage - 1) * itemsPerPage;
        int limit = Math.Min(offset + itemsPerPage - 1, totalItems - 1);

        return new PageBounds(offset, limit);
    }
}

Estructura de la Clase Principal

El archivo de código subyacente encapsula el estado del control. Se utilizan propiedades con validación interna para garantizar la consistencia de los datos y eventos para notificar a la interfaz principal.

public class Paginator : UserControl
{
    private int _recordsPerPage = 20;
    private int _totalRecords;
    private int _activePage = 1;

    public int RecordsPerPage 
    { 
        get => _recordsPerPage; 
        set 
        { 
            if (value > 0) _recordsPerPage = value; 
        } 
    }

    public int TotalRecords 
    { 
        get => _totalRecords; 
        set 
        { 
            _totalRecords = Math.Max(0, value); 
            RefreshUI(); 
        } 
    }

    public event EventHandler PageNavigationRequested;

    public void GoToNext()
    {
        int maxPages = (int)Math.Ceiling((double)_totalRecords / _recordsPerPage);
        if (_activePage < maxPages)
        {
            _activePage++;
            OnPageNavigationRequested();
        }
    }

    protected virtual void OnPageNavigationRequested()
    {
        PageNavigationRequested?.Invoke(this, EventArgs.Empty);
    }
    
    private void RefreshUI() { /* Lógica de actualización visual */ }
}

Generación Automática y Código de Diseño

El archivo de diseñador es gestionado por el entorno visual de Visual Studio y contiene la instanciación de los componentes gráficos. Si se requiere inyectar lógica personalizada en la inicialización, es recomendable hacerlo en el constructor de la clase parcial principal después de la llamada al método de inicialización, evitando así que el diseñador sobrescriba los cambios manuales.

partial class Paginator
{
    private System.ComponentModel.IContainer _uiComponents = null;

    protected override void Dispose(bool isDisposing)
    {
        if (isDisposing && _uiComponents != null)
        {
            _uiComponents.Dispose();
        }
        base.Dispose(isDisposing);
    }
}

Gestión de Recursos y Localización

Para que el control sea reutilizable en diferentes regiones, los textos y elementos gráficos no deben estar codificados de forma rígida. Se emplean archivos de recursos para almacenar cadenas traducibles e iconos.

Definición de Recursos

En el archivo de recursos, se definen pares clave-valor. Por ejemplo, para los botones de navegación:

<data name="BtnNextText" xml:space="preserve">
  <value>Siguiente</value>
</data>
<data name="BtnPrevText" xml:space="preserve">
  <value>Anterior</value>
</data>

Acceso a Recursos en Tiempo de Ejecución

El acceso a estos elementos se realiza mediante la clase administradora de recursos, lo que permite cambiar el idioma dinámicamente modificando la cultura de la interfaz de usuario del hilo actual antes de renderizar el control.

var nextLabel = Properties.PaginatorResources.ResourceManager.GetString("BtnNextText");
btnNext.Text = nextLabel ?? "Next";

Configuración del Proyecto

El archivo de proyecto en formatos modernos simplifica la inclusión de referencias. Para un control WinForms, es crucial asegurar que el framework objetivo y las dependencias de UI estén correctamente declaradas.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <RootNamespace>CustomGridControls</RootNamespace>
  </PropertyGroup>
</Project>

La solución simplemente orquesta la compilación, y se recomienda utilizar la CLI de .NET o MSBuild para automatizar la limpieza y compilación en entornos de integración continua.

Integración en la Aplicación

Una vez compilada la biblioteca de clases, el control puede añadirse al cuadro de herramientas o instanciarse programáticamente. La integración con el DataGridView se realiza interceptando el evento de cambio de página.

Enlace de Datos y Navegación

El siguiente fragmento demuestra cómo conectar el paginador con una fuente de datos, actualizando la cuadrícula cuando el usuario cambia de página.

private void InitializeGridPagination()
{
    customPaginator.RecordsPerPage = 15;
    customPaginator.TotalRecords = FetchTotalRecordCount();
    
    customPaginator.PageNavigationRequested += (sender, args) => 
    {
        LoadDataForCurrentPage();
    };

    LoadDataForCurrentPage();
}

private void LoadDataForCurrentPage()
{
    var bounds = PaginationEngine.CalculateBounds(
        customPaginator.ActivePage, 
        customPaginator.RecordsPerPage, 
        customPaginator.TotalRecords);

    if (bounds.HasValue)
    {
        var pageData = FetchDataFromDatabase(bounds.Value.Start, customPaginator.RecordsPerPage);
        dataGridview1.DataSource = pageData;
    }
}

Funcionalidades Avanzadas

El control puede extenderse para soportar ordenación y filtrado a nivel de base de datos, evitando traer registros innecesarios a la memoria de la aplicación. Esto se logra pasando expresiones o cláusulas parametrizadas al método de obtención de datos, asegurando que la paginación se ejecute directamente en el servidor de base de datos para maximizar el rendimiento.