В инфраструктуре Entity используется много памяти
Вот изображение из профилирования памяти ANTS. Он видит, что в памяти хранится много объектов. Как я могу найти то, что я делаю неправильно?
![ANTS memory profiler]()
**UPDATE**
Вот мои классы репозитория:
public class Repository<T> : IRepository<T> where T : class, IDataEntity
{
ObjectContext _context;
IObjectSet<T> _objectSet;
readonly string _entitySetName;
readonly string[] _keyNames;
private ObjectContext Context
{
get
{
if (_context == null)
{
_context = GetCurrentUnitOfWork<EFUnitOfWork>().Context;
}
return _context;
}
}
private IObjectSet<T> ObjectSet
{
get
{
if (_objectSet == null)
{
_objectSet = this.Context.CreateObjectSet<T>();
}
return _objectSet;
}
}
public TUnitOfWork GetCurrentUnitOfWork<TUnitOfWork>() where TUnitOfWork : IUnitOfWork
{
return (TUnitOfWork)UnitOfWork.Current;
}
public virtual IEnumerable<T> GetQuery()
{
return ObjectSet;
}
public virtual IEnumerable<T> GetQuery(params Expression<Func<T, object>>[] includes)
{
return ObjectSet.IncludeMultiple(includes);
}
public virtual IEnumerable<T> GetQuery(
IEnumerable<Expression<Func<T, bool>>> filters,
Func<IQueryable<T>, IOrderedQueryable<T>> orderBy,
IEnumerable<Expression<Func<T, object>>> includes)
{
IQueryable<T> _query = ObjectSet;
if (filters != null)
{
foreach (var filter in filters)
{
_query = _query.Where(filter);
}
}
if (includes != null && includes.Count() > 0)
{
_query = _query.IncludeMultiple(includes.ToArray());
}
if (orderBy != null)
{
_query = orderBy(_query);
}
return _query;
}
public virtual IPaged<T> GetQuery(
IEnumerable<Expression<Func<T, bool>>> filters,
Func<IQueryable<T>, IOrderedQueryable<T>> orderBy,
int pageNumber, int pageSize,
IEnumerable<Expression<Func<T, object>>> includes)
{
IQueryable<T> _query = ObjectSet;
if (filters != null)
{
foreach (var filter in filters)
{
_query = _query.Where(filter);
}
}
if (orderBy != null)
{
_query = orderBy(_query);
}
IPaged<T> page = new Paged<T>(_query, pageNumber, pageSize, includes);
return page;
}
public virtual void Insert(T entity)
{
this.ObjectSet.AddObject(entity);
}
public virtual void Delete(T entity)
{
if (entity is ISoftDeletable)
{
((ISoftDeletable)entity).IsDeleted = true;
//Update(entity);
}
else
{
this.ObjectSet.DeleteObject(entity);
}
}
public virtual void Attach(T entity)
{
ObjectStateEntry entry = null;
if (this.Context.ObjectStateManager.TryGetObjectStateEntry(entity, out entry) == false)
{
this.ObjectSet.Attach(entity);
}
}
public virtual void Detach(T entity)
{
ObjectStateEntry entry = null;
if (this.Context.ObjectStateManager.TryGetObjectStateEntry(entity, out entry) == true)
{
this.ObjectSet.Detach(entity);
}
}
}
Теперь, если у меня есть класс A, который содержит записи из таблицы A, я также создаю класс:
public class ARepository:BaseRepository<A> {
// Implementation of A queries and specific db operations
}
Вот мой класс EFUnitOfWork:
public class EFUnitOfWork : IUnitOfWork, IDisposable
{
public ObjectContext Context { get; private set; }
public EFUnitOfWork(ObjectContext context)
{
Context = context;
context.ContextOptions.LazyLoadingEnabled = true;
}
public void Commit()
{
Context.SaveChanges();
}
public void Dispose()
{
if (Context != null)
{
Context.Dispose();
}
GC.SuppressFinalize(this);
}
}
И класс UnitOfWork:
public static class UnitOfWork
{
private const string HTTPCONTEXTKEY = "MyProj.Domain.Business.Repository.HttpContext.Key";
private static IUnitOfWorkFactory _unitOfWorkFactory;
private static readonly Hashtable _threads = new Hashtable();
public static void Commit()
{
IUnitOfWork unitOfWork = GetUnitOfWork();
if (unitOfWork != null)
{
unitOfWork.Commit();
}
}
public static IUnitOfWork Current
{
get
{
IUnitOfWork unitOfWork = GetUnitOfWork();
if (unitOfWork == null)
{
_unitOfWorkFactory = ObjectFactory.GetInstance<IUnitOfWorkFactory>();
unitOfWork = _unitOfWorkFactory.Create();
SaveUnitOfWork(unitOfWork);
}
return unitOfWork;
}
}
private static IUnitOfWork GetUnitOfWork()
{
if (HttpContext.Current != null)
{
if (HttpContext.Current.Items.Contains(HTTPCONTEXTKEY))
{
return (IUnitOfWork)HttpContext.Current.Items[HTTPCONTEXTKEY];
}
return null;
}
else
{
Thread thread = Thread.CurrentThread;
if (string.IsNullOrEmpty(thread.Name))
{
thread.Name = Guid.NewGuid().ToString();
return null;
}
else
{
lock (_threads.SyncRoot)
{
return (IUnitOfWork)_threads[Thread.CurrentThread.Name];
}
}
}
}
private static void SaveUnitOfWork(IUnitOfWork unitOfWork)
{
if (HttpContext.Current != null)
{
HttpContext.Current.Items[HTTPCONTEXTKEY] = unitOfWork;
}
else
{
lock(_threads.SyncRoot)
{
_threads[Thread.CurrentThread.Name] = unitOfWork;
}
}
}
}
Вот как я это использую:
public class TaskPriceRepository : BaseRepository<TaskPrice>
{
public void Set(TaskPrice entity)
{
TaskPrice taskPrice = GetQuery().SingleOrDefault(x => x.TaskId == entity.TaskId);
if (taskPrice != null)
{
CommonUtils.CopyObject<TaskPrice>(entity, ref taskPrice);
}
else
{
this.Insert(entity);
}
}
}
public class BranchRepository : BaseRepository<Branch>
{
public IList<Branch> GetBranchesList(Guid companyId, long? branchId, string branchName)
{
return Repository.GetQuery().
Where(b => companyId == b.CompanyId).
Where(b => b.IsDeleted == false).
Where(b => !branchId.HasValue || b.BranchId.Equals(branchId.Value)).
Where(b => branchName == null || b.BranchName.Contains(branchName)).
ToList();
}
}
[WebMethod]
public void SetTaskPrice(TaskPriceDTO taskPrice)
{
TaskPrice tp = taskPrice.ToEntity();
TaskPriceRepository rep = new TaskPriceRepository();
rep.Set(tp);
UnitOfWork.Commit();
}
[WebMethod]
public IList<Branch> GetBranchesList()
{
BranchRepository rep = new BranchRepository();
return rep.GetBranchesList(m_User.UserCompany.CompanyId, null, null).ToList();
}
Надеюсь, этого достаточно, чтобы помочь мне решить проблему. Спасибо.
UPDATE 2
Существует также UnitOfWorkFactory, который инициализирует UnitOfWork:
public class UnitOfWorkFactory : IUnitOfWorkFactory
{
private static Func<ObjectContext> _objectContextDelegate;
private static readonly Object _lockObject = new object();
public static void SetObjectContext(Func<ObjectContext> objectContextDelegate)
{
_objectContextDelegate = objectContextDelegate;
}
public IUnitOfWork Create()
{
ObjectContext context;
lock (_lockObject)
{
context = _objectContextDelegate();
}
return new EFUnitOfWork(context);
}
}
Чтобы использовать это, при запуске приложения я использую map структуры:
ObjectFactory.Initialize(x =>
{
x.For<IUnitOfWorkFactory>().Use<UnitOfWorkFactory>();
x.For(typeof(IRepository<>)).Use(typeof(Repository<>));
});
Ответы
Ответ 1
У меня есть подозрение, что вы не распоряжаетесь контекстом.
Я предлагаю использовать контекст, когда вы взаимодействовали с базой данных.
Используйте инструкцию using
всякий раз, когда вы создаете контекст.
[изменить]
Насколько я вижу, вы кешируете и не уничтожаете свой объект EFUnitOfWork
. Это одноразово, это правильно, но я не вижу, когда называется одноразовое. Похоже, вы держите ссылку на контекст для всего времени выполнения приложения.
Кроме того, вы создаете и сохраняете один контекст для потока, что сделает его еще хуже.
Я не могу точно сказать вам, где вы должны положить Dispose
или using
, так как я не знаю обычаев.
Вероятно, вы могли бы поместить его в свой метод Commit
, но я не знаю, вызвал ли вызов Commit
только один раз во время сеанса взаимодействия с базой данных.
Кроме того, ваш дизайн может быть слишком сложным.
Если бы я был вами, я бы:
- Найдите способ утилизации контекста с использованием текущего кода в качестве краткосрочного решения
- Упростите дизайн, как долгосрочное решение
Если бы у меня было время, я бы сделал долгосрочное решение сразу.
Но опять же, я не могу сказать, оправдана ли сложность вашего дизайна, поскольку я не знаю, насколько велика ваша заявка и что она делает, и каковы требования.
Ответ 2
Несколько вещей приходят мне на ум:
- Вы, вероятно, не избавляетесь от ObjectContext. Убедитесь, что все коды вашей базы данных находятся внутри блока
using(var context = CreateObjectContext())
- У вас есть N-уровневая архитектура, и вы передаете сущности с уровня доступа к данным на верхний уровень, не отрывая сущности от ObjectContext. Вам нужно вызвать ObjectContext.Detach(...)
- Скорее всего, вы возвращаете полную коллекцию сущностей, а не возвращаете один объект для отдельных операций Get. Например, у вас есть запросы, например,
from customer in context.Customers select customer
а не from customer in context.Customers select customer.FirstOrDefault()
Мне было трудно заставить Entity Framework работать в N-уровневом приложении. Он просто не подходит для использования в приложениях N-уровня как есть. Только EF 4.0 есть. Вы можете прочитать обо всех моих приключениях по созданию EF 3 в приложении N-уровня.
http://www.codeproject.com/KB/linq/ef.aspx
Отвечает ли это на ваш вопрос?
Ответ 3
Вы очищаете ObjectContext
один раз в то время. Если вы сохраняете ObjectContext
живым в течение длительного времени, это будет потреблять память, связанную с размером EntityDataModel и количеством объектов, загруженных в этот ObjectContext
.
Ответ 4
У меня была такая же проблема в классе, который использует внедрение зависимостей, поэтому опция using()
не была альтернативой. Мое решение состояло в том, чтобы добавить DbContextOptions<Context>
в конструктор и в качестве частного поля для класса. Затем вы можете позвонить
_db.Dispose();
_db = new BlockExplorerContext(_dBContextOptions);
в подходящее время. Это исправило мою проблему, когда у меня не хватало оперативной памяти, а приложение было убито ОС.