Ich stehe heute vor einem Problem und kann es nicht lösen. Ich habe viel gesucht und kann keine Lösung finden. Bitte helfen Sie mir, wenn Sie können.

Ich implementiere eine MVC-Anwendung, die EF + Repository-Muster + Arbeitseinheit mit Autofac als Abhängigkeitsinjektor verwendet.

Ich konnte mit einer DbContext-Klasse arbeiten, muss jedoch eine andere DbContext-Instanz verwenden (die auf eine andere Datenbank mit anderen Benutzeranmeldeinformationen zugreift).

Lass es mich besser erklären: Ich habe EntityA, das aus der Datenbank A stammt (und eine DatabaseA_Context-Klasse hat). Also brauche ich eine EntityB, die aus der Datenbank B stammt (mit einer eigenen DatabaseB_Context-Klasse).

Wenn ich sie bei AutoFac registriere, wird nur die zuletzt konfigurierte Abhängigkeit in die GenericRepository-Implementierung eingefügt.

Ich habe bereits Artikel gefunden, die besagen, dass Autofac die Registrierung mit dem letzten Wert überschreibt.

Ich habe bereits einen anderen Artikel gefunden, der zeigt, dass ich alle registrierten Typen für den UnitOfWork-Konstruktor sehen kann, wenn ich eine IEnumerable übergebe, aber ich möchte einen bestimmten.

Bin ich klar genug?

Mein Code unten:

Meine Steuerung:

public class MyController : Controller
{
    private readonly IBaseBLL<EntityA> _aBLL;
    private readonly IBaseBLL<EntityB> _bBll;

    public MyController(IBaseBLL<EntityA> aBLL, IBaseBLL<EntityB> bBLL)
    {
        _aBLL = aBLL;
        _bBLL = bBLL;
    }
}

My Business Layer

public interface IBaseBLL<T> where T : class
{
    T Select(Expression<Func<T, bool>> predicate);
    T AddT entity);
    void Update(T entity);
    T Delete(T entity);
}

public class BaseBLL<T> : IBaseBLL<T> where T : class
{
    private readonly IUnitOfWork _uow;

    public BaseBLL(IUnitOfWork uow)
    {
        _uow = uow;
    }

    //implementation goes here...
}

Meine UOW-Implementierung

public interface IUnitOfWork : IDisposable
{
    int SaveChanges();
    IGenericRepository<T> Repository<T>() where T : class;
}

public class UnitOfWork : IUnitOfWork
{
    private readonly DbContext _dbContext;
    private bool disposed = false;
    private Dictionary<Type, object> repositories;


    public UnitOfWork(DbContext dbContext)
    {
        _dbContext = dbContext;
        repositories = new Dictionary<Type, object>();
    }

    public IGenericReposity<T> Repository<T>() where T : class
    {
        if (repositories.Keys.Contains(typeof(T)))
            return repositories[typeof(T)] as IGenericReposity<T>;

        IGenericReposity<T> repository = new GenericRepository<T>(_dbContext);
        repositories.Add(typeof(T), repository );
        return repository ;
    }

    public int SaveChanges()
    {
        return _dbContext.SaveChanges();
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
            if (disposing)
                _dbContext.Dispose();

        this.disposed = true;
    }

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

Meine Repository-Implementierung

public class GenericRepository<T> : IGenericRepositoryT> where T : class
{
    protected readonly DbContext _dbContext;
    protected IDbSet<T> _dbSet;

    public GenericRepository(DbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = _dbContext.Set<T>();
    }

    //implementation goes here...
}

Meine AutoFac-Registrierung (in der Datei Global.asax)

var builder = new ContainerBuilder();

builder.RegisterType(typeof(DatabaseA_Context)).As(typeof(DbContext)).InstancePerLifetimeScope();
builder.RegisterType(typeof(DatabaseB_Context)).As(typeof(DbContext)).InstancePerLifetimeScope();
builder.RegisterType(typeof(UnitOfWork)).As(typeof(IUnitOfWork)).InstancePerRequest(); 

Bitte hilfe