リポジトリパターン部Ninject

Question

私は私のアーキテクチャで マイティアリポジトリ、仕事と依存性注入パターンの単位を使用します。

コア

DataLayer

BusinessLayer

ServiceLayer

を

私の構造には何か問題があります。作業単位の単位

public class UnitOfWork:IUnitOfWork 
{ 
    private readonly IDataContext _context; 
    private IKullaniciDal _kullaniciDal; 
    private IKategoriDal _kategoriDal; 
    private IUrunDal _urunDal; 
    public UnitOfWork(IDataContext context) 
    { 
     _context = context; 
    } 

    public IKategoriDal KategoriDal => _kategoriDal ?? (_kategoriDal = new KategoriDal(_context)); 

    public IKullaniciDal KullaniciDal => _kullaniciDal ?? (_kullaniciDal = new KullaniciDal(_context)); 

    public IUrunDal UrunDal => _urunDal ?? (_urunDal = new UrunDal(_context)); 

    public void SaveChanges() 
    { 
     _context.SaveChanges(); 
    } 
} 

ここ

上記のように、私は_kullaniciDAL

ようDataAccessLayersを注入したい多くのことを検索し、私はビジネスから直接リポジトリインスタンスにアクセスしたいいけないリポジトリ総称的にBUを生成するためのいくつかの例を見て、私がアクセスしたいですここに私のKullaniciDalクラス のインスタンスは、私はそれらのいくつかの特殊なデータアクセス層にいくつかの余分な機能を書きたいととしてインスタンスを使用したいKullaniciDal

public interface IKullaniciDal : IRepositoryEntityFramework<Kullanici> 
{ 
} 

public class KullaniciDal : RepositoryEntityFramework<Kullanici>, IKullaniciDal 
{ 
    public KullaniciDal(IDataContext dbContextBase) : base(dbContextBase) 
    { 
    } 
} 

のコードです作業単位クラスの一部

Dalクラスはどのように注入できますか？ コンテキストオブジェクトをすべてのdalクラスに渡すように注意してください。

Answer 1

ここにはいくつかの問題があります。

まず、あなたのUoWはDIで注入するのではなく、DAL自体を新しくしています。 DIルートに行くなら、DIにすべてを注入させ、オブジェクトの範囲などをそれ自体で管理できるようにする方が良いでしょう。一般的なルールの一種として、インフラストラクチャークラスでnew（）を使用していることがわかった場合は、一歩踏み込んでインジェクションを検討してください。

public class UnitOfWork:IUnitOfWork 
{ 
    private readonly IDataContext _context; 
    public UnitOfWork(IDataContext context,IKullaniciDal kullaniciDal,IKategoriDal kategoriDal, IUrunDal urunDal) 
    { 
     KullaniciDal = kullaniciDal; 
     KategoriDal = kategoriDal; 
     UrunDal = urunDal; 
     _context = context; 
    } 

    public IKategoriDal KategoriDal{get;private set;} 

    public IKullaniciDal KullaniciDal{get;private set;} 

    public IUrunDal UrunDal{get;private set;} 

    public void SaveChanges() 
    { 
     _context.SaveChanges(); 
    } 
} 

次の質問は設計上の問題です。なぜこれらのDALがUoWに必要なのですか？私はこの奇妙な自分を見つける。

私がUoWとDALを制御する必要があるビジネスレイヤーを実装していた場合、ビジネスレイヤーに挿入するだけです。

public class FooBLL 
{ 
    private IKullanicDal _kullanicDal; 
    private IUnitOfWork _unitOfWork; 
    public FooBLL(IKullanicDal kullanicDal,IUnitOfWork unitOfWork) 
    { 
     _kullanicDal = kullanicDal; 
     _unitOfWork = unitOfWork; 
    } 

    public void FooBusinessMethod() 
    { 
     _unitOfWork.Begin(); 
     //do something with dal 
     //_unitOfWork.Commit etc 
    } 

} 

そのようなEFとしてORMを使用する場合、コンテキストがリポジトリ/ DLL及び作業ユニットの両方によって必要とされることは事実だが、それらは別々のパターンです。あなたのDIコンテナがあなたのコンテキスト、UoW、BLLなどを適切にスコープできるようにして、依存関係を回避することについて心配する必要はなく、コンテナがあなたのために仕事をするようにします。

これには、他のSOLID設計の利点もあります。あなたがhttpセッションを使ってあなたの消費を自動的にコミットするhttpフィルタを実装しているのかどうかを考えてみましょう。フィルタはIUnitOfWorkメソッドのコミット、ロールバックなどについて知る必要があります。最小限のインターフェイスに依存する必要があり、DALについて知る必要はありません。

Answer 2

私は、必要に応じてその場でリポジトリを作成するための別のソリューションを見つけました。 また、複数のデータコンテキストをサポートしています。また、IUnitOfWorkインターフェイスがIDisposableを継承するポイントがもう1つあります。コードはEF Core v2.0用です。ここにはすべてのUnitOfWorkがあります。csクラスコード：

public class UnitOfWork<TContext> : IUnitOfWork<TContext> where TContext : DbContext 
{ 
    private Dictionary<string, dynamic> _repositories; 
    private DbContext _context; 

    public UnitOfWork(TContext context) 
    { 
     _context = context ?? throw new ArgumentNullException(nameof(context)); 
    } 

    public IRepository<TEntity> Repository<TEntity>() where TEntity : class, IEntity, new() 
    { 
     if (_repositories == null) 
     { 
      _repositories = new Dictionary<string, dynamic>(); 
     } 
     var type = typeof(TEntity).Name; 
     if (_repositories.ContainsKey(type)) 
     { 
      return (IRepository<TEntity>)_repositories[type]; 
     } 
     _repositories.Add(type, Activator.CreateInstance(typeof(RepositoryEntityFramework<TEntity>), _context)); 
     return _repositories[type]; 
    } 

    public void SaveChanges() 
    { 
     _context.SaveChanges(); 
    } 

    public void BeginTransaction(System.Data.IsolationLevel isolationLevel = System.Data.IsolationLevel.ReadCommitted) 
    { 
     _context.Database.BeginTransaction(); 
    } 

    public bool Commit() 
    { 
     _context.Database.CommitTransaction(); 
     return true; 
    } 

    public void Rollback() 
    { 
     _context.Database.RollbackTransaction(); 
    } 

    /// <inheritdoc /> 
    /// <summary> 
    /// Disposes the current object 
    /// </summary> 
    public void Dispose() 
    { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 

    /// <summary> 
    /// Disposes all external resources. 
    /// </summary> 
    /// <param name="disposing">The dispose indicator.</param> 
    private void Dispose(bool disposing) 
    { 
     if (disposing) 
     { 
      if (_context != null) 
      { 
       _context.Dispose(); 
       _context = null; 
      } 
     } 
    } 
}