BB84.EntityFrameworkCore.Repositories 4.5.725

BB84.EntityFrameworkCore.Repositories

This package provides the default repository implementations and DatabaseFacadeExtensions for calling stored procedures and SQL functions.

Installation

dotnet add package BB84.EntityFrameworkCore.Repositories

Repository implementations

GenericRepository<TEntity>

Abstract base for all repositories. Accepts IDbContext as a constructor parameter. All query methods delegate to PrepareQuery(...), which composes Where, IgnoreQueryFilters, Include, OrderBy, Skip, Take, and AsNoTracking into a single IQueryable<TEntity>. Projection overloads use the protected ApplyProjection(query, selector, fieldSelector) helper.

Streaming reads

StreamAll and StreamByCondition return IAsyncEnumerable<T> instead of IReadOnlyList<T>. They take the same parameters as their GetAllAsync / GetManyByConditionAsync counterparts and go through the same PrepareQuery(...) composition, but the result set is not buffered — rows are yielded as they arrive. Use them for exports, batch jobs and other unbounded reads:

await foreach (Product product in repository.StreamByCondition(
    p => p.IsActive,
    orderBy: q => q.OrderBy(p => p.Name),
    token: token))
{
    await writer.WriteAsync(product, token);
}

Two things to keep in mind:

• The sequence is lazy. It must be enumerated within the lifetime of the IDbContext, and EF Core allows only one active stream per context at a time.
• trackChanges defaults to false and should stay that way for large reads — with tracking enabled the change tracker grows with every yielded entity, which defeats the purpose of streaming.

Subclasses can build their own streaming methods on the protected QueryManyStream(...) helpers, which mirror QueryMany / QueryManyAsync in both the entity and the projection flavour.

IdentityRepository<TEntity, TKey> / IdentityRepository<TEntity>

Extends GenericRepository<TEntity> with key-based GetById, GetByIds, and bulk Delete/Update by ID. The non-generic overload defaults TKey to Guid.

EnumeratorRepository<TEntity, TKey> / EnumeratorRepository<TEntity>

Extends IdentityRepository with GetByName and GetByNames. The non-generic overload defaults TKey to int.

Usage

Inherit from the appropriate base class and inject IDbContext:

public class ProductRepository : IdentityRepository<Product>, IProductRepository
{
    public ProductRepository(IDbContext dbContext) : base(dbContext) { }

    public async Task<IReadOnlyList<Product>> GetByCategoryAsync(
        int categoryId, CancellationToken token = default)
        => await GetManyByConditionAsync(
            p => p.CategoryId == categoryId,
            orderBy: q => q.OrderBy(p => p.Name),
            token: token);
}

public class CategoryRepository : EnumeratorRepository<ProductCategory>, ICategoryRepository
{
    public CategoryRepository(IDbContext dbContext) : base(dbContext) { }
    // GetByName / GetByNames inherited
}

DI registration:

services.AddScoped<IProductRepository, ProductRepository>();
services.AddScoped<ICategoryRepository, CategoryRepository>();

Calling save changes is the responsibility of the caller (unit-of-work pattern):

repository.Create(entity);
await dbContext.SaveChangesAsync(token);

DatabaseFacadeExtensions

Extension methods on DatabaseFacade (context.Database) for calling SQL Server stored procedures and functions safely with parameterized SQL.

Stored procedures

// Returns rows as IReadOnlyList<T>
IReadOnlyList<ReportRow> rows = context.Database.ExecuteProcedure<ReportRow>(
    schema: "dbo",
    name: "usp_GetReport",
    parameters: [new SqlParameter("@FromDate", fromDate)]);

// Non-generic overload returns rows-affected count
int affected = context.Database.ExecuteProcedure(
    schema: "dbo",
    name: "usp_ArchiveOrders",
    parameters: [new SqlParameter("@CutoffDate", cutoff)]);

// Async variants
await context.Database.ExecuteProcedureAsync<ReportRow>(..., cancellationToken);
await context.Database.ExecuteProcedureAsync(..., cancellationToken);

Output parameters are supported — parameters with Direction = ParameterDirection.Output are emitted as @param = @param OUTPUT in the generated SQL.

Table-valued functions

IReadOnlyList<ProductDto> results = context.Database.ExecuteTableFunction<ProductDto>(
    schema: "dbo",
    name: "fn_GetActiveProducts",
    parameters: [new SqlParameter("@CategoryId", categoryId)]);

await context.Database.ExecuteTableFunctionAsync<ProductDto>(..., cancellationToken);

Scalar-valued functions

decimal? total = context.Database.ExecuteScalarFunction<decimal>(
    schema: "dbo",
    name: "fn_GetOrderTotal",
    parameters: [new SqlParameter("@OrderId", orderId)]);

await context.Database.ExecuteScalarFunctionAsync<decimal>(..., cancellationToken);

All methods sanitize schema/name inputs and use parameterized SQL to prevent injection.