延迟加载

Question

我有这样一个实体：

public class Doctor : User 
{ 
    public Doctor(string userName, string firstName, string lastName, 
     string mobileNumber, string email, Sexes sex, Role myRole, DoctorExpertises expertise) 
     : base(userName, firstName, lastName, mobileNumber, email, sex, myRole) 
    { 
     this.Expertise = expertise; 
     this.Results = new List<Result>(); 
    } 

    private Doctor() 
    { 
     this.Results = new List<Result>(); 
    } 

    public void AddResult(Result result) 
    { 
     this.Results.Add(result); 
    } 

    public DoctorExpertises Expertise { get; private set; } 

    private ICollection<Result> results; 

    public virtual ICollection<Result> Results 
    { 
     get { return results; } 
     private set { results = value; } 
    } 
} 

，我有典型的资源库，如：

public abstract class RepositoryBase<T> where T : class 
    { 
     private DbContext dataContext; 
     protected readonly IDbSet<T> dbset; 

     protected RepositoryBase(IDatabaseFactory databaseFactory) 
     { 
      DatabaseFactory = databaseFactory; 
      dbset = DataContext.Set<T>(); 
     } 

     protected IDatabaseFactory DatabaseFactory 
     { 
      get; 
      private set; 
     } 

     protected DbContext DataContext 
     { 
      get { return dataContext ?? (dataContext = DatabaseFactory.Get()); } 
     } 
     public virtual void Add(T entity) 
     { 
      dbset.Add(entity); 
     } 
     public virtual void Update(T entity) 
     { 
      dbset.Attach(entity); 
      dataContext.Entry(entity).State = EntityState.Modified; 
     } 
     public virtual void Delete(T entity) 
     { 
      dbset.Remove(entity); 
     } 
     public virtual void Delete(Expression<Func<T, bool>> where) 
     { 
      IEnumerable<T> objects = dbset.Where<T>(where).AsEnumerable(); 
      foreach (T obj in objects) 
       dbset.Remove(obj); 
     } 
     public virtual T GetById(long id) 
     { 
      return dbset.Find(id); 
     } 
     public virtual T GetById(string id) 
     { 
      return dbset.Find(id); 
     } 
     public virtual IEnumerable<T> GetAll() 
     { 
      return dbset.ToList(); 
     } 
     public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where) 
     { 
      return dbset.Where(where).ToList(); 
     } 
     public T Get(Expression<Func<T, bool>> where) 
     { 
      return dbset.Where(where).FirstOrDefault<T>(); 
     } 
} 

，我想偷懒负荷医生用下面的测试结果之一代码：

[TestMethod] 
public void TestShouldLoadPropertyIfLazyLoaded() 
{ 
    // Act 
    Doctor doctor = this.userRepository.Get(u => u.UserName == "soroosh") as Doctor; 
    Result result = doctor.Results.FirstOrDefault(); 

    // Asserts 
    Assert.IsNotNull(doctor); 
    Assert.IsNotNull(result); 
} 

不幸的是，它不能正常工作医生不为空，但结果为空。

如果我使用include方法加载正确，它会正确加载，但我希望使用延迟加载。

我看过this question以及其他类似的问题，但其中没有一个是没用的，因为它们都使用急切的加载来解决问题。急于加载不适合我们，因为在我的main problem似乎急于加载是不可能的。

我该怎么办？

Answer 1

这应该只是工作，包括我自己在内的人每天都会这样做，并且工作。我看到了两个可能的罪魁祸首：

• 该工厂的DbContext可能可能创造一个懒加载被禁用
• 您记录setter方法需要一个背景是私人的，生成的代理实体可能只是不妥善处理。只需将其改为公开。

检查两个，重点在第二个。

Answer 2

我认为，如果你完整地定义你真的不需要担心这个你总边界 - 你可以总是加载实体时执行域操作，因为你的关系不应该越过边界总热切加载。因此，您的存储库只能加载和保存给定类型的单个聚合，以便可以调用该聚合上的行为。

不要误解我的意思，你可能仍然想查询你的数据库把数据放在UI等等上，但是你可以使用一个简单的工具，比如Linq到SQL，Dapper等，直接从数据库中取出数据DB进入用户界面，跳过所有的ORM eager/lazy加载废话。