Mecesoft.Repository 1.0.1

Mecesoft.Repository

Lightweight, generic repository implementation for Entity Framework Core. Provides a minimal API surface for common data access operations with optional soft-delete awareness (IgnoreQueryFilters) and tracking control (AsNoTracking/AsTracking).

• Target Framework: .NET 9 (net9.0)
• Dependency: Microsoft.EntityFrameworkCore

Installation

NuGet (once published):

Install-Package Mecesoft.Repository

or with dotnet CLI:

dotnet add package Mecesoft.Repository

Quick Start

using Microsoft.EntityFrameworkCore;
using Mecesoft.Repository;

// Your DbContext
public sealed class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
{
    public DbSet<User> Users => Set<User>();
}

public class User
{
    public string Id { get; set; } = Guid.NewGuid().ToString();
    public string Name { get; set; } = string.Empty;
    // Optional soft delete column if you use global query filters in your context
    public bool IsDeleted { get; set; }
}

// Register in DI (Program.cs)
// services.AddDbContext<AppDbContext>(...);
// services.AddScoped<IRepository<User>, Repository<User, AppDbContext>>();

// Use in a service
public class UserService(IRepository<User> users, AppDbContext db) 
{
    public async Task<string?> CreateAsync(string name, CancellationToken ct)
    {
        var entity = new User { Name = name };
        await users.AddAsync(entity, ct);
        await db.SaveChangesAsync(ct); // repository does not call SaveChanges
        return entity.Id;
    }

    public Task<User?> GetAsync(string id, CancellationToken ct)
        => users.GetByExpressionAsync(u => u.Id == id, ct);
}

Repository API Overview

The repository interface is IRepository<TEntity>.

• Query

  • IQueryable<TEntity> GetAll(bool includeDeleted = false, bool asNoTracking = true)
  • IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> predicate, bool includeDeleted = false, bool asNoTracking = true)
  • TEntity? GetByExpression(...) and Task<TEntity?> GetByExpressionAsync(...)
  • Task<TResult?> GetByExpressionDtoAsync<TResult>(predicate, selector, ...) (projection)
  • TEntity? GetFirst(...) and Task<TEntity?> GetFirstAsync(...)
  • bool Any(...) and Task<bool> AnyAsync(...)

• Mutations

  • void Add(TEntity entity) and Task AddAsync(TEntity entity, CancellationToken)
  • Task AddRangeAsync(ICollection<TEntity> entities, CancellationToken)
  • void Update(TEntity entity) and void UpdateRange(ICollection<TEntity> entities)
  • void Delete(TEntity entity) and void DeleteRange(ICollection<TEntity> entities)
  • Task DeleteByIdAsync(string id)
  • Task DeleteByExpressionAsync(Expression<Func<TEntity, bool>> expression, CancellationToken)

• Tracking helpers

  • GetByExpressionWithTrackingAsync(...) and GetAllExpressionWithTrackingAsync(...) to force tracking even when global no-tracking is used.

Notes:

• The repository does not call SaveChanges/SaveChangesAsync. Commit using your DbContext or a Unit of Work.
• Soft delete: pass includeDeleted: true to bypass EF Core global query filters.
• Tracking: for read operations, default is AsNoTracking to improve performance. Set asNoTracking: false when you plan to update returned entities.

Soft Delete and Global Filters

If you use global filters (e.g. modelBuilder.Entity<User>().HasQueryFilter(x => !x.IsDeleted)), you can opt-in to include filtered rows with includeDeleted: true in query methods.

License

This project is licensed under the MIT License - see the LICENSE file for details.