Menu
Canonical rules for using existing repositories and UnitOfWork from application code. Load when calling repositories or CompleteAsync from use cases.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | repository-usage |
| description | Canonical rules for using existing repositories and UnitOfWork from application code. Load when calling repositories or CompleteAsync from use cases. |
| requires | ["backend-dotnet-csharp"] |
| produces | ["repository-usage","unit-of-work-calls"] |
Load this skill only when the project's Data Access pattern is Repository + UnitOfWork.
Repository and UnitOfWork are always used together. If the pattern is Direct DbContext, use
dbcontext-usage instead — never combine the two for the same task. Query internals (tracking,
includes, projection) come from query-best-practices.
.Update()CompleteAsync() after successful writesSaveResult.IsSuccess after CompleteAsync()AsNoTracking()AnyAsync()Task<TEntity?> GetByIdAsync(Guid id, CancellationToken ct = default);
Task<TEntity?> GetByIdAsNoTrackingAsync(Guid id, CancellationToken ct = default);
Task AddAsync(TEntity entity, CancellationToken ct = default);
void Delete(TEntity entity);
IProductRepository ProductRepository { get; }
Task<SaveResult> CompleteAsync(CancellationToken ct = default);
Task BeginTransactionAsync(CancellationToken ct = default);
Task CommitTransactionAsync(CancellationToken ct = default);
Task RollbackTransactionAsync(CancellationToken ct = default);
Product? product = await _unitOfWork.ProductRepository
.GetByIdAsync(request.Id, cancellationToken);
if (product is null)
return Result<UpdateProductResponseDto>.Failure(HttpStatusCode.NotFound)
.WithErrors(["Product not found"]);
(List<string> errors, bool updated) = product.UpdateName(request.Name);
if (!updated)
return Result<UpdateProductResponseDto>.Failure(HttpStatusCode.BadRequest)
.WithErrors(errors);
SaveResult saveResult = await _unitOfWork.CompleteAsync(cancellationToken);
if (!saveResult.IsSuccess)
return Result<UpdateProductResponseDto>.Failure(HttpStatusCode.InternalServerError)
.WithErrors([saveResult.ErrorMessage]);
return Result<UpdateProductResponseDto>.Success(HttpStatusCode.OK);
(List<string> errors, Product? product) = Product.Create(request.Name, request.Price);
if (product is null)
return Result<CreateProductResponseDto>.Failure(HttpStatusCode.BadRequest)
.WithErrors(errors);
await _unitOfWork.ProductRepository.AddAsync(product, cancellationToken);
SaveResult saveResult = await _unitOfWork.CompleteAsync(cancellationToken);
if (!saveResult.IsSuccess)
return Result<CreateProductResponseDto>.Failure(HttpStatusCode.InternalServerError)
.WithErrors([saveResult.ErrorMessage]);
return Result<CreateProductResponseDto>.Success(HttpStatusCode.Created);
Product? product = await _unitOfWork.ProductRepository
.GetByIdAsNoTrackingAsync(request.Id, cancellationToken);
if (product is null)
return Result<ProductResponseDto>.Failure(HttpStatusCode.NotFound)
.WithErrors(["Product not found"]);
return Result<ProductResponseDto>.Success(HttpStatusCode.OK)
.WithPayload(product.ToProductResponseDto());
Product? product = await _unitOfWork.ProductRepository
.GetByIdAsync(request.Id, cancellationToken);
if (product is null)
return Result<DeleteProductResponseDto>.Failure(HttpStatusCode.NotFound)
.WithErrors(["Product not found"]);
_unitOfWork.ProductRepository.Delete(product);
SaveResult saveResult = await _unitOfWork.CompleteAsync(cancellationToken);
if (!saveResult.IsSuccess)
return Result<DeleteProductResponseDto>.Failure(HttpStatusCode.InternalServerError)
.WithErrors([saveResult.ErrorMessage]);
return Result<DeleteProductResponseDto>.Success(HttpStatusCode.NoContent);
public interface IProductRepository
{
Task<Product?> GetByNameAsync(string name, CancellationToken ct = default);
Task<Product?> GetByNameForUpdateAsync(string name, CancellationToken ct = default);
Task<IReadOnlyList<Product>> GetAllAsync(CancellationToken ct = default);
}
public async Task<Product?> GetByNameAsync(string name, CancellationToken ct = default)
{
return await AppDbContext.Products
.AsNoTracking()
.FirstOrDefaultAsync(p => p.Name == name, ct);
}
public async Task<Product?> GetByNameForUpdateAsync(string name, CancellationToken ct = default)
{
return await AppDbContext.Products
.FirstOrDefaultAsync(p => p.Name == name, ct);
}
// ❌ NEVER call .Update()
_appDbContext.Products.Update(product);
// ❌ NEVER call SaveChangesAsync directly
await _appDbContext.SaveChangesAsync(cancellationToken);
// ❌ NEVER ignore SaveResult.IsSuccess
SaveResult result = await _unitOfWork.CompleteAsync(cancellationToken);
// ❌ NEVER load with AsNoTracking when you intend to modify
Product? product = await _unitOfWork.ProductRepository
.GetByIdAsNoTrackingAsync(id, cancellationToken);
Structure and rules for .NET projects using Clean Architecture with DDD. Use when the project has complex business domain, multiple use cases, need to test business logic in isolation, or when the system is enterprise, e-commerce, ERP, CRM, or any rich domain. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.
Structure and rules for .NET projects using Hexagonal Architecture (Ports & Adapters). Use when the project has multiple input channels (API, CLI, message queue), need to test the domain in isolation, or when adapters change frequently. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.
Structure and rules for .NET projects using Onion Architecture. Use when the project has a strong domain-centric focus with DDD, aggregate roots, and the Specification pattern. All dependencies point inward toward the domain core. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.
Canonical DbContext setup and registration rules for EF Core. Load when creating or modifying DbContext classes or their DI wiring.
Pure LINQ standards for .NET 10 projects. Covers language operators, query composition, projection patterns, filtering, grouping, and performance best practices over IEnumerable<T> and IQueryable<T>. Load when writing or reviewing LINQ expressions in any layer. DO NOT load expecting EF Core-specific methods (ToListAsync, AsNoTracking, Include, ExecuteUpdateAsync) — those belong to `backend/dotnet/orms/ef-core/query-best-practices/SKILL.md`.
Canonical rules for using AppDbContext DIRECTLY from application code (use cases / handlers) when the project's data-access pattern is Direct DbContext — no repositories, no UnitOfWork. Load when the chosen pattern is Direct DbContext and a use case reads or writes data. This is the counterpart to repository-usage; never load both for the same task.