Generic CRUD Services that Never Throw for .NET 10

Muslim.GenericService is the service layer that sits on top of Muslim.GenericRepository. One generic class, Service<TEntity>, calls the repository for every operation and returns a Result<T> from Muslim.Result. Repository exceptions are caught and turned into a failed result; DTOs passed to create and update are validated first. Every write commits on its own.

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

First .NET 10 release (the last published version is 8.0.0). No public member was added, removed or changed.

Install the service and the repository implementation. The service package depends only on the two interface packages, so the repository itself, and your database provider, are added by you:

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

using AutoMapper;
using FluentValidation;
using Muslim.EntityAndDto.Dtos;
using Muslim.EntityAndDto.Entitys;

public class Note : Entity
{
    public string Title { get; set; } = "";
}

public class NoteDto : Dto
{
    public string Title { get; set; } = "";
}

public class NoteDtoValidator : AbstractValidator<NoteDto>
{
    public NoteDtoValidator() => RuleFor(x => x.Title).NotEmpty();
}

public class NoteProfile : Profile
{
    public NoteProfile() => CreateMap<Note, NoteDto>().ReverseMap();
}

using FluentValidation;
using Muslim.GenericRepository.Interface;
using Muslim.GenericRepository.Repositories;
using Muslim.GenericService;
using Muslim.Helpers;
using Muslim.Inject;

builder.Services.AddDbContext<AppDbContext>(o => o.UseSqlServer(connectionString));
builder.Services.AddAutoMapper(typeof(NoteProfile));
builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ICurrentUser, HttpCurrentUser>();
builder.Services.AddValidatorsFromAssemblyContaining<NoteDtoValidator>();   // scoped validators are fine
builder.Services.AddAutoInjection(typeof(INoteService).Assembly);           // INoteRepository, INoteService
builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));  // IRepository<T> for any entity
builder.Services.AddScoped(typeof(IService<>), typeof(Service<>));        // IService<T> for any entity
BaseRepository.SetDbContext<AppDbContext>();

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

using Muslim.GenericRepository.Interface;
using Muslim.GenericRepository.Repositories;
using Muslim.GenericService;

public interface INoteRepository : IRepository<Note> { }
public class NoteRepository : Repository<Note>, INoteRepository { }

public interface INoteService : IService<Note>
{
    Task<int> CountArchivedAsync();
}

// Pass the repository to the base constructor.
public class NoteService(INoteRepository repository) : Service<Note>(repository), INoteService
{
    public Task<int> CountArchivedAsync() => CountAsync(x => x.IsDeleted);
}

[ApiController, Route("notes")]
public class NotesController(INoteService notes) : ControllerBase
{
    [HttpGet("{id:int}")]
    public async Task<IActionResult> Get(int id)
    {
        var result = await notes.GetByIdAsync<NoteDto>(id);
        if (!result.IsSuccess) return BadRequest(result);
        return result.Response is null ? NotFound() : Ok(result);
    }

    [HttpPost]
    public async Task<IActionResult> Create(NoteDto request)
    {
        var result = await notes.CreateAsync(request);   // validated, inserted, Id filled
        return result.IsSuccess ? Ok(result) : BadRequest(result);
    }
}

Setup Notes & Best Practices

• Register a validator for every DTO you pass to Create* or Update*, even an empty AbstractValidator<TDto>. A DTO without one fails validation.
• A per-entity repository (NoteRepository : Repository<Note>, INoteRepository) is registered by AddAutoInjection as INoteRepository only. The parameterless Service<T>() needs IRepository<T>, so either pass the repository to the base constructor or add the open-generic line.
• In background work wrap each unit of work in InjectExtensions.RunInScopeAsync; there is no request scope there.
• Projects that only call services (a controller layer, another library) can reference Muslim.GenericService.Interface alone.

IService<TEntity> is the full surface for one entity. It lives in Muslim.GenericService.Interface, namespace Muslim.GenericService; the twelve interfaces it inherits are in Muslim.GenericService.Interfaces. Derive a per-entity interface from it to add methods; Muslim.Inject registers the implementation.

public interface IService<TEntity> : IAutoInjection
    , IGetAllService<TEntity>, IFindService<TEntity>, IGetByIdService<TEntity>
    , IFirstOrDefaultService<TEntity>, ISingleOrDefaultService<TEntity>
    , ICreateService<TEntity>, IUpdateService<TEntity>
    , IDeleteService<TEntity>, ISoftDeleteService<TEntity>
    , IAnyService<TEntity>, ICountService<TEntity>, IExecuteSqlService<TEntity>
    where TEntity : Entity

// Muslim.GenericService/TypeForwarders.cs
[assembly: TypeForwardedTo(typeof(Muslim.GenericService.IService<>))]
[assembly: TypeForwardedTo(typeof(IFindService<>))]
// ... one line for each of the 13 interfaces

Service<TEntity> is a partial class split by concern, like Repository<TEntity>. Each file declares the part interface it implements:

public Service(IRepository<TEntity> repository)
{
    _repository = repository;
}

public Service()
{
    _repository = InjectExtensions.Inject<IRepository<TEntity>>();
}

// Every operation goes through this accessor.
private IRepository<TEntity> Repository => _repository ?? throw new InvalidOperationException(
    $"No IRepository<{typeof(TEntity).Name}> is available to {GetType().Name}. Pass one to the constructor " +
    "(for example a per-entity repository injected into a derived service), or register the open generic: " +
    "services.AddScoped(typeof(IRepository<>), typeof(Repository<>)).");

Extending a service

All public methods are virtual. Override one to add rules, and call base to keep validation and error handling:

public class UserService(IUserRepository repository) : Service<User>(repository), IUserService
{
    public override async Task<Result<TMap>> CreateAsync<TMap>(TMap dto)
    {
        if (dto is CreateUserDto c && await AnyAsync(x => x.Email == c.Email) == 1)
            return Result<TMap>.Fail("Email already registered");
        return await base.CreateAsync(dto);
    }
}

Every method except the counts and raw SQL returns Result<T>. Read it instead of wrapping calls in try/catch:

IGetByIdService<TEntity> loads one row by primary key, as an entity or as a DTO. A missing id is a success with Response == null.

public virtual Result<TEntity> GetById(int id)
{
    try
    {
        var entity = Repository.GetById(id);
        return Result<TEntity>.Success(entity);
    }
    catch (Exception e)
    {
        return Result<TEntity>.Exception(e);
    }
}

public virtual async Task<Result<TMap>> GetByIdAsync<TMap>(int id) where TMap : IDto
{
    try
    {
        var dto = await Repository.GetByIdAsync<TMap>(id);
        return Result<TMap>.Success(dto);
    }
    catch (Exception e)
    {
        return Result<TMap>.Exception(e);
    }
}

All IGetByIdService Overloads

Result<TEntity> GetById(int id);
Task<Result<TEntity>> GetByIdAsync(int id);
Result<TMap> GetById<TMap>(int id) where TMap : IDto;
Task<Result<TMap>> GetByIdAsync<TMap>(int id) where TMap : IDto;

IGetAllService<TEntity> loads every row. On a table that grows without limit, page with a filter instead.

public virtual async Task<Result<List<TMap>>> GetAllAsync<TMap>() where TMap : IDto
{
    try
    {
        var dtos = await Repository.GetAllAsync<TMap>();
        return Result<List<TMap>>.Success(dtos);
    }
    catch (Exception e)
    {
        return Result<List<TMap>>.Exception(e);
    }
}

All IGetAllService Overloads

Result<List<TEntity>> GetAll();
Task<Result<List<TEntity>>> GetAllAsync();
Result<List<TMap>> GetAll<TMap>() where TMap : IDto;
Task<Result<List<TMap>>> GetAllAsync<TMap>() where TMap : IDto;

IFindService<TEntity> returns many rows, by an IFilter<T> from Muslim.Filter or by a condition, and fills Page. What Page.Count means depends on the overload:

public virtual async Task<Result<List<TMap>>> FindAsync<TMap>(IFilter<TEntity> filter) where TMap : IDto
{
    try
    {
        var dtos = await Repository.FindAsync<TMap>(filter);
        var count = await filter.ApplyFilterOnly(Repository.Query).CountAsync();
        var result = Result<List<TMap>>.Success(dtos, count, filter.PageSize);
        result.Filter = filter;
        return result;
    }
    catch (Exception e)
    {
        return Result<List<TMap>>.Exception(e);
    }
}

public class UserFilter : Filter<User>
{
    public string? Name { get; set; }
    protected override void ApplyFilter() => WhereIfNotEmpty(Name, n => x => x.Name.Contains(n));
}

// GET /users?name=al&pageIndex=1&pageSize=20&sortColumn=Name, bound to a UserFilter
var page = await users.FindAsync<UserDto>(filter);   // Response: 20 rows, Page.Count: total

public virtual async Task<Result<List<TEntity>>> FindAsync(IFilter<TEntity> filter)
{
    try
    {
        // isTracking selects the entity overload; see Find(IFilter<TEntity>).
        var entities = await Repository.FindAsync(filter, isTracking: true);
        // Rows matching the filter, as in Find(filter); this used to count the whole table.
        var count = await filter.ApplyFilterOnly(Repository.Query).CountAsync();
        return Result<List<TEntity>>.Success(entities, count, filter.PageSize);
    }
    catch (Exception e)
    {
        return Result<List<TEntity>>.Exception(e);
    }
}

public virtual async Task<Result<List<TEntity>>> FindAsync(Expression<Func<TEntity, bool>> condition, int pageSize = 0)
{
    try
    {
        var entities = await Repository.FindAsync(condition);
        // Matching rows, as in Find(condition); this used to count the whole table.
        var count = await Repository.CountAsync(condition);
        return Result<List<TEntity>>.Success(entities, count, pageSize);
    }
    catch (Exception e)
    {
        // Was the only Find overload that wrote to the console and rethrew.
        return Result<List<TEntity>>.Exception(e);
    }
}

var items = users.Find<UserListItem>(x => x.IsActive, 0, x => new UserListItem { Id = x.Id, Name = x.Name });

All IFindService Overloads

Result<List<TEntity>> Find(IFilter<TEntity> filter);
Result<List<TMap>> Find<TMap>(IFilter<TMap> filter) where TMap : class, IHaveFilter;
Result<List<TMap>> Find<TMap>(IFilter<TEntity> filter) where TMap : IDto;
Result<List<TEntity>> Find(Expression<Func<TEntity, bool>> condition, int pageSize = 0);
Result<List<TMap>> Find<TMap>(Expression<Func<TEntity, bool>> condition, int pageSize = 0,
    Expression<Func<TEntity, TMap>> selector = default!);
Result<List<TMap>> Find<TMap>(Expression<Func<TMap, bool>> condition,
    Expression<Func<TEntity, TMap>> selector, int pageSize = 0);

Task<Result<List<TEntity>>> FindAsync(IFilter<TEntity> filter);
Task<Result<List<TEntity>>> FindAsync(Expression<Func<TEntity, bool>> condition, int pageSize = 0);
Task<Result<List<TMap>>> FindAsync<TMap>(IFilter<TEntity> filter) where TMap : IDto;
Task<Result<List<TMap>>> FindAsync<TMap>(Expression<Func<TEntity, bool>> condition,
    int pageSize = 0, Expression<Func<TEntity, TMap>> selector = default!);
Task<Result<List<TMap>>> FindAsync<TMap>(Expression<Func<TMap, bool>> condition,
    Expression<Func<TEntity, TMap>> selector, int pageSize = 0);

// On the class only, not on IService<T>:
Task<Result<List<TMap>>> FindAsync<TMap>(IFilter<TMap> filter) where TMap : class, IHaveFilter;

IFirstOrDefaultService<TEntity> returns the first match, as an entity or projected. No match is a success with Response == null.

var found = await notes.FirstOrDefaultAsync<NoteDto>((Note x) => x.Title == "final");

All IFirstOrDefaultService Overloads

Result<TEntity> FirstOrDefault();
Result<TMap> FirstOrDefault<TMap>() where TMap : IDto;
Result<TEntity> FirstOrDefault(Expression<Func<TEntity, bool>> condition);
Result<TMap> FirstOrDefault<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto;
Result<TMap> FirstOrDefault<TMap>(Expression<Func<TEntity, bool>> condition,
    Expression<Func<TEntity, TMap>> selector);

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

ISingleOrDefaultService<TEntity> returns the only match. No match succeeds with null; more than one match is a failed result carrying EF Core's InvalidOperationException message. The same CS0121 rule as FirstOrDefault applies to the <TMap> forms, sync and async.

All ISingleOrDefaultService Overloads

Result<TEntity> SingleOrDefault(Expression<Func<TEntity, bool>> condition);
Result<TMap> SingleOrDefault<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto;
Result<TMap> SingleOrDefault<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto;
Task<Result<TEntity>> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> condition);
Task<Result<TMap>> SingleOrDefaultAsync<TMap>(Expression<Func<TEntity, bool>> condition) where TMap : IDto;
Task<Result<TMap>> SingleOrDefaultAsync<TMap>(Expression<Func<TMap, bool>> condition) where TMap : IDto;

Existence checks. These return plain values, not Result<T>:

public virtual async Task<int> AnyAsync(Expression<Func<TEntity, bool>> condition)
{
    try
    {
        return await Repository.AnyAsync(condition) ? 1 : 0;
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        return -1;
    }
}

All IAnyService Overloads

int Any(Expression<Func<TEntity, bool>> condition);        // 1, 0, or -1 on error
bool Any();                                                   // false on error
Task<int> AnyAsync(Expression<Func<TEntity, bool>> condition);
Task<bool> AnyAsync();

Row counts, optionally filtered, run as SQL COUNT. Every overload returns -1 on error and writes the exception to the console.

All ICountService Overloads

int Count();
Task<int> CountAsync();
int Count(Expression<Func<TEntity, bool>> condition);
Task<int> CountAsync(Expression<Func<TEntity, bool>> condition);

ICreateService<TEntity> inserts and commits. DTO forms are validated before anything touches the database; the entity form is not. The repository fills the audit columns.

public virtual async Task<Result<TMap>> CreateAsync<TMap>(TMap dto) where TMap : IDto
{
    try
    {
        var validatorError = Validate(dto, out var isValid);

        if (!isValid)
        {
            var result = Result<TMap>.ValidatorFail(validatorError);
            result.Response = dto;
            return result;
        }

        dto = await Repository.SaveCreateAsync<TMap, TMap>(dto);
        return Result<TMap>.Success(dto);
    }
    catch (Exception e)
    {
        return Result<TMap>.Exception(e);
    }
}

var result = await users.CreateAsync<UserDto, CreateUserDto>(request);   // in: CreateUserDto, out: UserDto

All ICreateService Overloads

Result<TMap> Create<TMap>(TMap dto) where TMap : IDto;
Result<TResult> Create<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
Result<List<TMap>> CreateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
Task<Result<TMap>> CreateAsync<TMap>(TMap dto) where TMap : IDto;
Task<Result<TEntity>> CreateAsync(TEntity entity);                 // no validation
Task<Result<TResult>> CreateAsync<TResult, TMap>(TMap dto) where TMap : IDto where TResult : IDto;
Task<Result<List<TMap>>> CreateRangeAsync<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;

IUpdateService<TEntity> updates from DTOs that carry Id. DTOs are validated first, any tracked copy of the row is detached, and the repository keeps CreatedBy/CreatedDate and stamps UpdateBy/UpdateDate. The same DTO is returned, not a re-read row. A missing id is a failed result.

public virtual async Task<Result<IEnumerable<TMap>>> UpdateRangeAsync<TMap>(IEnumerable<TMap> dtos)
    where TMap : IDto
{
    try
    {
        // Enumerated once: a lazy sequence used to be validated, saved and returned as three
        // different sets of objects.
        var list = dtos.ToList();
        var validatorErrors = new List<ValidatorError>();
        var isValid = true;
        foreach (var dto in list)
        {
            var errors = Validate(dto, out var _isValid);
            if (_isValid) continue;

            validatorErrors.AddRange(errors);
            isValid = isValid && _isValid;
        }

        if (!isValid) return Result<IEnumerable<TMap>>.ValidatorFail(validatorErrors);

        // Detach every row being saved, as UpdateAsync does.
        foreach (var dto in list)
            Repository.ChangeEntityState(dto.Id, EntityState.Detached);

        await Repository.SaveUpdateRangeAsync(list);
        return Result<IEnumerable<TMap>>.Success(list);
    }
    catch (Exception e)
    {
        return Result<IEnumerable<TMap>>.Exception(e);
    }
}

All IUpdateService Overloads

Result<TMap> Update<TMap>(TMap dto) where TMap : IDto;
Result<IEnumerable<TMap>> UpdateRange<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;
Task<Result<TMap>> UpdateAsync<TMap>(TMap dto) where TMap : IDto;
Task<Result<IEnumerable<TMap>>> UpdateRangeAsync<TMap>(IEnumerable<TMap> dtos) where TMap : IDto;

IDeleteService<TEntity> removes rows. Each call commits; a missing id is a failed result.

// Result.Create() starts as a failed "not found" result, so a range where every delete
// succeeded used to come back with IsSuccess = false. AddError below marks real failures.
var result = new Result<List<TMap>> { IsSuccess = true };
result.Response = new List<TMap>();

foreach (var i in id)
{
    try
    {
        var dto = await Repository.SaveDeleteByIdAsync<TMap>(i);
        result.Response.Add(dto);
    }
    catch (Exception e)
    {
        result.AddError(e.Message);
    }
}

return result;

ISoftDeleteService<TEntity> keeps the row and sets IsDeleted, DeletedDate and DeletedBy. Each single and range method detaches a tracked copy of the row first.

public virtual async Task<Result<TMap>> SoftDeleteByIdAsync<TMap>(int id) where TMap : IDto
{
    try
    {
        Repository.ChangeEntityState(id, EntityState.Detached);
        var dto = await Repository.SaveSoftDeleteByIdAsync<TMap>(id);
        return Result<TMap>.Success(dto);
    }
    catch (Exception e)
    {
        return Result<TMap>.Exception(e);
    }
}

All ISoftDeleteService Overloads

// Return mapped DTO
Result<TMap> SoftDelete<TMap>(TEntity entity) where TMap : IDto;
Result<TMap> SoftDeleteById<TMap>(int id) where TMap : IDto;
Result<IEnumerable<TMap>> SoftDeleteRange<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
Result<IEnumerable<TMap>> SoftDeleteRangeByIds<TMap>(IEnumerable<int> id) where TMap : IDto;
Task<Result<TMap>> SoftDeleteAsync<TMap>(TEntity entity) where TMap : IDto;
Task<Result<TMap>> SoftDeleteByIdAsync<TMap>(int id) where TMap : IDto;
Task<Result<IEnumerable<TMap>>> SoftDeleteRangeAsync<TMap>(IEnumerable<TEntity> entities) where TMap : IDto;
Task<Result<IEnumerable<TMap>>> SoftDeleteRangeByIdsAsync<TMap>(IEnumerable<int> id) where TMap : IDto;

// No return
Result<bool> SoftDeleteNoReturn(int id);
Task<Result<bool>> SoftDeleteNoReturnAsync(int id);
Task<Result<bool>> SoftDeleteRangeNoReturnAsync(IEnumerable<int> ids);

// Bulk SQL and restore
Task<Result<int>> SoftDeleteWhereAsync(Expression<Func<TEntity, bool>> predicate);
Task<Result<int>> SoftDeleteByIdsAsync(IEnumerable<int> ids);
Task<Result<int>> RestoreByIdAsync(int id);
Task<Result<int>> RestoreWhereAsync(Expression<Func<TEntity, bool>> predicate);

Raw SQL through the repository. The execute methods return affected rows, or -1 on error; FromSqlInterpolated returns entities, or null on error.

All IExecuteSqlService Overloads

Task<int> ExecuteSqlInterpolatedAsync(FormattableString sql);
int ExecuteSqlInterpolated(FormattableString sql);
int ExecuteSqlRaw(string sql, params object[] parameters);
Task<int> ExecuteSqlRawAsync(string sql, params object[] parameters);
IEnumerable<TEntity> FromSqlInterpolated(FormattableString sql);

Create* and Update* run FluentValidation through Muslim.Validator before writing. Validators are resolved from the current Muslim.Inject request scope, so scoped validators (the default of AddValidatorsFromAssemblyContaining) work:

// Services/Service.cs
private static List<ValidatorError> Validate<TDto>(TDto dto, out bool isValid)
    => InjectExtensions.TryInject<IServiceProvider>(out var provider)
        ? ValidateResult.Errors(dto, provider, out isValid)
        : ValidateResult.Errors(dto, out isValid);

• A validator for every DTO: without an IValidator<TDto> the call fails with “No validators were found” / “No Property To Validate”. An empty AbstractValidator<TDto> is enough.
• Fallback: outside a Muslim.Inject scope, the provider given to ValidateResult.SetServiceProvider is used. With neither, writes return a failed result: “No service provider is configured”.
• Ranges: CreateRange* and UpdateRange* validate every item before saving any of them.
• Entities: CreateAsync(TEntity) is not validated.

• One call, one transaction: every service write commits on its own. For several writes in one transaction, use the repositories' staging methods (Create, Update, Delete) and one Save().
• Cancellation Tokens: async methods do not take a CancellationToken in 10.0.1; adding them would break implementers of the interfaces.
• Plain-value methods: Any, Count, ExecuteSql* and FromSqlInterpolated return -1, false or null on error and write the exception to the console.
• Unit Testing: construct the service with a repository (new NoteService(fakeRepository)), or use SQLite in memory with the full wiring. The ambient provider is process-wide: call InjectExtensions.Reset() in setup and teardown and disable test parallelization.
• AutoMapper advisory: AutoMapper 12.0.1, which arrives with Muslim.GenericRepository, has a published high-severity advisory (GHSA-rvv3-g6hj-g44x).

New in 10.0.1: when a project that references Muslim.GenericService builds, a short guide for AI coding agents (SKILL.md plus two references) is copied to .agents/skills/muslim-genericservice/ at the repository root. Installing or restoring alone does nothing; start a new agent session after the first build.

Agents that read .agents/skills (such as Codex, GitHub Copilot in VS Code, Gemini CLI, Cursor and OpenCode) can use it. Claude Code reads .claude/skills/ instead; copy the folder there if you use it. Your own files, edited files, other skills and AGENTS.md are never overwritten, and removing the package does not delete the folder.

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

<PropertyGroup>
  <MuslimGenericServiceGenerateSkill>false</MuslimGenericServiceGenerateSkill>
</PropertyGroup>

Explore the companion packages in the Muslim.* ecosystem: