Modern EF Core Generic Repository for .NET 10

Muslim.GenericRepository is an enterprise-grade EF Core repository for .NET 10. One generic class, Repository<TEntity>, gives every table reads, writes, soft delete, bulk operations and raw SQL, and fills CreatedBy, UpdateBy, DeletedBy and their dates on every write.

The contract lives in a separate package, Muslim.GenericRepository.Interface. IRepository<TEntity> is built from fifteen small, single-responsibility interfaces; each section below covers one of them, with the implementation as it ships in 10.0.1 and when to use it.

Install the NuGet package using the .NET CLI. It brings Muslim.GenericRepository.Interface, Muslim.EntityAndDto, Muslim.Helpers, Muslim.Inject and AutoMapper 12 with it. The database provider is not included, so add the one you use:

dotnet add package Muslim.GenericRepository
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

using AutoMapper;
using Muslim.EntityAndDto.Dtos;
using Muslim.EntityAndDto.Entitys;
using Muslim.GenericRepository.Interface;
using Muslim.GenericRepository.Repositories;

public class Product : Entity
{
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

public class ProductDto : Dto
{
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

public class ProductProfile : Profile
{
    public ProductProfile() => CreateMap<Product, ProductDto>().ReverseMap();
}

public interface IProductRepository : IRepository<Product> { }

internal class ProductRepository : Repository<Product>, IProductRepository { }

using Microsoft.EntityFrameworkCore;
using Muslim.Helpers;
using Muslim.Inject;
using Muslim.GenericRepository.Repositories;

builder.Services.AddDbContext<ShopContext>(o => o.UseSqlServer(connectionString));
builder.Services.AddAutoMapper(typeof(ProductProfile).Assembly);
builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ICurrentUser, HttpCurrentUser>();             // your class, reads the user from the request
builder.Services.AddAutoInjection(typeof(IProductRepository).Assembly);   // IProductRepository -> ProductRepository

BaseRepository.SetDbContext<ShopContext>();

var app = builder.Build();

InjectExtensions.SetServiceProvider(app.Services);
app.Use(async (context, next) =>
{
    InjectExtensions.SetServiceProvider(context.RequestServices);   // before anything uses a repository
    await next();
});

public class ProductService(IProductRepository products)
{
    public Task<ProductDto> GetAsync(int id)
        => products.GetByIdAsync<ProductDto>(id);

    public async Task<int> CreateAsync(CreateProductDto dto)
    {
        var product = await products.SaveCreateAsync(new Product { Name = dto.Name, Price = dto.Price });
        return product.Id;
    }

    public Task DeleteAsync(int id)
        => products.SaveSoftDeleteByIdAsync(id);
}

global using Muslim.GenericRepository.Interface;    // IRepository<T>
global using Muslim.IGenericRepository;             // ICreate<T>, IFind<T>, ...
global using Muslim.GenericRepository.Repositories; // Repository<T>, BaseRepository
global using Muslim.EntityAndDto.Entitys;           // Entity
global using Muslim.EntityAndDto.Dtos;              // Dto
global using Muslim.Helpers;                        // ICurrentUser
global using Muslim.Inject;                         // AddAutoInjection, InjectExtensions

Setup Notes & Best Practices

• DTOs inherit Dto from Muslim.EntityAndDto and need an AutoMapper map configured from the entity.
• The middleware that sets the provider per request is required. Without it every request shares one DbContext, or startup fails with “Cannot resolve scoped service”.
• Place that middleware before any middleware that touches a repository, such as authentication handlers that load users or tenant resolution.
• In background work or queued hosted services, wrap each unit of work in InjectExtensions.RunInScopeAsync. There is no HttpContext there, so ICurrentUser must still return a user id (a system user).
• AddAutoInjection registers IProductRepository as scoped. It does not register open generics. To inject IRepository<T> directly, add:
  builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

BaseRepository resolves what every repository needs: the DbContext, AutoMapper and the current user. Repositories have a parameterless constructor, so these are pulled from the ambient provider set by InjectExtensions.SetServiceProvider. Everything is resolved on first use, not in the constructor, so a repository that is built but never queried opens no connection.

public static void SetDbContext<TDbContext>() => _defaultDbContextType = typeof(TDbContext);

protected void UseContext<TDbContext>()
{
    _contextType = typeof(TDbContext);
    _dbContext = null;
}

internal class TenantRepository : Repository<Tenant>, ITenantRepository
{
    public TenantRepository() { UseContext<TenantDbContext>(); }
}

IRepository<TEntity> is the full surface for one entity. It inherits every interface below and adds two IQueryable entry points for anything the named methods do not cover: joins, grouping, paging and custom ordering.

public interface IRepository<TEntity> : IAutoInjection
    , IGetById<TEntity>, IGetAll<TEntity>, IFind<TEntity>
    , IFirstOrDefault<TEntity>, ISingleOrDefault<TEntity>
    , ICreate<TEntity>, IUpdate<TEntity>, IEntityState<TEntity>
    , IDelete<TEntity>, ISoftDelete<TEntity>
    , ICount<TEntity>, IAny<TEntity>
    , ISqlOperations<TEntity>, ISave<TEntity>
 where TEntity : Entity

public virtual IQueryable<TEntity> Query => Table;

public virtual IQueryable<TEntity> QueryAsNoTracking => Table.AsNoTracking();

var page = await repo.QueryAsNoTracking
                     .Where(x => x.Price > 0)
                     .OrderBy(x => x.Name)
                     .Skip(20).Take(20)
                     .ToListAsync();

Every read that returns entities takes bool isTracking = true. All of them go through one unified helper:

protected IQueryable<TEntity> Read(bool isTracking)
    => isTracking ? Table : Table.AsNoTracking();

• true (default): the result is tracked. Edit it and call Save().
• false: the result is not tracked. Faster on large results you only read; edits are ignored on save.
• Reads that return a DTO are never tracked, so they have no such switch.

IGetById<TEntity> loads one row by primary key, as an entity or as a DTO. Each returns null when no row has that id.

public virtual TEntity GetById(int id, bool isTracking = true)
    => isTracking
        ? Table.Find(id)!
        : Table.AsNoTracking().FirstOrDefault(x => x.Id == id)!;

public virtual TMap GetById<TMap>(int id) where TMap : IDto
    => Table.ProjectTo<TMap>(_mapperConfig).SingleOrDefault(x => x.Id == id)!;

public virtual async Task<TEntity> GetByIdAsync(int id, bool isTracking = true)
    => isTracking
        ? (await Table.FindAsync(id))!
        : (await Table.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id))!;

public virtual async Task<TMap> GetByIdAsync<TMap>(int id) where TMap : IDto
    => (await Table.ProjectTo<TMap>(_mapperConfig).SingleOrDefaultAsync(x => x.Id == id))!;

IGetAll<TEntity> loads every matching row. On a table that grows without limit, page with Query or filter with Find instead.

public virtual List<TEntity> GetAll(bool isTracking = true)
    => Read(isTracking).ToList();

public virtual List<TMap> GetAll<TMap>() where TMap : IDto
    => Table.ProjectTo<TMap>(_mapperConfig).ToList();

public virtual async Task<List<TEntity>> GetAllAsync(bool isTracking = true)
    => await Read(isTracking).ToListAsync();

public virtual async Task<List<TEntity>> GetAllAsync(Expression<Func<TEntity, bool>> condition, bool isTracking = true)
    => await Read(isTracking).Where(condition).ToListAsync();

var active = await repository.GetAllAsync(x => !x.IsDeleted, isTracking: false);

public virtual async Task<List<TMap>> GetAllAsync<TMap>() where TMap : IDto
    => await Table.ProjectTo<TMap>(_mapperConfig).ToListAsync();

IFind<TEntity> returns many rows, by a condition or by an IFilter<T> from Muslim.Filter carrying the paging, sorting and search of a grid. Overloads that return entities take isTracking; overloads that project do not.

public virtual List<TEntity> Find(IFilter<TEntity> filter, bool isTracking = true)
    => filter.Apply(Read(isTracking)).ToList();

public virtual List<TEntity> Find(Expression<Func<TEntity, bool>> condition, bool isTracking = true)
    => Read(isTracking).Where(condition).ToList();

public virtual List<TMap> Find<TMap>(IFilter<TMap> filter) where TMap : class, IHaveFilter
    => filter.Apply(Table.ProjectTo<TMap>(_mapperConfig)).ToList();

public virtual List<TMap> Find<TMap>(IFilter<TEntity> filter) where TMap : IDto
    => filter.Apply(Table).ProjectTo<TMap>(_mapperConfig).ToList();

public virtual List<TMap> Find<TMap>(Expression<Func<TEntity, bool>> condition, Expression<Func<TEntity, TMap>> selector = default!)
    => selector is null
        ? Table.Where(condition).ProjectTo<TMap>(_mapperConfig).ToList()
        : Table.Where(condition).Select(selector).ToList();

var dtos = repository.Find<UserDto>(x => x.IsActive);
var rows = repository.Find((User x) => x.IsActive, x => new { x.Id, x.Name });

public virtual List<TMap> Find<TMap>(Expression<Func<TMap, bool>> condition, Expression<Func<TEntity, TMap>> selector)
    => Table.Select(selector).Where(condition).ToList();

var rows = repository.Find(r => r.Total > 100, x => new { x.Id, Total = x.Qty * x.Price });

Async Twin Overloads

Each overload above has an async twin with the same parameters and behavior:

Task<List<TEntity>> FindAsync(IFilter<TEntity> filter, bool isTracking = true);
Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> condition, bool isTracking = true);
Task<List<TMap>> FindAsync<TMap>(IFilter<TMap> filter) where TMap : class, IHaveFilter;
Task<List<TMap>> FindAsync<TMap>(IFilter<TEntity> filter) where TMap : IDto;
Task<List<TMap>> FindAsync<TMap>(Expression<Func<TEntity, bool>> condition, Expression<Func<TEntity, TMap>> selector = default!);
Task<List<TMap>> FindAsync<TMap>(Expression<Func<TMap, bool>> condition, Expression<Func<TEntity, TMap>> selector);

IFirstOrDefault<TEntity> reads the first matching row, or null when there is none. Use it when several rows may match and any one will do. No ordering is applied by default, so “first” is whatever the database returns first; order through Query if it must be deterministic.

public virtual TEntity FirstOrDefault(bool isTracking = true)
    => Read(isTracking).FirstOrDefault()!;

public virtual TEntity FirstOrDefault(Expression<Func<TEntity, bool>> condition, bool isTracking = true)
    => Read(isTracking).FirstOrDefault(condition)!;

public virtual TMap FirstOrDefault<TMap>() where TMap : IDto
    => Table.ProjectTo<TMap>(_mapperConfig).FirstOrDefault()!;

public virtual TMap FirstOrDefault<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto
    => Table.Where(condition).ProjectTo<TMap>(_mapperConfig).FirstOrDefault()!;

public virtual TMap FirstOrDefault<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto
    => Table.ProjectTo<TMap>(_mapperConfig).FirstOrDefault(condition)!;

repo.FirstOrDefault<ProductDto>((Product x) => x.Price > 0);        // filter entity, then map
repo.FirstOrDefault<ProductDto>((ProductDto d) => d.Label == text);  // map to dto, then filter

public virtual TMap FirstOrDefault<TMap>(Expression<Func<TEntity, bool>> condition, Expression<Func<TEntity, TMap>> selector)
    => Table.Where(condition).Select(selector).FirstOrDefault()!;

Async Twin Overloads

Task<TEntity> FirstOrDefaultAsync(bool isTracking = true);
Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> condition, bool isTracking = true);
Task<TMap> FirstOrDefaultAsync<TMap>() where TMap : IDto;
Task<TMap> FirstOrDefaultAsync<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto;
Task<TMap> FirstOrDefaultAsync<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto;
Task<TMap> FirstOrDefaultAsync<TMap>(Expression<Func<TEntity, bool>> condition, Expression<Func<TEntity, TMap>> selector);

ISingleOrDefault<TEntity> reads the one row that matches. It throws InvalidOperationException when more than one row matches. Use it where a duplicate means the data is invalid, such as a unique SKU or user email. Where multiple matches are acceptable, use FirstOrDefault.

public virtual TEntity SingleOrDefault(Expression<Func<TEntity, bool>> condition, bool isTracking = true)
    => Read(isTracking).SingleOrDefault(condition)!;

public virtual TMap SingleOrDefault<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto
    => Table.Where(condition).ProjectTo<TMap>(_mapperConfig).SingleOrDefault()!;

public virtual TMap SingleOrDefault<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto
    => Table.ProjectTo<TMap>(_mapperConfig).SingleOrDefault(condition)!;

Async Twin Overloads

Task<TEntity> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> condition, bool isTracking = true);
Task<TMap> SingleOrDefaultAsync<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto;
Task<TMap> SingleOrDefaultAsync<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto;

IAny<TEntity> answers “is there at least one matching record?”. The database short-circuits at the first match, making this substantially faster and cheaper than Count() > 0.

public virtual bool Any() => Table.Any();

public virtual bool Any(Expression<Func<TEntity, bool>> condition) => Table.Any(condition);

if (repository.Any(x => x.Code == code))
    throw new InvalidOperationException("Code already used.");

public virtual async Task<bool> AnyAsync() => await Table.AnyAsync();

public virtual async Task<bool> AnyAsync(Expression<Func<TEntity, bool>> condition) => await Table.AnyAsync(condition);

ICount<TEntity> counts rows using SELECT COUNT(*) directly in SQL; no entities or columns are loaded into memory. To ask only whether rows exist, prefer Any.

public virtual int Count() => Table.Count();

public virtual int Count(Expression<Func<TEntity, bool>> condition) =>
    Table.Count(condition);

public virtual async Task<int> CountAsync() => await Table.CountAsync();

public virtual async Task<int> CountAsync(Expression<Func<TEntity, bool>> condition)
    => await Table.CountAsync(condition);

ICreate<TEntity> inserts rows. Every method fills CreatedDate (UTC) and CreatedBy from the current user before the row is added to the tracker. Never set these manually.

public virtual TEntity Create(TEntity entity)
    => Table.Add(ApplyAuditCreate(entity)).Entity;

public virtual TEntity SaveCreate(TEntity entity)
{
    var created = Table.Add(ApplyAuditCreate(entity)).Entity;
    Save();
    return created;
}

public virtual TMap SaveCreate<TMap>(TEntity entity) where TMap : IDto
{
    var created = Table.Add(ApplyAuditCreate(entity)).Entity;
    Save();
    return _mapper.Map<TMap>(created);
}

public virtual List<TEntity> CreateRange(IEnumerable<TEntity> entities)
{
    var list = ApplyAuditCreate(entities);
    Table.AddRange(list);
    return list;
}

public virtual TResult SaveCreate<TResult, TMap>(TMap dto)
    where TMap : IDto
    where TResult : IDto
{
    var created = Table.Add(ApplyAuditCreate(_mapper.Map<TEntity>(dto))).Entity;
    Save();
    return _mapper.Map<TResult>(created);
}

var response = await repo.SaveCreateAsync<ProductDto, CreateProductDto>(request);

All ICreate Overloads Reference

// From an entity
TEntity Create(TEntity entity);
TMap Create<TMap>(TEntity entity) where TMap : IDto;
Task<TEntity> CreateAsync(TEntity entity);
Task<TMap> CreateAsync<TMap>(TEntity entity) where TMap : IDto;
TEntity SaveCreate(TEntity entity);
TMap SaveCreate<TMap>(TEntity entity) where TMap : IDto;
Task<TEntity> SaveCreateAsync(TEntity entity);
Task<TMap> SaveCreateAsync<TMap>(TEntity entity) where TMap : IDto;
List<TEntity> CreateRange(IEnumerable<TEntity> entities);
List<TMap> CreateRange<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
Task<List<TEntity>> CreateRangeAsync(IEnumerable<TEntity> entities);
Task<List<TMap>> CreateRangeAsync<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
List<TEntity> SaveCreateRange(IEnumerable<TEntity> entities);
List<TMap> SaveCreateRange<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
Task<List<TEntity>> SaveCreateRangeAsync(IEnumerable<TEntity> entities);
Task<List<TMap>> SaveCreateRangeAsync<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;

// From a DTO
TEntity Create<TMap>(TMap dto) where TMap : IDto;
TResult Create<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
Task<TEntity> CreateAsync<TMap>(TMap dto) where TMap : IDto;
Task<TResult> CreateAsync<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
List<TEntity> CreateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
List<TResult> CreateRange<TResult, TMap>(IEnumerable<TMap> dtos) where TMap : IDto where TResult : IDto;
Task<List<TEntity>> CreateRangeAsync<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
Task<List<TResult>> CreateRangeAsync<TResult, TMap>(IEnumerable<TMap> dtos) where TMap : IDto where TResult : IDto;
TEntity SaveCreate<TMap>(TMap dto) where TMap : IDto;
TResult SaveCreate<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
Task<TEntity> SaveCreateAsync<TMap>(TMap dto) where TMap : IDto;
Task<TResult> SaveCreateAsync<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
List<TEntity> SaveCreateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
List<TResult> SaveCreateRange<TResult, TMap>(IEnumerable<TMap> dtos) where TMap : IDto where TResult : IDto;
Task<List<TEntity>> SaveCreateRangeAsync<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
Task<List<TResult>> SaveCreateRangeAsync<TResult, TMap>(IEnumerable<TMap> dtos) where TMap : IDto where TResult : IDto;

IUpdate<TEntity> writes changes to existing rows from an entity or a DTO. Every update fills UpdateDate (UTC) and UpdateBy, and preserves CreatedBy, CreatedDate and soft-delete columns by reading them back from the database.

private TEntity PrepareUpdate(TEntity entity)
{
    ApplyAuditUpdate(entity);   // reads stored audit columns, stamps UpdateBy/UpdateDate
    ReleaseStaleCopy(entity);   // new in 10.0.1: detaches stale tracked instances
    return entity;
}

private void ReleaseStaleCopy(TEntity entity)
{
    var tracked = Table.Local.FindEntry(entity.Id);
    if (tracked is null || ReferenceEquals(tracked.Entity, entity)) return;
    if (tracked.State is EntityState.Unchanged or EntityState.Modified)
        tracked.State = EntityState.Detached;
}

Typical safe workflow in Web APIs:

var product = await repo.GetByIdAsync(dto.Id) ?? throw new KeyNotFoundException();
await repo.SaveUpdateAsync(dto);   // previously loaded copy is safely detached, DTO values are updated

public virtual void Update(TEntity entity)
    => Table.Update(PrepareUpdate(entity));

public virtual void SaveUpdate(TEntity entity)
{
    Table.Update(PrepareUpdate(entity));
    Save();
}

public virtual async Task SaveUpdateAsync(TEntity entity)
{
    Table.Update(await PrepareUpdateAsync(entity));
    await SaveAsync();
}

public virtual void Update<TMap>(TMap dto) where TMap : IDto
    => Table.Update(PrepareUpdate(_mapper.Map<TEntity>(dto)));

public virtual void IgnoreUpdateProperty(TEntity entity, Expression<Func<TEntity, object>> propertyExpression)
{
    PrepareUpdate(entity);
    var entry = _context.Entry(entity);
    entry.State = EntityState.Modified;
    entry.Property(propertyExpression).IsModified = false;
}

repo.IgnoreUpdateProperty(user, x => x.PasswordHash);
repo.Save();   // all columns updated, PasswordHash remains untouched, audit columns updated

All IUpdate Overloads

void Update(TEntity entity);
void SaveUpdate(TEntity entity);
Task SaveUpdateAsync(TEntity entity);
void UpdateRange(IEnumerable<TEntity> entities);
void SaveUpdateRange(IEnumerable<TEntity> entities);
Task SaveUpdateRangeAsync(IEnumerable<TEntity> entities);
void Update<TMap>(TMap dto) where TMap : IDto;
void SaveUpdate<TMap>(TMap dto) where TMap : IDto;
Task SaveUpdateAsync<TMap>(TMap dto) where TMap : IDto;
void UpdateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
void SaveUpdateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
Task SaveUpdateRangeAsync<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
void IgnoreUpdateProperty(TEntity entity, Expression<Func<TEntity, object>> propertyExpression);

IDelete<TEntity> removes rows permanently from the database. Where audit history matters, use soft delete instead. Methods by ID throw KeyNotFoundException when the ID does not exist.

public virtual TEntity Delete(TEntity entity)
    => Table.Remove(entity).Entity;

public virtual TEntity SaveDeleteById(int id)
{
    var removed = Table.Remove(FindOrThrow(id)).Entity;
    Save();
    return removed;
}

public virtual async Task<int> DeleteWhereAsync(Expression<Func<TEntity, bool>> predicate)
    => await Table.Where(predicate).ExecuteDeleteAsync();

All IDelete Overloads

// Sync — return entity
TEntity Delete(TEntity entity);
TEntity SaveDelete(TEntity entity);
TEntity DeleteById(int id);
TEntity SaveDeleteById(int id);
IEnumerable<TEntity> DeleteRange(IEnumerable<TEntity> entities);
IEnumerable<TEntity> SaveDeleteRange(IEnumerable<TEntity> entities);

// Sync — return DTO
TMap Delete<TMap>(TEntity entity) where TMap : IDto;
TMap SaveDelete<TMap>(TEntity entity) where TMap : IDto;
TMap DeleteById<TMap>(int id) where TMap : IDto;
TMap SaveDeleteById<TMap>(int id) where TMap : IDto;
IEnumerable<TMap> DeleteRange<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
IEnumerable<TMap> SaveDeleteRange<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;

// Sync — no return
void DeleteNoReturn(TEntity entity);
void SaveDeleteNoReturn(TEntity entity);
void DeleteByIdNoReturn(int id);
void SaveDeleteByIdNoReturn(int id);
void DeleteRangeNoReturn(IEnumerable<TEntity> entities);
void SaveDeleteRangeNoReturn(IEnumerable<TEntity> entities);

// Async
Task<TEntity> DeleteByIdAsync(int id);
Task<TEntity> SaveDeleteAsync(TEntity entity);
Task<TEntity> SaveDeleteByIdAsync(int id);
Task<IEnumerable<TEntity>> SaveDeleteRangeAsync(IEnumerable<TEntity> entities);
Task<TMap> DeleteByIdAsync<TMap>(int id) where TMap : IDto;
Task<TMap> SaveDeleteAsync<TMap>(TEntity entity) where TMap : IDto;
Task<TMap> SaveDeleteByIdAsync<TMap>(int id) where TMap : IDto;
Task<IEnumerable<TMap>> SaveDeleteRangeAsync<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
Task DeleteByIdNoReturnAsync(int id);
Task SaveDeleteNoReturnAsync(TEntity entity);
Task SaveDeleteByIdNoReturnAsync(int id);
Task SaveDeleteRangeNoReturnAsync(IEnumerable<TEntity> entities);

// Bulk — one direct SQL statement
Task<int> DeleteWhereAsync(Expression<Func<TEntity, bool>> predicate);
Task<int> DeleteByIdsAsync(IEnumerable<int> ids);

ISoftDelete<TEntity> retains records in the database while stamping audit flags: IsDeleted = true, DeletedDate = DateTime.UtcNow and DeletedBy. It mirrors the clean method conventions of IDelete and adds instantaneous restore methods.

public virtual TEntity SoftDelete(TEntity entity)
    => Table.Update(ApplyAuditSoftDelete(entity)).Entity;

private TEntity ApplyAuditSoftDelete(TEntity entity)
{
    entity.IsDeleted = true;
    entity.DeletedDate = DateTime.UtcNow;
    entity.DeletedBy = CurrentUserId;
    return entity;
}

public virtual TEntity SaveSoftDeleteById(int id)
{
    var updated = Table.Update(ApplyAuditSoftDelete(FindOrThrow(id))).Entity;
    Save();
    return updated;
}

public virtual async Task<int> SoftDeleteWhereAsync(Expression<Func<TEntity, bool>> predicate)
{
    var userId = CurrentUserId;
    var now = DateTime.UtcNow;
    return await Table.Where(predicate).ExecuteUpdateAsync(s => s
        .SetProperty(e => e.IsDeleted, true)
        .SetProperty(e => e.DeletedDate, now)
        .SetProperty(e => e.DeletedBy, userId));
}

public virtual async Task<int> RestoreByIdAsync(int id)
    => await Table.Where(e => e.Id == id).ExecuteUpdateAsync(s => s
        .SetProperty(e => e.IsDeleted, false)
        .SetProperty(e => e.DeletedDate, (DateTime?)null)
        .SetProperty(e => e.DeletedBy, (string?)null));

All ISoftDelete Overloads

// Sync — return entity
TEntity SoftDelete(TEntity entity);
TEntity SaveSoftDelete(TEntity entity);
TEntity SoftDeleteById(int id);
TEntity SaveSoftDeleteById(int id);

// Sync — return DTO
TMap SoftDelete<TMap>(TEntity entity) where TMap : IDto;
TMap SaveSoftDelete<TMap>(TEntity entity) where TMap : IDto;
TMap SoftDeleteById<TMap>(int id) where TMap : IDto;
TMap SaveSoftDeleteById<TMap>(int id) where TMap : IDto;

// Sync — no return
void SoftDeleteNoReturn(TEntity entity);
void SaveSoftDeleteNoReturn(TEntity entity);
void SoftDeleteByIdNoReturn(int id);
void SaveSoftDeleteByIdNoReturn(int id);
void SoftDeleteRangeNoReturn(IEnumerable<TEntity> entities);
void SaveSoftDeleteRangeNoReturn(IEnumerable<TEntity> entities);

// Async
Task<TEntity> SoftDeleteByIdAsync(int id);
Task<TEntity> SaveSoftDeleteAsync(TEntity entity);
Task<TEntity> SaveSoftDeleteByIdAsync(int id);
Task<TMap> SoftDeleteByIdAsync<TMap>(int id) where TMap : IDto;
Task<TMap> SaveSoftDeleteAsync<TMap>(TEntity entity) where TMap : IDto;
Task<TMap> SaveSoftDeleteByIdAsync<TMap>(int id) where TMap : IDto;
Task SoftDeleteNoReturnAsync(TEntity entity);
Task SaveSoftDeleteNoReturnAsync(TEntity entity);
Task SoftDeleteByIdNoReturnAsync(int id);
Task SaveSoftDeleteByIdNoReturnAsync(int id);
Task SoftDeleteRangeNoReturnAsync(IEnumerable<TEntity> entities);
Task SaveSoftDeleteRangeNoReturnAsync(IEnumerable<TEntity> entities);

// Bulk — direct SQL execution
Task<int> SoftDeleteWhereAsync(Expression<Func<TEntity, bool>> predicate);
Task<int> SoftDeleteByIdsAsync(IEnumerable<int> ids);

// Restore
Task<int> RestoreByIdAsync(int id);
Task<int> RestoreWhereAsync(Expression<Func<TEntity, bool>> predicate);

IEntityState<TEntity> directly changes how EF Core's change tracker watches an entity you already have, without a new database roundtrip. Since 10.0.1, updates release stale tracked instances automatically, so manual detachment is rarely required before an update.

public virtual void ChangeEntityState(TEntity entity, EntityState state)
    => SetLocalState(entity.Id, state);

private void SetLocalState(int id, EntityState state)
{
    var tracked = Table.Local.FirstOrDefault(e => e.Id == id);
    if (tracked is null) return;
    _context.Entry(tracked).State = state;
}

public virtual void ChangeEntityState(int id, EntityState state)
    => SetLocalState(id, state);

public async Task Detach(TEntity entity)
{
    var tracked = await Table.FindAsync(entity.Id);
    if (tracked is null) return;
    _context.Entry(tracked).State = EntityState.Detached;
}

public void DetachLocal(TEntity entity)
    => SetLocalState(entity.Id, EntityState.Detached);

public void DetachLocalById(int id)
    => SetLocalState(id, EntityState.Detached);

ISqlOperations<TEntity> executes parameterized raw SQL statements. Always prefer interpolated methods: every {value} in the interpolated string is converted to a secure SQL parameter automatically, preventing SQL injection.

public virtual IEnumerable<TEntity> FromSqlInterpolated(FormattableString sql)
    => Table.FromSqlInterpolated(sql).ToList();

var rows = repo.FromSqlInterpolated($"SELECT * FROM Product WHERE Price > {minPrice}");

public virtual int ExecuteSqlInterpolated(FormattableString sql)
    => _context.Database.ExecuteSqlInterpolated(sql);

public virtual int ExecuteSqlRaw(string sql, params object[] parameters)
    => _context.Database.ExecuteSqlRaw(sql, parameters);

ISave<TEntity> commits what the non-save mutation methods added. All repositories in one HTTP request share a single DbContext instance, so calling Save() once commits pending changes across all repositories atomically.

public virtual int Save() => _context.SaveChanges();

productRepo.Create(product);
orderRepo.Update(order);
productRepo.Save();          // both saved together in one atomic transaction

public virtual async Task<int> SaveAsync() => await _context.SaveChangesAsync();

[Obsolete("The DbContext is owned by the DI scope and shared with other repositories. " +
          "Disposing it here breaks every other repository in the same request; let the scope dispose it.")]
void Dispose();

These columns are automatically maintained by Muslim.GenericRepository. Never set them manually. All timestamps are in UTC; convert to local timezone exclusively for presentation.

• Never call Dispose(): The DbContext belongs to the request scope and is shared across all repositories in that request.
• Cancellation Tokens: Async methods do not accept CancellationToken parameters in 10.0.1 yet.
• Transactions: There is no explicit custom transaction API needed. To commit several entity changes atomically across multiple repositories, perform your additions/edits and call Save() once.
• Unit Testing: When writing unit tests with a mock database, prefer a relational engine such as SQLite in memory. EF Core's InMemory database provider does not support SQL bulk operations (ExecuteUpdateAsync / ExecuteDeleteAsync).

New in 10.0.1: When building a project that references Muslim.GenericRepository, an optimized guidance skill for AI coding assistants is copied automatically to .agents/skills/muslim-genericrepository/ at the root of your repository.

AI agents that read skills from .agents/skills (such as GitHub Copilot, Codex, Cursor, and Antigravity) use this guidance to write idiomatically correct repository code without guessing method names. Your existing files and other skills are never modified or removed.

To disable automatic skill generation, add this to your project file or Directory.Build.props:

<PropertyGroup>
  <MuslimGenericRepositoryGenerateSkill>false</MuslimGenericRepositoryGenerateSkill>
</PropertyGroup>

Explore the companion packages in the Muslim.* ecosystem for a complete, enterprise-grade architecture: