ASP.NET MVC: Unit of Work или продолжаем оптимизировать сайт

   1:  publicinterface IMuseumUoW {

   2:  

   3:  // Сохранение данных 

   4:  // ожидающих сохранения

   5:  void Commit();

   6:  

   7:  // Репозитории

   8:      IRepository<Exhibit> Exhibits { get; }

   9:      IRepository<Hall> Halls { get; }

  10:      IRepository<LinkItem> LinkItems { get; }

  11:      IRepository<LinkCatalog> LinkCatalogs { get; }

  12:      ISubscriberRepository Subscribers { get; }

  13:      ILentaRepository Lentas { get; }

  14:      ILogRepository Logs { get; }

  15:      ITagRepository Tags { get; }

  16:  }

   1:  publicinterface IExhibitRepository {

   2:      IQueryable<Exhibit> All { get; }

   3:      IQueryable<Exhibit> AllIncluding(params Expression<Func<Exhibit, object>>[] includeProperties);

   4:      Exhibit Find(int id);

   5:  void Insert(Exhibit item);

   6:  void Update(Exhibit item);

   7:  void Delete(int id);

   8:  void Save();

   9:  }

   1:  publicinterface IRepository<T> where T : class {

   2:      IQueryable<T> All();

   3:      IQueryable<T> AllIncluding(params Expression<Func<T, object>>[] includeProperties);

   4:      T GetById(int id);

   5:  void Add(T entity);

   6:  void Update(T entity);

   7:  void Delete(T entity);

   8:  void Delete(int id);

   9:  }

   1:  publicinterface IExhibitRepository : IRepository<Exhibit> { 

   2:  }

   1:  publicclass ExhibitRepository : EntityRepository<Exhibit>, IExhibitRepository {

   2:  public ExhibitRepository(DbContext context) : base(context) { }

   3:  }

   1:  publicinterface ITagRepository : IRepository<Tag> {

   2:      Tag FindName(string name);

   3:  }

   1:  publicclass TagRepository : EntityRepository<Tag>, ITagRepository {

   2:  public TagRepository(DbContext context) : base(context) { }

   3:  

   4:  public Tag FindName(string name) {

   5:  return DbSet.SingleOrDefault(x => x.Name.ToLower().Equals(name.ToLower()));

   6:      }

   7:  }

   1:  /// <summary>

   2:  /// Main class Unit of Work for Museum of Humor

   3:  /// </summary>

   4:  publicclass MuseumUoW : UnitOfWorkBase, IMuseumUoW, IDisposable {

   5:   

   6:  public MuseumUoW(IRepositoryProvider provider)

   7:          : base(provider) {

   8:          InitializeDbContext();

   9:      }

  10:   

  11:  // часть кода скрыта для краткости

  12:  }

   1:  publicoverridevoid InitializeDbContext() {

   2:      DbContext = new MuseumContext();

   3:   

   4:  // запретим создавать proxy-классы для сущностей

   5:  // чтобы избежать проблем при сериализации объектов

   6:      DbContext.Configuration.ProxyCreationEnabled = false;

   7:   

   8:  // Отключим неявную "ленивую" загрузку 

   9:  // (избежим проблемы с сериализацией)

  10:      DbContext.Configuration.LazyLoadingEnabled = false;

  11:   

  12:  // Отключим для повышения увеличения производительности

  13:  // валидацию при записи в базу данных.

  14:  // Я ее отключил, потому что уверен в том, что 

  15:  // реализую валидацию объектов на форме (представления),

  16:  // а при реализации Web API я буду использовать валидацию

  17:  // для Knockout.Validation

  18:      DbContext.Configuration.ValidateOnSaveEnabled = false;

  19:   

  20:  // Инициализируем провайдера репозиториев

  21:      InitializeProvider(this.DbContext);

  22:  }

   1:  // ... тут другие репозитории

   2:  

   3:  public IRepository<LinkCatalog> LinkCatalogs {

   4:      get {

   5:  return GetRepository<LinkCatalog>();

   6:      }

   7:  }

   8:  public ISubscriberRepository Subscribers {

   9:      get {

  10:  return GetRepositoryExt<ISubscriberRepository>();

  11:      }

  12:  }

  13:  

   1:  /// <summary>

   2:  /// Main class Unit of Work for Museum of Humor

   3:  /// </summary>

   4:  publicclass MuseumUoW : UnitOfWorkBase, IMuseumUoW, IDisposable {

   5:   

   6:  public MuseumUoW(IRepositoryProvider provider)

   7:          : base(provider) {

   8:          InitializeDbContext();

   9:      }

  10:   

  11:   

  12:   

  13:  private MuseumContext DbContext;

  14:   

  15:  #region IDisposable

  16:   

  17:  publicvoid Dispose() {

  18:          Dispose(true);

  19:          GC.SuppressFinalize(this);

  20:      }

  21:   

  22:  protectedvirtualvoid Dispose(bool disposing) {

  23:  if (disposing) {

  24:  if (DbContext != null) {

  25:                  DbContext.Dispose();

  26:              }

  27:          }

  28:      }

  29:   

  30:  #endregion

  31:   

  32:   

  33:  #region Репозитории

  34:   

  35:  public IRepository<Exhibit> Exhibits {

  36:          get { return GetRepository<Exhibit>(); }

  37:      }

  38:  public IRepository<Hall> Halls {

  39:          get { return GetRepository<Hall>(); }

  40:      }

  41:  public IRepository<LinkItem> LinkItems {

  42:          get { return GetRepository<LinkItem>(); }

  43:      }

  44:  public IRepository<LinkCatalog> LinkCatalogs {

  45:          get { return GetRepository<LinkCatalog>(); }

  46:      }

  47:  public ISubscriberRepository Subscribers {

  48:          get { return GetRepositoryExt<ISubscriberRepository>(); }

  49:      }

  50:  public ILentaRepository Lentas {

  51:          get { return GetRepositoryExt<ILentaRepository>(); }

  52:      }

  53:  public ILogRepository Logs {

  54:          get { return GetRepositoryExt<ILogRepository>(); }

  55:      }

  56:  public ITagRepository Tags {

  57:          get { return GetRepositoryExt<ITagRepository>(); }

  58:      }

  59:   

  60:  #endregion

  61:   

  62:  publicoverridevoid InitializeDbContext() {

  63:          DbContext = new MuseumContext();

  64:   

  65:  // запретим создавать proxy-классы для сущностей

  66:  // чтобы избежать проблем при сериализации объектов

  67:          DbContext.Configuration.ProxyCreationEnabled = false;

  68:   

  69:  // Отключим неявную "ленивую" загрузку 

  70:  // (избежим проблемы с сериализацией)

  71:          DbContext.Configuration.LazyLoadingEnabled = false;

  72:   

  73:  // Отключим для повышения увеличения производительности

  74:  // валидацию при записи в базу данных.

  75:  // Я ее отключил, потому что уверен в том, что 

  76:  // реализую валидацию объектов на форме (представления),

  77:  // а при реализации Web API я буду использовать валидацию

  78:  // для Knockout.Validation

  79:          DbContext.Configuration.ValidateOnSaveEnabled = false;

  80:   

  81:  // Инициализируем провайдера репозиториев

  82:          InitializeProvider(this.DbContext);

  83:      }

  84:   

  85:  publicoverridevoid Commit() {

  86:          DbContext.SaveChanges();

  87:      }

  88:  }

   1:  container.RegisterInstance<RepositoryFactories>(new RepositoryFactories(data));

   2:  container.RegisterType<IMuseumUoW, MuseumUoW>();

   3:  container.RegisterType<IRepositoryProvider, RepositoryProvider>();

   1:  publicstaticclass Bootstrapper {

   2:  

   3:  publicstaticvoid Initialise() {

   4:          var container = BuildUnityContainer();

   5:  

   6:          DependencyResolver.SetResolver(new UnityDependencyResolver(container));

   7:          GlobalConfiguration.Configuration.DependencyResolver =                       
                             new Unity.WebApi.UnityDependencyResolver(container);

   8:      }

   9:  

  10:  privatestatic IUnityContainer BuildUnityContainer() {

  11:          var container = new UnityContainer();

  12:          var data = new Dictionary<Type, Func<DbContext, object>>{ 

  13:              {typeof(IExhibitRepository), dbContext     => new ExhibitRepository(dbContext)},

  14:              {typeof(IHallRepository), dbContext        => new HallRepository(dbContext)},

  15:              {typeof(ILentaRepository), dbContext       => new LentaRepository(dbContext)},

  16:              {typeof(ILinkItemRepository), dbContext    => new LinkItemRepository(dbContext)},

  17:              {typeof(ILogRepository), dbContext         => new LogRepository(dbContext)},

  18:              {typeof(ISubscriberRepository), dbContext  => new SubscriberRepository(dbContext)},

  19:              {typeof(ILinkCatalogRepository), dbContext => new LinkCatalogRepository(dbContext)},

  20:              {typeof(ITagRepository), dbContext         => new TagRepository(dbContext)}

  21:          };

  22:  

  23:          container.RegisterInstance<RepositoryFactories>(new RepositoryFactories(data));

  24:          container.RegisterType<IMuseumUoW, MuseumUoW>();

  25:          container.RegisterType<IRepositoryProvider, RepositoryProvider>();

  26:  

  27:  return container;

  28:      }

  29:  }