Question

我在EF中遇到了一件有趣的事情。如果我们使用基本实体获取子实体，则加载实体会花费更多时间。我的模型如下：

public abstract class BaseDocument
{
    public Guid Id { get; set; }
    public string Name { get; set; }
}

public abstract class ComplexDocument : BaseDocument
{
    public string AuthorName { get; set; }
}

public abstract class SimpleDocument : BaseDocument
{
    public int Level { get; set; }
}

public abstract class OfficeDocument : ComplexDocument
{
    public string OfficeName { get; set; }
}

public abstract class ClassDocument : SimpleDocument
{
    public string HeadName { get; set; }
}

public class WordDocument : OfficeDocument
{
    public int PagesCount { get; set; }
}

public class ExcelDocument : OfficeDocument
{
    public int SheetsCount { get; set; }
}

public class TextDocument : ClassDocument
{
    public int LinesCount { get; set; }
}

我正在使用 TPT 方法。这是继承树这是我的上下文类：

public class Context : DbContext
{
    public Context() : base(@"Server=(localdb)\MSSQLLocalDB;Database=EFSIX;Trusted_Connection=True;")
    {
        Database.CreateIfNotExists();
    }
    public DbSet<BaseDocument> BaseDocuments { get; set; }
    public DbSet<ComplexDocument> ComplexDocuments { get; set; }
    public DbSet<SimpleDocument> SimpleDocuments { get; set; }
    public DbSet<OfficeDocument> OfficeDocuments { get; set; }
    public DbSet<ClassDocument> ClassDocuments { get; set; }
    public DbSet<ExcelDocument> ExcelDocuments { get; set; }
    public DbSet<WordDocument> WordDocuments { get; set; }
    public DbSet<TextDocument> TextDocuments { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
       modelBuilder.Entity<BaseDocument>().ToTable("BaseDocuments");
       modelBuilder.Entity<ComplexDocument>().ToTable("ComplexDocuments");
       modelBuilder.Entity<SimpleDocument>().ToTable("SimpleDocuments");
       modelBuilder.Entity<OfficeDocument>().ToTable("OfficeDocuments");
       modelBuilder.Entity<ExcelDocument>().ToTable("ExcelDocuments");
       modelBuilder.Entity<WordDocument>().ToTable("WordDocuments");
       modelBuilder.Entity<ClassDocument>().ToTable("ClassDocuments");
       modelBuilder.Entity<TextDocument>().ToTable("TextDocuments");
    }
    public IQueryable<T> GetEntities<T>() where T : class
    {
        return Set<T>();
    }
}

我正在创建一些数据：

static void CreateTestData()
    {
        using (Context context = new Context())
        {
            for (int i = 0; i < 20; i++)
            {
                ExcelDocument excel = new ExcelDocument()
                {
                    Id = Guid.NewGuid(),
                    AuthorName = $"ExcelAuthor{i}",
                    Name = $"Excel{i}",
                    OfficeName = $"ExcelOffice{i}",
                    SheetsCount = (i + 1) * 10
                };
                context.ExcelDocuments.Add(excel);

                WordDocument word = new WordDocument()
                {
                    Id = Guid.NewGuid(),
                    AuthorName = $"WordAuthor{i}",
                    Name = $"Word{i}",
                    OfficeName = $"WordOffice{i}",
                    PagesCount = (i + 2) * 10
                };
                context.WordDocuments.Add(word);

                TextDocument text = new TextDocument()
                {
                    Id = Guid.NewGuid(),
                    Name = $"Text{i}",
                    LinesCount = (i + 3) * 10,
                    HeadName = $"Head{i}",
                    Level = i + 5
                };
                context.TextDocuments.Add(text);
            }
            context.SaveChanges();
        }
    }

我做了两种方法从数据库获取WordDocument。其中一个使用BaseDocument，另一个使用WordDocument。两者都返回WordDocument的20个实例：

 static long ReadBaseDoc()
    {
        using (Context context = new Context())
        {
            var words= context.GetEntities<BaseDocument>().Where(e => e.Name.StartsWith("Word"));
            Stopwatch stopwatch = Stopwatch.StartNew();
            var instacnes = excel.ToList();
            stopwatch.Stop();
            return stopwatch.ElapsedMilliseconds;
        }
    }
    static long ReadWordDoc()
    {
        using (Context context = new Context())
        {
            var words = context.GetEntities<WordDocument>().Where(e => e.Name.StartsWith("Word"));
            Stopwatch stopwatch = Stopwatch.StartNew();
            var instacnes = words.ToList();
            stopwatch.Stop();
            return stopwatch.ElapsedMilliseconds;
        }
    }

我分别对飞蛾方法进行了几次测试，平均方法ReadWordDoc花费25毫秒，方法ReadBaseDoc花费52毫秒（实例相同）。现在这不是什么大问题，但是当我们拥有复杂的继承时，它需要超过1秒的时间。我创建了10个类，并继承自BaseDocument。之后，我执行了ReadBaseDoc和ReadWordDoc方法。 ReadWordDoc花费了25毫秒，而ReadBaseDoc花费了1023毫秒。实例相同，为什么ReadBaseDoc需要更多时间？避免EF中此类问题的更好方法是什么？

Answer 1

看看here。有多种方法可以使EF更快，但是在那些复杂的情况下，ORM只会带来更多无法解决的问题。

您的情况之一是尝试将继承更改为TablePerType，也许会更快一些。

其他方法是找到速度较慢的请求并为其使用Dapper-这样会更快。

最后一种方法是使用实时缓存创建一个存储库，将整个数据库加载到内存中并保持最新状态-这应该是应用程序中的一个实例。如果您有多个使用同一数据库的应用，则需要连接数据更改触发器。

通常，对于像您这样的缓慢（且相对简单）的查询，我会说使用Dapper + AutoMapper。保持EF，以便您的数据库与您的类保持同步，但不要依赖它进行查询。

如果您真的想坚持使用ORM，我认为您需要切换nHibernate。自己还没有尝试过，但是从我阅读的内容来看，它几乎在所有可能的方面都非常出色，包括性能和启动时间。

载入实体实例需要超过1秒

1 个答案: