L'implementazione di modelli DI con UnitOfWork e repository in winform utilizza autofac (Autofac.Core.DependencyResolutionException HResult=0x80131500)

L'implementazione di modelli DI con UnitOfWork e repository in winform utilizza autofac (Autofac.Core.DependencyResolutionException HResult=0x80131500)

La soluzione per l'implementazione di DI con UnitOfWork e modelli di repository in winform utilizza autofac (Autofac.Core.DependencyResolutionException HResult=0x80131500)
di seguito:

Quindi iniziamo con DbContext

  public class SIMContext : DbContext
  {
    public SIMContext()
    {
       
    }
    public SIMContext(DbContextOptions<SIMContext> options): base(options)
    {
    }
    public virtual DbSet<Department> Departments { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(ConfigurationManager.ConnectionStrings["SIMContext"].ConnectionString);
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.ApplyConfiguration(new DepartmentConfiguration());
    } 
}

E questo è il mio IUnitOfWork:

public interface IUnitOfWork : IDisposable
{
    IDepartmentRepository Departments { get; }
    int Complete();
}

E questa è UnitOfWork:

public class UnitOfWork : IUnitOfWork
{

    private readonly SIMContext _context;
    public UnitOfWork(SIMContext context)
    {
        _context = context;
        Departments = new DepartmentRepository(_context);
    }
    public IDepartmentRepository Departments { get; private set; }
    public int Complete()
    {
        return _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);
    }
}

E questo è il mio IRepository:

public interface IRepository<TEntity> where TEntity : class
{
    Task<TEntity> GetByIdAsync(object id);
    Task<IEnumerable<TEntity>> GetAllAsync();
    Task<TEntity> FindAsync(Expression<Func<TEntity, bool>> predicate, string[] includes = null);
    Task<IEnumerable<TEntity>> FindAllAsync(Expression<Func<TEntity, bool>> predicate, string[] includes = null);
    Task<IEnumerable<TEntity>> FindAllAsync(Expression<Func<TEntity, bool>> predicate, int take, int skip);
    Task<TEntity> SingleOrDefault(Expression<Func<TEntity, bool>> predicate);
    Task<TEntity> AddAsync(TEntity entity);
    Task<IEnumerable<TEntity>> AddRangeAsync(IEnumerable<TEntity> entities);
    void Remove(TEntity entity);
    void RemoveRange(IEnumerable<TEntity> entities);
}

E questo è il mio repository:

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
    protected readonly DbContext Context;
    internal DbSet<TEntity> dbSet;

    public Repository(DbContext context)
    {
        Context = context;
        dbSet = Context.Set<TEntity>();
    }
    public async Task<TEntity> AddAsync(TEntity entity)
    {
        await dbSet.AddAsync(entity);
        return entity;
    }
    public async Task<IEnumerable<TEntity>> AddRangeAsync(IEnumerable<TEntity> entities)
    {
        await dbSet.AddRangeAsync(entities);
        return entities;
    }
    public async Task<TEntity> FindAsync(Expression<Func<TEntity, bool>> predicate, string[] includes = null)
    {
        IQueryable<TEntity> query = dbSet;
        if (includes != null)
            foreach (var incluse in includes)
                query = query.Include(incluse);

        return await query.SingleOrDefaultAsync(predicate);
    }
    public async Task<IEnumerable<TEntity>> FindAllAsync(Expression<Func<TEntity, bool>> predicate, string[] includes = null)
    {
        IQueryable<TEntity> query = dbSet;

        if (includes != null)
            foreach (var include in includes)
                query = query.Include(include);

        return await query.Where(predicate).ToListAsync();
    }
    public async Task<IEnumerable<TEntity>> FindAllAsync(Expression<Func<TEntity, bool>> predicate, int take, int skip)
    {
        return await dbSet.Where(predicate).Skip(skip).Take(take).ToListAsync();
    }
    public async Task<TEntity> GetByIdAsync(object id)
    {
        return await dbSet.FindAsync(id);
    }
    public async Task<IEnumerable<TEntity>> GetAllAsync()
    {
        return await dbSet.ToListAsync();
    }
    public void Remove(TEntity entity)
    {
         dbSet.Remove(entity);
    }
    public void RemoveRange(IEnumerable<TEntity> entities)
    {
         dbSet.RemoveRange(entities);
    }
    public async Task<TEntity> SingleOrDefault(Expression<Func<TEntity, bool>> predicate)
    {
        return await dbSet.SingleOrDefaultAsync(predicate);
    }
}

e questo è IDepartmentRepository :

public interface IDepartmentRepository: IRepository<Department>
{
}

e questo è DepartmentRepository :

 public class DepartmentRepository : Repository<Department>, IDepartmentRepository
{
    public DepartmentRepository(SIMContext context) : base(context)
    {
    }
    public SIMContext SIMContext
    {
        get { return Context as SIMContext; }
    }
}

E questa è la mia classe di programma :

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    public static IContainer Container;

    [STAThread]
    static void Main()
    {
        DevExpress.UserSkins.BonusSkins.Register();
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Container = Configure();
        Application.Run(new XtraMain(Container.Resolve<IUnitOfWork>()));
    }
    static IContainer Configure()
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<UnitOfWork>().As<IUnitOfWork>();
        builder.RegisterType<XtraMain>();
        return builder.Build();
    }
}

e questo è il mio modulo XtraMain :

private readonly IUnitOfWork unitOfWork;
    public XtraMain(IUnitOfWork unitOfWork) 
    {
        InitializeComponent();
        this.unitOfWork = unitOfWork;
    }
    private void bbtnDepartment_ItemClick(object sender, ItemClickEventArgs e)
    {
        Frm_Department frme = new(unitOfWork)
        {
            Name = "Frm_Department"

        };
        ViewChildForm(frme);
    }

ma quando eseguo il programma ottengo un errore in questa riga:

Application.Run(new XtraMain(Container.Resolve<IUnitOfWork>()));

L'errore è :

Come posso risolvere questo problema?.

Sembra che tu non abbia registrato SIMContext durante la configurazione dell'Autofac. Aggiunta della seguente registrazione nel tuo Configure il metodo può aiutare:

builder.RegisterType<SIMContext>().AsSelf();


No