Repozytorium i jeden kontekst aplikacji.

1

Jak zrobić, aby każde repozytorium korzystało z jednego kontekstu aplikacji?
W QuizController i QuestionController ma taką linijkę:

private UnitOfWork unitOfWork = new UnitOfWork();
 

Skoro w UnitOfWork jest to:

private ApplicationDbContext context = new ApplicationDbContext(); 

to tworząc instancję klasy UnitOfWork za każdym razem jest tworzony nowy kontekst, żeby temu zapobiec to cała klasa UnitOfWork powinna być np. singletonem? Czy może jestem w błędzie?

using System;
using WebQuiz.Models;

namespace WebQuiz.DAL
{
    //All repositories share the same context instance
    public class UnitOfWork : IDisposable
    {
        private ApplicationDbContext context = new ApplicationDbContext();
       
        private IQuizRepository quizRepository;
        private IQuestionRepository questionRepostiory;

      

        public IQuizRepository QuizRepository
        {
            get
            {

                if (this.quizRepository == null)
                {
                    this.quizRepository = new QuizRepository(context);
                }
                return quizRepository;
            }
        }

        public IQuestionRepository QuestionRepository
        {
            get
            {

                if (this.questionRepostiory == null)
                {
                    this.questionRepostiory = new QuestionRepository(context);
                }
                return questionRepostiory;
            }
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

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

Cala klasa nie musi byc singletonem, potrzebujesz osobnej klasy, ktora bedize pilnowala, ze w uzyciu zawsze bedzie jeden kontekst (ta kalsa bedzie singletonem)

public class MyDBContextProvider
{
   private static MyDBContext instance;

   private MyDBContextProvider() {}

   public static MyDBContext Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new MyDBContext();
         }
         return instance;
      }
   }
}
3
gcmarcin napisał(a):

to tworząc instancję klasy UnitOfWork za każdym razem jest tworzony nowy kontekst, żeby temu zapobiec to cała klasa UnitOfWork powinna być np. singletonem? Czy może jestem w błędzie?

Powinieneś przekazywać UnitOfWork do repozytorium w konstruktorze, a nie tworzyć go wewnątrz repozytorium.
Ogólnie najłatwiej jest stosować IoC i nie tworzyć obiektów samemu.

1

Wzorując się na tym: http://debugmode.net/2014/08/28/resolving-dependencies-in-asp-net-mvc-5-using-unity-container/ mam IoC. Nigdzie nie tworzę obiektów kontekstu aplikacji ani obiektu repozytorium, unityMVC.5 samo je stworzy kiedy będzie to konieczne, dobrze to rozumiem? Czy poniższy kod jest ok? @somekind

 
using System.Web.Mvc;
using Microsoft.Practices.Unity;
using Unity.Mvc5;
using WebQuiz.DAL;

namespace WebQuiz
{
    public static class UnityConfig
    {
        public static void RegisterComponents()
        {
			var container = new UnityContainer();
            
            // register all your components with the container here
            // it is NOT necessary to register your controllers
            
            // e.g. container.RegisterType<ITestService, TestService>();

            container.RegisterType<IQuizRepository, QuizRepository>();
            container.RegisterType<IQuestionRepository, QuestionRepository>();
            DependencyResolver.SetResolver(new UnityDependencyResolver(container));
        }
    }
}
using System.Collections.Generic;
using WebQuiz.Models;

namespace WebQuiz.DAL
{
    public interface IQuizRepository
    {
        IEnumerable<Quiz> GetQuizzes();
        Quiz GetQuizById(int quizId);
        void InsertQuiz(Quiz quiz);
        void DeleteQuiz(int quizId);
        void UpdateQuiz(Quiz quiz);
        void Save();

        void Dispose();
    }
} 
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using WebQuiz.Models;

namespace WebQuiz.DAL
{
    public class QuizRepository : IQuizRepository
    {
        private ApplicationDbContext context;

        public QuizRepository(ApplicationDbContext context)
        {
            this.context = context;
        }

        public IEnumerable<Quiz> GetQuizzes()
        {
            return context.Quizzes.ToList();
        }

        public Quiz GetQuizById(int quizId)
        {
            return context.Quizzes.Find(quizId);
        }

        public void InsertQuiz(Quiz quiz)
        {
            context.Quizzes.Add(quiz);
        }

        public void DeleteQuiz(int quizId)
        {
            Quiz quiz = context.Quizzes.Find(quizId);
            context.Quizzes.Remove(quiz);
        }

        public void UpdateQuiz(Quiz quiz)
        {
            context.Entry(quiz).State = EntityState.Modified;
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

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

    }
} 
 
namespace WebQuiz.Controllers
{
    public class QuizsController : Controller
    {
        
        private readonly IQuizRepository quizRepository;

        public QuizsController(IQuizRepository quizRepository)
        {
            this.quizRepository = quizRepository;

        }
        // GET: Quizs
        public ActionResult Index()
        {
            
            return View(quizRepository.GetQuizzes());
        }
....
1
gcmarcin napisał(a):

Nigdzie nie tworzę obiektów kontekstu aplikacji ani obiektu repozytorium, unityMVC.5 samo je stworzy kiedy będzie to konieczne, dobrze to rozumiem?

Tak powinno się stać.

Czy poniższy kod jest ok?

Wygląda nieźle, chociaż zgodnie ze wzorcem MVC, repozytoriów nie powinno się używać w kontrolerach. (Chociaż czasem takie uproszczenie ma sens.)

1 użytkowników online, w tym zalogowanych: 0, gości: 1