由于实体框架（连接到数据库），CPU使用率上升

Question

我有网站（2 core-6gb ram），对于发送到服务器cpu的每个请求开始上升，当请求得到答复时cpu正常

我在简单的控制台应用程序中进行了测试，然后又发生了

我发现这是因为存在实体框架（add-update-delete-find，..），所以我该怎么办？ 我没事做...

这是我的存储库示例：

public class FactorRepository : IDisposable
{
    private DomainModels.AppEntities _dbDnt = null;

    public FactorRepository()
    {
        _dbDnt = new DomainModels.AppEntities();
    }
    public bool Add(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            _dbDnt.Factors.Add(entity);
            if (autoSave)
                return Convert.ToBoolean(_dbDnt.SaveChanges());
            else
                return false;
        }
        catch
        {
            return false;
        }
    }

    public bool Update(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            _dbDnt.Factors.Attach(entity);
            _dbDnt.Entry(entity).State = EntityState.Modified;
            if (autoSave)
                return Convert.ToBoolean(_dbDnt.SaveChanges());
            else
                return false;
        }
        catch
        {
            return false;
        }
    }

    public bool Delete(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            _dbDnt.Entry(entity).State = EntityState.Deleted;
            if (autoSave)
                return Convert.ToBoolean(_dbDnt.SaveChanges());
            else
                return false;
        }
        catch
        {
            return false;
        }
    }

    public bool Delete(long id, bool autoSave = true)
    {
        try
        {
            var entity = _dbDnt.Factors.Find(id);
            _dbDnt.Entry(entity).State = EntityState.Deleted;
            if (autoSave)
                return Convert.ToBoolean(_dbDnt.SaveChanges());
            else
                return false;
        }
        catch
        {
            return false;
        }
    }

    public DomainModels.Factor Find(long id)
    {
        try
        {
            return _dbDnt.Factors.Find(id);
        }
        catch
        {
            return null;
        }
    }

    public List<DomainModels.Factor> Where(Expression<Func<DomainModels.Factor, bool>> predicate)
    {
        try
        {
            return _dbDnt.Factors.Where(predicate).ToList();
        }
        catch
        {
            return null;
        }
    }

    public List<DomainModels.Factor> Select()
    {
        try
        {
            return _dbDnt.Factors.AsQueryable().ToList();
        }
        catch
        {
            return null;
        }
    }

    public List<TResult> Select<TResult>(Expression<Func<DomainModels.Factor, TResult>> selector)
    {
        try
        {
            return _dbDnt.Factors.Select(selector).ToList();
        }
        catch
        {
            return null;
        }
    }

    public long GetLastIdentity()
    {
        try
        {
            if (_dbDnt.Factors.Any())
                return _dbDnt.Factors.OrderByDescending(p => p.Id).First().Id;
            else
                return 0;
        }
        catch
        {
            return -1;
        }
    }

    public long Save()
    {
        try
        {
            return _dbDnt.SaveChanges();
        }
        catch
        {
            return -1;
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (this._dbDnt != null)
            {
                this._dbDnt.Dispose();
                this._dbDnt = null;
            }
        }
    }

    ~FactorRepository()
    {
        Dispose(false);
    }

更新 ：即使当我使用此类作为存储库问题仍然存在时

    public class FactorRepository 
{
    public bool Add(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                database.Factors.Add(entity);
                if (autoSave)
                    return Convert.ToBoolean(database.SaveChanges());
                else
                    return false;
            }
        }
        catch
        {
            return false;
        }
    }

    public bool Update(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                database.Factors.Attach(entity);
                database.Entry(entity).State = EntityState.Modified;
                if (autoSave)
                    return Convert.ToBoolean(database.SaveChanges());
                else
                    return false;
            }
        }
        catch
        {
            return false;
        }
    }

    public bool Delete(DomainModels.Factor entity, bool autoSave = true)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                database.Entry(entity).State = EntityState.Deleted;
                if (autoSave)
                    return Convert.ToBoolean(database.SaveChanges());
                else
                    return false;
            }
        }
        catch
        {
            return false;
        }
    }

    public bool Delete(int id, bool autoSave = true)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                var entity = database.Factors.Find(id);
                database.Entry(entity).State = EntityState.Deleted;
                if (autoSave)
                    return Convert.ToBoolean(database.SaveChanges());
                else
                    return false;
            }
        }
        catch
        {
            return false;
        }
    }

    public DomainModels.Factor Find(long id)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                return database.Factors.Find(id);
            }
        }
        catch
        {
            return null;
        }
    }

    public DomainModels.Factor Find(string username)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                return database.Factors.Find(username);
            }
        }
        catch
        {
            return null;
        }
    }
    public List<DomainModels.Factor> Where(Expression<Func<DomainModels.Factor, bool>> predicate)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                return database.Factors.Where(predicate).ToList();
            }
        }
        catch
        {
            return null;
        }
    }

    public List<DomainModels.Factor> Select()
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                return database.Factors.AsQueryable().ToList();
            }
        }
        catch
        {
            return null;
        }
    }

    public List<TResult> Select<TResult>(Expression<Func<DomainModels.Factor, TResult>> selector)
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                return database.Factors.Select(selector).ToList();
            }
        }
        catch
        {
            return null;
        }
    }

    public long GetLastIdentity()
    {
        try
        {
            using (AppEntities database = new AppEntities())
            {
                if (database.Factors.Any())
                    return database.Factors.OrderByDescending(p => p.Id).First().Id;
                else
                    return 0;
            }

        }
        catch
        {
            return -1;
        }
    }
}

更新 ：用法

FactorRepository blFact = new FactorRepository();

var model1 = blFact.Where(p => p.UserId == userid).SingleOrDefault();

Answer 1

查找性能问题有点困难，但是我认为在您的情况下，实体框架的查询编译阶段是一个问题。 您可以使用Windows系统和PerfView（或任何其他内存分析器）中的性能监视器工具非常快速地对其进行验证。

打开一个性能监视器，然后在您的进程中添加以下计数器：.NET CLR内存（GC中的％时间和已分配的字节/秒）。 如果您有很多分配，或者您在GC中的时间超过了10，那么我们将更接近地确定错误是否在查询编译阶段。 现在执行PerfView监视您的内存使用情况。 如果结果中您注意到来自实体框架名称空间的大量分配，那么是的，这是查询编译阶段。

我有一个类似的问题，您可以在这里看看： 实体框架6.1.3插入，更新操作的CPU使用率很高

此外，我写了一篇有关查询编译阶段和阅读方面的问题的博客文章： http : //devmate.net/2017/10/entity-framework-the-query-plan-cache-story/ 。 也许对您也很方便。