C#, Entity Framework: Comment puis-je combiner un .Trouver et .Inclure sur un Objet de Modèle?

Dennis réponse est à l'aide de Include et SingleOrDefault. Ce dernier va en aller-retour à 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 MSDN exemple:

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, Find retourne immédiatement sans faire une demande à la banque, si l'entité est déjà chargé par le contexte.

Il n'y a pas de véritable moyen facile de filtrer avec une. Mais je suis venu avec une proximité façon à reproduire la fonctionnalité, mais veuillez prendre note de quelques choses pour ma solution.

Ces Solutions vous permet de filtrer de manière générique, sans knowning la clé primaire dans la .net-de base

1. Trouver est fondamentalement différente parce qu'il obtient de 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 de sorte que l'utilisateur n'a pas à connaître la clé primaire.

3. Cette solution est pour EntityFramework de Base.

4. Cela nécessite l'accès au contexte

Voici quelques méthodes d'extension pour ajouter ce qui vous aidera à filtrer par la clé primaire de sorte

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