👁 Image
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.