C # Entity-Framework: Jak mogę połączyć .Find i .Include na obiekcie modelu?

Robię samouczek praktyczny mvcmusicstore. Zauważyłem coś podczas tworzenia rusztowania dla menedżera albumów (dodaj usuń edycję).

Chcę pisać kod elegancko, więc szukam przejrzystego sposobu, aby to napisać.

FYI, sprawiam, że sklep jest bardziej ogólny:

Albumy = elementy

Gatunki = Kategorie

Artysta = marka

Oto jak indeks jest pobierany (generowany przez MVC):

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

Oto jak jest pobierany element do usunięcia:

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

Pierwsza z nich przywraca wszystkie elementy i zapełnia modele kategorii i marki w modelu przedmiotu. Drugi nie wypełnia kategorii i marki.

Jak mogę napisać drugą, aby znaleźć i zapełnić to, co jest w środku (najlepiej w 1 linii) ... teoretycznie - coś takiego:

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

Musisz Include()najpierw użyć , a następnie pobrać pojedynczy obiekt z wynikowego zapytania:

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

Odpowiedź Dennisa to użycie Includei SingleOrDefault. Ten ostatni przechodzi w obie strony do bazy danych.

Alternatywą jest użycie Find, w połączeniu z Load, do jawnego ładowania powiązanych jednostek ...

Poniżej przykład 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(); 
}

Oczywiście Findwraca natychmiast bez składania zapytania do sklepu, jeśli ten podmiot jest już załadowany przez kontekst.

Musisz rzucić IQueryable na DbSet

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

return dbSet.Find(id);

Nie działa dla mnie. Ale rozwiązałem to w ten sposób.

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

Nie wiem, czy to dobre rozwiązanie. Ale drugi, podany przez Dennisa, dał mi błąd bool .SingleOrDefault(x => x.ItemId = id);

Nie ma naprawdę łatwego sposobu na filtrowanie za pomocą znalezienia. Ale wymyśliłem bliski sposób na odtworzenie funkcjonalności, ale proszę zwrócić uwagę na kilka rzeczy dotyczących mojego rozwiązania.

To rozwiązanie umożliwia filtrowanie ogólne bez znajomości klucza podstawowego w .net-core

1. Funkcja Find różni się zasadniczo, ponieważ uzyskuje jednostkę, jeśli jest ona obecna w śledzeniu przed wysłaniem zapytania do bazy danych.

2. Dodatkowo może filtrować według obiektu, dzięki czemu użytkownik nie musi znać klucza podstawowego.

3. To rozwiązanie jest przeznaczone dla EntityFramework Core.

4. Wymaga to dostępu do kontekstu

Oto kilka metod rozszerzenia do dodania, które pomogą Ci filtrować według klucza podstawowego

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

Gdy masz już te metody rozszerzenia, możesz filtrować w ten sposób:

query.FilterByPrimaryKey(this._context, id);