C # Entity-Framework: ¿Cómo puedo combinar .Find e .Include en un objeto modelo?

Estoy haciendo el tutorial de práctica mvcmusicstore. Noté algo al crear el andamio para el administrador de álbumes (agregar, eliminar, editar).

Quiero escribir código con elegancia, así que estoy buscando la forma limpia de escribir esto.

FYI estoy haciendo la tienda más genérica:

Álbumes = Artículos

Géneros = Categorías

Artista = Marca

Así es como se recupera el índice (generado por MVC):

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

Así es como se recupera el elemento para eliminar:

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

El primero recupera todos los artículos y completa la categoría y los modelos de marca dentro del modelo de artículo. El segundo, no llena la categoría y la marca.

¿Cómo puedo escribir el segundo para hacer la búsqueda Y llenar lo que hay dentro (preferiblemente en 1 línea) ... en teoría, algo como:

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

Include()Primero debe usar , luego recuperar un solo objeto de la consulta resultante:

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

La respuesta de Dennis es usar Includey SingleOrDefault. Este último va de ida y vuelta a la base de datos.

Una alternativa es usar Find, en combinación con Load, para la carga explícita de entidades relacionadas ...

Debajo de un ejemplo de 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(); 
}

Por supuesto, Findregresa inmediatamente sin hacer una solicitud a la tienda, si esa entidad ya está cargada por el contexto.

Tienes que lanzar IQueryable a DbSet

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

return dbSet.Find(id);

No funcionó para mí. Pero lo resolví haciendo así.

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

No sé si esa es una buena solución. Pero el otro que Dennis me dio me dio un error de bool en .SingleOrDefault(x => x.ItemId = id);

No hay una manera fácil de filtrar con un hallazgo. Pero he encontrado una forma cercana de replicar la funcionalidad, pero tenga en cuenta algunas cosas para mi solución.

Esta solución le permite filtrar genéricamente sin conocer la clave principal en .net-core

1. Buscar es fundamentalmente diferente porque obtiene la entidad si está presente en el seguimiento antes de consultar la base de datos.

2. Además, puede filtrar por un Objeto para que el usuario no tenga que conocer la clave principal.

3. Esta solución es para EntityFramework Core.

4. Esto requiere acceso al contexto

Aquí hay algunos métodos de extensión para agregar que lo ayudarán a filtrar por clave primaria

    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));
    }

Una vez que tenga estos métodos de extensión, puede filtrar así:

query.FilterByPrimaryKey(this._context, id);