C # Entity-Framework: Comment puis-je combiner un .Find et .Include sur un objet de modèle?

Je fais le didacticiel de pratique mvcmusicstore. J'ai remarqué quelque chose lors de la création de l'échafaudage pour le gestionnaire d'albums (ajouter supprimer modifier).

Je veux écrire du code avec élégance, donc je cherche la manière propre d'écrire ceci.

Pour info, je rends le magasin plus générique:

Albums = éléments

Genres = Catégories

Artiste = Marque

Voici comment l'index est récupéré (généré par MVC):

var items = db.Items.Include(i => i.Category).Include(i => i.Brand);

Voici comment l'élément à supprimer est récupéré:

Item item = db.Items.Find(id);

Le premier ramène tous les articles et remplit les modèles de catégorie et de marque à l'intérieur du modèle d'article. Le second ne remplit pas la catégorie et la marque.

Comment puis-je écrire le second pour faire la recherche ET remplir ce qu'il y a à l'intérieur (de préférence en 1 ligne) ... théoriquement - quelque chose comme:

Item item = db.Items.Find(id).Include(i => i.Category).Include(i => i.Brand);

Vous devez d' Include()abord utiliser , puis récupérer un seul objet de la requête résultante:

Item item = db.Items
              .Include(i => i.Category)
              .Include(i => i.Brand)
              .SingleOrDefault(x => x.ItemId == id);

La réponse de Dennis utilise Includeet SingleOrDefault. Ce dernier fait un aller-retour vers la base de données.

Une alternative, est d'utiliser Find, en combinaison avec Load, pour le chargement explicite des entités liées ...

Ci-dessous un exemple MSDN :

using (var context = new BloggingContext()) 
{ 
  var post = context.Posts.Find(2); 

  // Load the blog related to a given post 
  context.Entry(post).Reference(p => p.Blog).Load(); 

  // Load the blog related to a given post using a string  
  context.Entry(post).Reference("Blog").Load(); 

  var blog = context.Blogs.Find(1); 

  // Load the posts related to a given blog 
  context.Entry(blog).Collection(p => p.Posts).Load(); 

  // Load the posts related to a given blog  
  // using a string to specify the relationship 
  context.Entry(blog).Collection("Posts").Load(); 
}

Bien sûr, Findretourne immédiatement sans faire de requête au magasin, si cette entité est déjà chargée par le contexte.

Vous devez convertir IQueryable en DbSet

var dbSet = (DbSet<Item>) db.Set<Item>().Include("");

return dbSet.Find(id);

Cela n'a pas fonctionné pour moi. Mais je l'ai résolu en faisant comme ça.

var item = db.Items
             .Include(i => i.Category)
             .Include(i => i.Brand)
             .Where(x => x.ItemId == id)
             .First();

Je ne sais pas si c'est une bonne solution. Mais l'autre que Dennis m'a donné m'a donné une erreur booléenne .SingleOrDefault(x => x.ItemId = id);

Il n'y a pas de moyen vraiment simple de filtrer avec une trouvaille. Mais j'ai trouvé un moyen rapproché de répliquer la fonctionnalité, mais veuillez prendre note de quelques éléments pour ma solution.

Cette solution vous permet de filtrer de manière générique sans connaître la clé primaire dans .net-core

1. Find est fondamentalement différent car il obtient l'entité si elle est présente dans le suivi avant d'interroger la base de données.

2. En outre, il peut filtrer par un objet afin que l'utilisateur n'ait pas à connaître la clé primaire.

3. Cette solution est pour EntityFramework Core.

4. Cela nécessite un accès au contexte

Voici quelques méthodes d'extension à ajouter qui vous aideront à filtrer par clé primaire afin

    public static IReadOnlyList<IProperty> GetPrimaryKeyProperties<T>(this DbContext dbContext)
    {
        return dbContext.Model.FindEntityType(typeof(T)).FindPrimaryKey().Properties;
    }

    //TODO Precompile expression so this doesn't happen everytime
    public static Expression<Func<T, bool>> FilterByPrimaryKeyPredicate<T>(this DbContext dbContext, object[] id)
    {
        var keyProperties = dbContext.GetPrimaryKeyProperties<T>();
        var parameter = Expression.Parameter(typeof(T), "e");
        var body = keyProperties
            // e => e.PK[i] == id[i]
            .Select((p, i) => Expression.Equal(
                Expression.Property(parameter, p.Name),
                Expression.Convert(
                    Expression.PropertyOrField(Expression.Constant(new { id = id[i] }), "id"),
                    p.ClrType)))
            .Aggregate(Expression.AndAlso);
        return Expression.Lambda<Func<T, bool>>(body, parameter);
    }

    public static Expression<Func<T, object[]>> GetPrimaryKeyExpression<T>(this DbContext context)
    {
        var keyProperties = context.GetPrimaryKeyProperties<T>();
        var parameter = Expression.Parameter(typeof(T), "e");
        var keyPropertyAccessExpression = keyProperties.Select((p, i) => Expression.Convert(Expression.Property(parameter, p.Name), typeof(object))).ToArray();
        var selectPrimaryKeyExpressionBody = Expression.NewArrayInit(typeof(object), keyPropertyAccessExpression);

        return Expression.Lambda<Func<T, object[]>>(selectPrimaryKeyExpressionBody, parameter);
    }

    public static IQueryable<TEntity> FilterByPrimaryKey<TEntity>(this DbSet<TEntity> dbSet, DbContext context, object[] id)
        where TEntity : class
    {
        return FilterByPrimaryKey(dbSet.AsQueryable(), context, id);
    }

    public static IQueryable<TEntity> FilterByPrimaryKey<TEntity>(this IQueryable<TEntity> queryable, DbContext context, object[] id)
        where TEntity : class
    {
        return queryable.Where(context.FilterByPrimaryKeyPredicate<TEntity>(id));
    }

Une fois que vous avez ces méthodes d'extension, vous pouvez filtrer comme suit:

query.FilterByPrimaryKey(this._context, id);