Comment charger avec impatience des entités profondément imbriquées dans Entity Framework Core ?

Chargement hâtif d'entités profondément imbriquées dans Entity Framework Core

Contexte

Le chargement hâtif dans Entity Framework Core (EF Core) est une technique de pré- récupérer les entités associées avec l'entité principale, pour éviter plusieurs requêtes de base de données. Cependant, dans certains scénarios, vous pouvez rencontrer des limitations lorsque vous essayez de charger des entités profondément imbriquées.

Le problème

Considérez le scénario suivant :

public class Order
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int CustomerId { get; set; }
    public Customer Customer { get; set; }
}

public class Customer
{
    public int Id { get; set; } 
    public string Name { get; set; }
    public int AddressId { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public int Id { get; set; }
    public string PostCode { get; set; }
    public string City { get; set; }
}

Lorsque vous essayez pour charger une commande avec Include(nameof(Customer)).ThenInclude(nameof(Address)), vous remarquerez peut-être que la propriété Address de l'entité Customer est nulle. Cela se produit car EF Core ne prend pas en charge le chargement rapide de toutes les entités associées imbriquées par défaut.

Solution proposée

Malheureusement, il n'existe actuellement aucune prise en charge officielle pour le chargement rapide de toutes les entités profondément imbriquées dans EF Core. . Cependant, il existe deux méthodes d'extension personnalisées que vous pouvez utiliser pour y parvenir :

Inclure l'extension :

public static IQueryable<T> Include<T>(this IQueryable<T> source, IEnumerable<string> navigationPropertyPaths)
    where T : class
{
    return navigationPropertyPaths.Aggregate(source, (query, path) => query.Include(path));
}

GetIncludePaths Extension :

public static IEnumerable<string> GetIncludePaths(this DbContext context, Type clrEntityType, int maxDepth = int.MaxValue)
{
    ...
}

Exemple d'utilisation

Dans votre référentiel générique, vous pouvez modifier le GetAllAsync comme suit :

public virtual async Task<IEnumerable<T>> GetAllAsync(Expression<Func<T, bool>> predicate = null)
{
    var query = Context.Set<T>()
        .Include(Context.GetIncludePaths(typeof(T));
    if (predicate != null)
        query = query.Where(predicate);
    return await query.ToListAsync();
}

En utilisant ces méthodes d'extension, vous pouvez charger avec impatience toutes les entités associées imbriquées pour le type spécifié.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!