Asp.net mvc 在控制器内正确处理存储库对象

我很难弄明白这一点。我已经实现了存储库和工作单元模式，作为数据库的数据访问抽象。我使用依赖注入将它们注入控制器。问题是当控制器被释放时，它会释放存储库，但当我刷新页面时，存储库中的DbContext对象为null（我认为不应该为null）。类的实现如下所示

这是数据库存储库类：

public class ConferenceCrawlyDbRepository : IConferenceCrawlyDbRepository
{
    private ConferenceCrawlyDbContext _context = null;
    private static ConferenceCrawlyDbRepository _instance = null;

    public IRepository<AcademicDegree> AcademicDegrees { get; private set; }

    public IRepository<Conference> Conferences { get; private set; }

    public IRepository<ConferenceComment> ConferenceComments { get; private set; }

    public IRepository<ConferenceRating> ConferenceRatings { get; private set; }

    public IRepository<ConnectionConferenceRecommendation> ConnectionConferenceRecommendation { get; private set; }

    public IRepository<Country> Countries { get; private set; }

    public IRepository<ImportantDate> ImportantDates { get; private set; }

    public IRepository<Topic> Topics { get; private set; }

    public IRepository<UserProfile> UserProfiles { get; private set; }

    public IRepository<UserProfileSettings> UserProfileSettings { get; private set; }

    public IRepository<UsersConnection> UserConnections { get; private set; }

    public IRepository<Venue> Venues { get; private set; }

    private ConferenceCrawlyDbRepository(ConferenceCrawlyDbContext context)
    {
        _context = context;

        AcademicDegrees = new Repository<AcademicDegree>(context);
        Conferences = new Repository<Conference>(context);
        ConferenceComments = new Repository<ConferenceComment>(context);
        ConferenceRatings = new Repository<ConferenceRating>(context);
        ConnectionConferenceRecommendation = new Repository<ConnectionConferenceRecommendation>(context);
        Countries = new Repository<Country>(context);
        ImportantDates = new Repository<ImportantDate>(context);
        Topics = new Repository<Topic>(context);
        UserProfiles = new Repository<UserProfile>(context);
        UserProfileSettings = new Repository<UserProfileSettings>(context);
        UserConnections = new Repository<UsersConnection>(context);
        Venues = new Repository<Venue>(context);
    }

    public static ConferenceCrawlyDbRepository Instance
    {
        get
        {
            if (_instance == null)
                _instance = new ConferenceCrawlyDbRepository(new ConferenceCrawlyDbContext());

            return _instance;
        }
    }

    public bool CommitChanges()
    {
        try
        {
            return _context.SaveChanges() > 0;
        }
        catch
        {
            // TODO: Add logging
            return false;
        }
    }

    public void Dispose()
    {
        if (_context != null)
            _context.Dispose();
    }

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
    private ConferenceCrawlyDbContext _context = null;
    private DbSet<TEntity> _dbSet = null;

    public Repository(ConferenceCrawlyDbContext context)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
    }

    public DbSet<TEntity> DbSet
    {
        get
        {
            return _dbSet;
        }
    }

    public bool Add(TEntity entity)
    {
        try
        {
            DbSet.Add(entity);

            return true;
        }
        catch (Exception ex)
        {
            // TODO: Add logging
            return false;
        }

    }

    public bool Update(TEntity entity)
    {
        try
        {
            var entry = _context.Entry<TEntity>(entity);

            DbSet.Attach(entity);

            entry.State = EntityState.Modified;

            return true;
        }
        catch(Exception ex)
        {
            // TODO: Add logging
            return false;
        }
    }

    public bool Remove(TEntity entity)
    {
        try
        {
            DbSet.Remove(entity);

            return true;
        }
        catch (Exception ex)
        {
            // TODO: Add logging
            return false;
        }
    }

    public IQueryable<TEntity> GetAll()
    {
        return DbSet;
    }

    public IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
    {
        return DbSet.Where(predicate);
    }

    public TEntity FindById(params object[] keys)
    {
        return DbSet.Find(keys);
    }

    public bool Contains(Expression<Func<TEntity, bool>> predicate)
    {
        return _dbSet.Any(predicate);
    }

    public bool CommitChanges()
    {
        try
        {
            return _context.SaveChanges() > 0;
        }
        catch
        {
            // TODO: Add logging
            return false;
        }
    }

    public void Dispose()
    {
        if (_context != null)
            _context.Dispose();
    }
}

最后，控制器及其动作：

public class HomeController : Controller
    {
        private IConferenceCrawlyDbRepository _dbRepository;
        private IMailService _mailService;

        public HomeController(IConferenceCrawlyDbRepository dbRepository, IMailService mailService)
        {
            _dbRepository = dbRepository;
            _mailService = mailService;
        }

        //
        // GET: /
        public ActionResult Index()
        {
            var countries = _dbRepository.Countries.GetAll().ToList();

            return View(countries);
        }

        //
        // GET: /Home/About
        public ActionResult About()
        {
            return View();
        }

        //
        // GET: /Home/Contact
        public ActionResult Contact()
        {
            return View(new Contact());
        }

        //
        // POST: /Home/Contact
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Contact(Contact contact)
        {
            if (ModelState.IsValid)
            {
                if (await _mailService.SendMail(contact.Email, contact.Title,
                    String.Format("{1}{0}{2}", Environment.NewLine, contact.Message, String.IsNullOrEmpty(contact.Name) ? "Anonimous" : contact.Name)))
                {
                    ViewBag.SuccessMessage = "Comment has been successfully sent.";

                    return View(new Contact());
                }
                else
                    ViewBag.ErrorMessage = "Couldn't send your email. Please try again later";
            }

            return View(contact);
        }

        protected override void Dispose(bool disposing)
        {
            if (_dbRepository != null)
                _dbRepository.Dispose();

            base.Dispose(disposing);
        }
    }

公共类HomeController:控制器
{
私有IConferenceCrawlyDbRepository\u dbRepository；
私人iMail服务(邮递服务),；
公共HomeController（IConferenceCrawlyDbRepository，iMail服务邮件服务）
{
_dbRepository=dbRepository；
_mailService=mailService；
}
//
//获取：/
公共行动结果索引（）
{
var countries=_dbRepository.countries.GetAll（）.ToList（）；
返回视图（国家）；
}
//
//到家/大约
关于（）的公共行动结果
{
返回视图（）；
}
//
//取得/回家/联系
公共行动结果联系人（）
{
返回视图（新联系人（））；
}
//
//职位：/Home/联系人
[HttpPost]
[ValidateAntiForgeryToken]
公共异步任务联系人（联系人联系人）
{
if（ModelState.IsValid）
{
如果（等待）mailService.SendMail（contact.Email，contact.Title，
String.Format（“{1}{0}{2}”、Environment.NewLine、contact.Message、String.IsNullOrEmpty（contact.Name）？“Anonimous”：contact.Name）））
{
ViewBag.SuccessMessage=“评论已成功发送。”；
返回视图（新联系人（））；
}
其他的
ViewBag.ErrorMessage=“无法发送您的电子邮件。请稍后再试”；
}
返回视图（联系人）；
}
受保护的覆盖无效处置（布尔处置）
{
if（_dbRepository！=null）
_dbRepository.Dispose（）；
基地。处置（处置）；
}
}

---

当我调用存储库时，异常会在索引操作中抛出，但只有在第一次访问此控制器并且它表示存储库中的DbContext对象之后才会抛出。很明显，我做错了什么，但我想不出来。

我在长时间的启动和调试代码后才发现。这很简单，因为我在ConferenceScrawlyDBRepository中处理上下文，我还应该将使用它的_实例对象设置为null，然后它将与DbContext对象一起重新创建。我现在觉得自己太蠢了…

你不能在GetControllerInstance中设置一个调试点并跟踪它吗？我设置了，但这对我没有帮助。正如我所说，它很好地处理了它，但是当第二次调用它时，上下文是空的。这没有意义，因为我正在调用实例，如果该实例为空，则该实例应创建新上下文。该存储库是一个令人讨厌的对象。与直接使用EF相比，它没有增加任何价值。你为什么要用它？

public class HomeController : Controller
    {
        private IConferenceCrawlyDbRepository _dbRepository;
        private IMailService _mailService;

        public HomeController(IConferenceCrawlyDbRepository dbRepository, IMailService mailService)
        {
            _dbRepository = dbRepository;
            _mailService = mailService;
        }

        //
        // GET: /
        public ActionResult Index()
        {
            var countries = _dbRepository.Countries.GetAll().ToList();

            return View(countries);
        }

        //
        // GET: /Home/About
        public ActionResult About()
        {
            return View();
        }

        //
        // GET: /Home/Contact
        public ActionResult Contact()
        {
            return View(new Contact());
        }

        //
        // POST: /Home/Contact
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Contact(Contact contact)
        {
            if (ModelState.IsValid)
            {
                if (await _mailService.SendMail(contact.Email, contact.Title,
                    String.Format("{1}{0}{2}", Environment.NewLine, contact.Message, String.IsNullOrEmpty(contact.Name) ? "Anonimous" : contact.Name)))
                {
                    ViewBag.SuccessMessage = "Comment has been successfully sent.";

                    return View(new Contact());
                }
                else
                    ViewBag.ErrorMessage = "Couldn't send your email. Please try again later";
            }

            return View(contact);
        }

        protected override void Dispose(bool disposing)
        {
            if (_dbRepository != null)
                _dbRepository.Dispose();

            base.Dispose(disposing);
        }
    }