پیاده سازی Generic Controller همراه با Generic Repository

public interface IGenericRepository<TEntity> where TEntity : class, new()
{
    Task<TEntity> GetByIdAsync(CancellationToken cancellationToken, params object[] ids);
    Task<IEnumerable<TEntity>> GetAll(CancellationToken cancellationToken);
    Task AddAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true);
    Task AddRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true);
    Task DeleteAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true);
    Task DeleteRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true);
    Task UpdateAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true);
    Task UpdateRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true);
    Task<int> SaveChangeAsync(CancellationToken cancellationToken);
}
public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class, new()
{
    private readonly ApplicationDbContext _context;
    private DbSet<TEntity> _table { get; set; }
    public GenericRepository(ApplicationDbContext context)
    {
        _context = context;
        _table = _context.Set<TEntity>();
    }
    public virtual Task<TEntity> GetByIdAsync(CancellationToken cancellationToken, params object[] ids)
    {
        return _table.FindAsync(ids, cancellationToken);
    }
    public virtual async Task AddAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true)
    {
        await _table.AddAsync(entity, cancellationToken).ConfigureAwait(false);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }

    public virtual async Task AddRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true)
    {
        await _table.AddRangeAsync(entities, cancellationToken).ConfigureAwait(false);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }

    public virtual async Task UpdateAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true)
    {
        _table.Update(entity);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken);
    }
    public virtual async Task UpdateRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true)
    {
        _table.UpdateRange(entities);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken);
    }
    public virtual async Task DeleteAsync(TEntity entity, CancellationToken cancellationToken, bool saveNow = true)
    {
        _table.Remove(entity);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken);
    }
    public virtual async Task DeleteRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken, bool saveNow = true)
    {
        _table.RemoveRange(entities);
        if (saveNow)
            await _context.SaveChangesAsync(cancellationToken);
    }
    public virtual async Task<IEnumerable<TEntity>> GetAll(CancellationToken cancellationToken)
    {
        return await _table.ToListAsync(cancellationToken);
    }
    public async Task<int> SaveChangeAsync(CancellationToken cancellationToken)
    {
        return await _context.SaveChangesAsync(cancellationToken);
    }
}

public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class, new()

public class Person
{
    public int Id { get; set; }
    public string  Username { get; set; }
}

public interface IPersonRepository : IGenericRepository<Person>
{

}
public class PersonRepository : GenericRepository<Person>, IPersonRepository
{
    public PersonRepository(ApplicationDbContext context)
        : base(context)
    {
    }
}

public class GenericController<TEntity, IRepository> : Controller
    where TEntity : class, new()
    where IRepository : IGenericRepository<TEntity>
{
    private readonly IRepository _repository;

    public GenericController(IRepository repository)
    {
        _repository = repository;
    }

    public async Task<IActionResult> Index(CancellationToken cancellationToken)
    {
        var data = await _repository.GetAll(cancellationToken);
        return View(data);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost, ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(TEntity entity, CancellationToken cancellationToken)
    {
        if (ModelState.IsValid)
        {
            await _repository.AddAsync(entity, cancellationToken);
        }
        else return View(entity);
        return RedirectToAction(nameof(Index));
    }
    public async Task<IActionResult> Edit(int id, CancellationToken cancellationToken)
    {
        var data = await _repository.GetByIdAsync(cancellationToken, id);
        return View(data);
    }
    [HttpPost, ValidateAntiForgeryToken]
    public async Task<IActionResult> Edit(TEntity entity, CancellationToken cancellationToken)
    {
        if (ModelState.IsValid)
        {
            await _repository.UpdateAsync(entity, cancellationToken);
        }
        else return View(entity);
        return RedirectToAction(nameof(Index));
    }
    [HttpGet]
    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
    {
        return View(await _repository.GetByIdAsync(cancellationToken, id));
    }
    [HttpPost, ValidateAntiForgeryToken]
    public async Task<IActionResult> Delete(TEntity entity, CancellationToken cancellationToken)
    {
        await _repository.DeleteAsync(entity, cancellationToken);
        return RedirectToAction(nameof(Index));
    }
}

public class UserController : GenericController<Person, IPersonRepository>
{
    public UserController(IPersonRepository personRepository)
        : base(personRepository)
    {
    }
}

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; set; }
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
        {
            options.UseSqlServer(Configuration.GetConnectionString("Connection"));
        });
        services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
        services.AddScoped<IPersonRepository, PersonRepository>();
        services.AddMvc();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseMvcWithDefaultRoute();
    }
}