Acceso a datos

Introducción para acceder a la base de datos de la aplicación

Visión general

Cada organización estña representada por una única base de datos, incluso cuando se utiliza la opción de varias organizaciones. Cada tabla está representada por un tipo de entidad especial derivado del tipo.

Actualmente, Crono es compatible con los sistemas de base de datos Microsoft SQL Server, MySQL y utiliza el mapeador relacional de objetos (O/R-Mapper) de para acceder a la base de datos de la organización. EntidadBase

Permite a los desarrolladores de .NET trabajar con una base de datos mediante objetos .NET.
Se puede omitir la mayor parte del código de acceso a datos que normalmente se escribiría-
Escriba código de acceso a datos independiente del proveedor, independientemente del proveedor de base de datos subyacente.

La puerta de entrada principal a la base de datos de la aplicación es, que representa la unidad de trabajo. El contexto realiza un seguimiento de todo lo que hace durante una solicitud/transacción que afecta a la base de datos. Averigua todo lo que se debe hacer para alterar la base de datos como resultado ed su trabajo. También define las propiedades y los métodos de extensión que exponen los repositorios para interactuar con tablas de base de datos específicas. CronoDbContexto

CronoDbContexto

La implementación principal de EF para la base de datos de la aplicación es . Se registra como una dependencia con ámbito en el contenedor de inyección de dependencias y, como tal, su tipo se puede pasar fácilmente como una dependencia para que se resuelva.

public class MiServicio : IMiServicio
{
    private readonly CronoDbContexto _db;

    public MiServicio(CronoDbContexto db)
    {
        _db = db;
    }

    public Task<List<MiEntidadDto>> ObtenerMisEntidades()
    {
        var misEntidades = _db.Set<MiEntidad>()
            .Select(x=>x.HaciaMiEntidadDto())
            .ToListAsync();
            
        return misEntidades;
    }
}

Se recomienda asignar un nombre al parámetro de contexto de datos o si se utiliza en un campo. Que sea simple y breve. db _db

Fábrica agrupada

Una instancia no se resuelve directamente desde el contenedor de inyección de dependencias, sino desde el agrupado que se configura y crea al iniciar la aplicación. La fábrica, registrada como singleton, es responsable de crear y agrupar las instancias. CronoDbContexto IDbContextFactory<CronoDbContexto> CronoDbContexto

Una instancia creada por la fábrica se devuelve al grupo tras la eliminación y se restablece a su estado inicial. Cada vez que se solicita una instancia, el grupo devolverá una instancia no arrendada ya existente en lugar de crear una nueva, o creará una nueva instancia si el grupo se agota. Por lo tanto, el registro de DI es en realidad un delegado que concede una instancia de este grupo, no del contenedor de DI. CronoDbContexto

La agrupación es muy beneficiosa para el rendimiento en escenarios de alta carga, ya que la fábrica evita que se creen instancias de demasiados objetos.

De forma predeterminada, el tamaño del grupo se establece en 1024 instancias y se puede modificar mediante la configuración. appsettings.json BdContextoTamanioGrupo

En algunas situaciones, puede ser necesario arrendar manualmente una instancia de contexto del grupo. Dos escenarios en los que esto ocurre son:

No se puede pasar como una dependencia en objetos singleton, debido a su ámbito.
Necesita un control granular de su unidad de trabajo

En estos casos, es posible que desee realizar una de las siguientes acciones:

public class MiSingletonServicio : IMiSingletonServicio 
{
    private IDbContextFactory<CronoDbContexto> _dbFabrica;

    public MiSingletonServicio(IDbContextFactory<CronoDbContexto> dbFabrica)
    {
        // IDbContextFactory<T> es singleton y puede
        // pasarse a otras dependencias singleton.
        _dbFabrica = dbFabrica;
    }

    public Task<List<MiEntidad>> ObtenerMisEntidades()
    {
        // Arrendar instancia de contexto del grupo
        using (var db = _dbFabrica.CreateDbContext())
        {
            // hacer algo en esta "unidad de trabajo"
        } // --> Dispose: devolver la instancia de contexto al grupo
    }
}

Paginación

Lista paginada

El enfoque tradicional para aplicar paginación a una consulta LINQ sería llamar a los métodos and. Crono proporciona una forma más conveniente con . Le permite tomar un (o incluso un ), dividirlo en páginas y tomar una página en particular por un índice. Skip() Take() ListaPaginada IQueryable IEnumerable

Simplemente puede llamar desde su /, pasando el tamaño de la página y el índice de la página que desea cargar. El resultado sigue siendo solo un subconjunto de los datos totales. La llamada devuelve una instancia de IListaPaginada<T>, que también implementa las interfaces IPaginable. AListaPaginada ToList IQueryable IEnumerable IList<T> AListaPaginada IList<T>

Si el origen es a, la paginación se realiza en el lado de la base de datos, de lo contrario en la memoria. IQueryable<T> DbSet<T>

A carga datos de forma diferida cuando se inicia la iteración o cuando se accede a la lista por primera vez. Para cargar los datos de forma explícita de antemano, debe llamar a ListaPaginada Cargar CargarAsync

Ejemplo

// _db es CronoDbContexto
var db = _db;

// Simple paginación: carga pagina 3 con 100 elementos
var productoCortado = await db.Productos.AListaPaginada(3, 100).CargarAsync();

// Paginación más compleja
var indicePagina = -1;

while (true)
{
    var productos = db.Productos.AListaPaginada(++indicePagina, 500);
    
    // Iterar a través de todos los elementos de la página.
    await foreach (var producto in productos.ComoEnumerableAsync())
    {
        // Hacer algo...
    }

    if (!productos.TienePaginasSiguientes)
    {
        // Salir del bucle si no hay más páginas
        break;
    }
}

PaginadorRapido

No es tan conveniente como pero es muy eficiente. Proporciona un rendimiento de paginación estable y coherente en conjuntos de datos muy grandes. PaginadorRapido ListaPaginada

A diferencia del enfoque de LINQ, el conjunto de entidades se ordena por identificador descendente y se devuelve un número especificado de registros. Recuerda el último identificador (el más bajo) devuelto y lo usa para la cláusula WHERE del siguiente lote. De esta manera, puede evitar por completo , que se sabe que funciona mal en mesas grandes cuando el recuento de omisiones es muy alto. Skip(x).Take(y) PaginadorRapido Skip()

Ejemplo

// _db es CronoDbContexto
var db = _db;

// Construya la consulta de antemano
var consulta = db.Productos.Where(x => x.MontoPrestamo > 100);

// Cree una instancia de PaginadorRapido con una consulta dada y un tamaño de página de 500
var paginador = new PaginadorRapido<Producto>(consulta, 500);

// Página sincrona
while (paginador.LeerSiguientePagina<Producto>(out var productos))
{
    // Haz algo significativo...
}

// ...o página de forma asincrónica
while ((await paginador.LeerSiguientePaginaAsync<Producto>()).Out(out var productos))
{
    // Haz algo significativo...
}

Caché de segundo nivel

La memoria caché de segundo nivel es donde las entidades consultadas se almacenan en caché en la memoria. Esto permite que las consultas posteriores en las mismas entidades recuperen el resultado directamente de la memoria caché, omitiendo la base de datos por completo. No tener que acceder a la base de datos significa que las consultas se ejecutan mucho más rápido. Esto se incrementa aún más porque no hay ningún registro para clasificar la materialización involucrada, ya que las entidades materializadas ya están almacenadas en caché.

Una entrada de caché siempre contiene el resultado de una consulta, por lo que contiene una sola entidad o una lista de entidades. La clave de la entrada es el hash único de su consulta. Incluso la más mínima variación en la consulta da como resultado un hash diferente y, por lo tanto, una nueva entrada de caché.

Cada vez que se actualiza o elimina una entidad procedente de la memoria caché, todas las entradas de la memoria caché que contengan esa entidad se invalidarán automáticamente. Esto significa que la próxima vez que se ejecute la consulta, se volverá a acceder a la base de datos.

Sin embargo, no todos los tipos de entidad se pueden almacenar en caché. Solo se almacenan en caché los tipos anotados con el atributo. Este atributo también define la directiva de almacenamiento en caché, como el tiempo que se debe almacenar en caché la entrada (el valor predeterminado es 3 horas) y un límite máximo de filas (hace que los resultados de la consulta con más elementos que el número especificado no se almacenen en caché). EntidadCacheable

Solo los tipos de entidad que no cambian con frecuencia y los que no es probable que produzcan tablas de base de datos de gran tamaño se marcan como almacenables en caché. Por ejemplo: , , , , etc. Pais Ubigeo Moneda Idioma Organizacion CorreoElectronicoCuenta

Para activar el almacenamiento en caché por consulta, se utilizan dos enfoques. Dependen de si el tipo de entidad consultado está anotado con el atributo. Si está anotado con el atributo, llame a la consulta, ya que solo se almacenan en caché las entidades sin seguimiento. EntidadCacheable AsNoTracking()

[EntidadCacheable]
public partial class Moneda : EntidadConAtributos, IAuditable, IEntidadLocalizada, IOrganizacionRestringida, IOrdenVisualizacion, IClonable<Moneda>
{
}

var todasMonedas = _db.Monedas.AsNoTracking().ToList();

Si el tipo de entidad consultado no está anotado con el atributo, llame para la consulta.

var consultaUsuario = _db.Usuarios
    .AsNoTracking()
    .ConCache()
    .Where(x => x.CorreoElectronico.EndsWith(".com"))

Para desactivar explícitamente el almacenamiento en caché por consulta, llame a la consulta. SinCache()

Las entidades rastreadas nunca se almacenan en caché, ni siquiera cuando se llama ConCache()

Proveedor de datos

Un ProveedorDatos abstrae y unifica los componentes internos de un sistema de base de datos compatible con Crono. Actúa como un adaptador para operaciones de base de datos de bajo nivel y proporciona una interfaz unificada para los diferentes sistemas de bases de datos.

Se puede acceder a la instancia actual de ProveedorDatos llamando a la propiedad de la instancia. Proporciona los siguientes miembros, entre otros: ProveedorDatos CronoDbContexto

Miembro

Descripción

RespaldoBaseDatos

Crea una copia de seguridad de la base de datos. Actualmente solo es compatible con SQLServer

Puede*

Comprueba si la base de datos admite una característica específica. por ejemplo devuelve si la base de datos puede transmitir campos BLOB de manera eficiente. PuedeAlmacenarSecuencia

CrearParametro()

Devuelve una instancia que es compatible con la base de datos. DbParameter

AdjuntarIdentificador()

Incluye el identificador dado entre comillas específicas del proveedor, por ejemplo, [Nombre] para MSSQL, 'Nombre' para MySQL.

EjecutarSqlScript()

Ejecuta un script SQL (multilínea) en una transacción atómica.

ObtenerTamanioBaseDatos()

Obtiene el tamaño total de la base de datos en bytes.

ObtenerIdentidadTabla<T>()

Obtiene el valor ident actual de la tabla dada.

TieneTabla()

Comprueba si la base de datos contiene la tabla dada.

InsertarEn()

Ejecuta el comando INSERT INTO SQL dado y devuelve el identificador de la fila insertada.

EsTransitorioException()

Comprueba si la excepción especificada representa un error transitorio que se puede compensar con un reintento.

AbrirSecuenciaBinaria()

Abre una secuencia BLOB para el descriptor de acceso de propiedad especificado.

RestaurarBaseDatos()

Restaura una copia de seguridad creada anteriormente. Actualmente solo es compatible con SQLServer y solo si la base de datos y el servidor web se encuentran en el mismo equipo.

EstablecerIdentidadTabla<T>()

Establece el valor ident de la tabla.

ReducirBaseDatos()

Encoge / comprime la base de datos.

Sql()

Normaliza el texto de un comando SQL determinado reemplazando los identificadores entre comillas en dialecto MSSQL por comillas específicas del proveedor. Por ejemplo: --> '''' (dialecto MySQL).SELECT [Id] FROM [Usuarios]SELECT Id FROM Usuarios

TruncarTabla<T>()

Trunca/borra una tabla. ¡TODAS las filas se eliminarán irreversiblemente!

Convenciones y mejores prácticas

Datos relacionados con la carga ansiosa

La carga ansiosa es una característica de EF Core que permite cargar datos relacionados junto con los datos de la entidad principal en una sola consulta. Esto puede mejorar el rendimiento en comparación con la carga diferida, en la que los datos relacionados se cargan a petición, ya que se evitan realizar varios viajes de ida y vuelta a la base de datos para cada entidad relacionada.

Este es un ejemplo de cómo puede usar la carga diligente en EF Core 7:

var consulta = _db.CuentaPrestamos
    .AplicarFiltroFechaAuditoria(DateTime.UtcNow.AddMonths(-1))
    .Include(x => x.Cliente)
    .Where(x => x.EstadosActivos)

Encapsular consultas y predicados

La encapsulación de consultas y predicados LINQ en métodos de extensión proporciona varias ventajas: Where

Reutilización: puede reutilizar el mismo código en varias partes de la aplicación, lo que facilita su mantenimiento y reduce la probabilidad de errores.
Legibilidad mejorada: puede hacer que su código sea más legible y fácil de entender. Esto es especialmente cierto si se asignan nombres descriptivos a los métodos de extensión que encapsulan los predicados.
Mayor capacidad de mantenimiento: puede realizar cambios en los predicados en un solo lugar, en lugar de tener que cambiar el código en varios lugares de la aplicación. Esto puede facilitar el mantenimiento del código y reducir la probabilidad de que se introduzcan errores.
Mejor separación de preocupaciones: ayuda a separar la lógica de consulta del resto del código, lo que facilita su comprensión y mantenimiento.

Estos son algunos de los métodos de extensión de consulta integrados más utilizados en Crono:

GrillaComandoConsultaExtensiones -> AListaPaginada
UsuarioConsultaExtensiones -> IncluirRoles
IOrganizacionRestringidaConsultaExtensiones -> AplicarFiltroOrganizacion

Este es el aspecto que podría tener una clase de extensión de consulta personalizada:

public static partial class UsuarioConsultaExtensiones
{
  public static IQueryable<Usuario> AplicarFiltroIdentificador(this IQueryable<Usuario> consulta,
     string correoElectronico = null,
     string nombreUsuario = null,
     string numeroUsuario = null,
     bool coincidenciaExacta = false)
  {
      Guarda.NoNulo(consulta, nameof(consulta));

      if (correoElectronico.TieneValor())
      {
          consulta = coincidenciaExacta ? consulta.Where(c => c.CorreoElectronico == correoElectronico) : consulta.Where(c => c.CorreoElectronico.Contains(correoElectronico));
      }

      if (nombreUsuario.TieneValor())
      {
          consulta = coincidenciaExacta ? consulta.Where(c => c.NombreUsuario == nombreUsuario) : consulta.Where(c => c.NombreUsuario.Contains(nombreUsuario));
      }

      if (numeroUsuario.TieneValor())
      {

      }

      return consulta;
  }
}

Profundizar

Para obtener más información sobre el acceso a los datos en Crono, lea Acceso a datos (Avanzado)

PreviousInyección de dependencias NextDominio

Last updated 1 year ago