В инфраструктуре 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);

в подходящее время. Это исправило мою проблему, когда у меня не хватало оперативной памяти, а приложение было убито ОС.