RCommon.Linq2Db 2.4.1

RCommon.Linq2Db

Linq2Db implementation of the RCommon persistence abstractions. Provides a LINQ-enabled repository backed by Linq2Db's DataConnection, supporting composable queries, eager loading, pagination, and integration with the RCommon data store factory and domain event tracking.

Features

• Linq2DbRepository<TEntity> implementing ILinqRepository<T>, IReadOnlyRepository<T>, and IWriteOnlyRepository<T>
• Full IQueryable<T> support built on Linq2Db's ITable<T> for composable LINQ queries
• Eager loading via Include / ThenInclude mapped to Linq2Db's LoadWith / ThenLoad API
• Paginated query results with ordering support via IPaginatedList<T>
• Expression-based and specification-based querying with FindQuery returning IQueryable<T>
• Bulk delete via Linq2Db's DeleteAsync on queryable expressions
• Named data store support for multi-database scenarios through IDataStoreFactory
• RCommonDataConnection base class implementing IDataStore for seamless factory resolution
• Fluent DI configuration using AddLinqToDBContext under the hood
• Domain event tracking integrated into add, update, and delete operations
• Soft delete -- entities implementing ISoftDelete are automatically filtered on reads and logically deleted on writes
• Multitenancy -- entities implementing IMultiTenant are automatically filtered by tenant on reads and stamped with TenantId on writes
• Targets .NET 8, .NET 9, and .NET 10

Installation

dotnet add package RCommon.Linq2Db

Usage

// Configure in Program.cs or Startup
builder.Services.AddRCommon()
    .WithPersistence<Linq2DbPersistenceBuilder>(linq2Db =>
    {
        linq2Db.AddDataConnection<ApplicationDataConnection>("ApplicationDb",
            (serviceProvider, options) =>
                options.UseSqlServer(builder.Configuration.GetConnectionString("ApplicationDb")));

        linq2Db.SetDefaultDataStore(defaults =>
            defaults.DefaultDataStoreName = "ApplicationDb");
    });

Your data connection must inherit from RCommonDataConnection:

public class ApplicationDataConnection : RCommonDataConnection
{
    public ApplicationDataConnection(DataOptions options)
        : base(options) { }
}

Then inject and use the repository abstractions:

public class CustomerService
{
    private readonly ILinqRepository<Customer> _customerRepo;

    public CustomerService(ILinqRepository<Customer> customerRepo)
    {
        _customerRepo = customerRepo;
    }

    public async Task<ICollection<Customer>> GetActiveCustomersAsync()
    {
        return await _customerRepo.FindAsync(c => c.IsActive);
    }

    public async Task<IPaginatedList<Customer>> GetCustomersPagedAsync(int page, int pageSize)
    {
        return await _customerRepo.FindAsync(
            c => c.IsActive,
            c => c.LastName,
            orderByAscending: true,
            pageNumber: page,
            pageSize: pageSize);
    }
}

Soft Delete and Multitenancy

Linq2DbRepository<TEntity> automatically supports soft delete and multitenancy when your entities implement the opt-in interfaces:

using RCommon.Entities;

public class Customer : BusinessEntity<int>, ISoftDelete, IMultiTenant
{
    public string Name { get; set; }
    public bool IsDeleted { get; set; }
    public string? TenantId { get; set; }
}

Reads automatically exclude soft-deleted records and scope to the current tenant:

// Both filters applied transparently
var customers = await _customerRepo.FindAsync(c => c.IsActive);

Writes automatically stamp the tenant and support logical deletion:

// TenantId stamped automatically from ITenantIdAccessor
await _customerRepo.AddAsync(new Customer { Name = "Acme" });

// Soft delete — sets IsDeleted = true, performs UPDATE via Linq2Db
await _customerRepo.DeleteAsync(customer, isSoftDelete: true);

Key Types

Documentation

For full documentation, visit rcommon.com.

Related Packages

• RCommon.Persistence - Core persistence abstractions (required dependency)
• RCommon.EFCore - Entity Framework Core implementation
• RCommon.Dapper - Dapper implementation

License

Licensed under the Apache License, Version 2.0.