Использование Linq2Db в проектах C# .NET

var customers = 
    from c in db.Customers
    where c.Orders.Count > 5 && c.Country == "UK"
    orderby c.CompanyName
    select c;

var result = db.Customers
    .Where(c => Sql.Like(c.ContactName, "A%"))
    .OrderBy(c => c.ContactName)
    .Select(c => new { c.CustomerID, c.ContactName });

[Table("Customers")]
public class Customer
{
    [PrimaryKey, Identity]
    public int Id { get; set; }
    
    [Column("CompanyName"), NotNull]
    public string Name { get; set; }
    
    [Association(ThisKey = "Id", OtherKey = "CustomerId")]
    public List<Order> Orders { get; set; }
}

dotnet add package linq2db

dotnet add package linq2db.SqlServer

dotnet add package linq2db.PostgreSQL

var connection = new DataConnection(
    ProviderName.SqlServer,
    "Server=.;Database=MyDatabase;Trusted_Connection=True;");

services.AddLinqToDb(options =>
    options.UseSqlServer("Server=.;Database=Demo;Trusted_Connection=True;"));

[Table("Products")]
public class Product
{
    [PrimaryKey, Identity]
    public int Id { get; set; }
    
    [Column, NotNull]
    public string Name { get; set; }
    
    [Column(Name = "UnitPrice")]
    public decimal Price { get; set; }
    
    [Column]
    public int CategoryId { get; set; }
    
    [Association(ThisKey = "CategoryId", OtherKey = "Id")]
    public Category Category { get; set; }
}

public class AppDataConnection : DataConnection
{
    public AppDataConnection(string connectionString) 
        : base(ProviderName.SqlServer, connectionString) { }
    
    public ITable<Product> Products => GetTable<Product>();
    public ITable<Category> Categories => GetTable<Category>();
}

// Выборка с фильтрацией
var expensiveProducts = from p in db.Products
                      where p.Price > 100
                      orderby p.Name
                      select p;
 
// Добавление записи
var product = new Product { Name = "New Product", Price = 25.99m, CategoryId = 1 };
db.Insert(product); // Id заполнится автоматически
 
// Обновление
product.Price = 29.99m;
db.Update(product);
 
// Удаление
db.Delete(product);

var query = from p in db.Products
          join c in db.Categories on p.CategoryId equals c.Id
          where c.Name == "Electronics"
          select new { ProductName = p.Name, CategoryName = c.Name, p.Price };

using (var db = new DataConnection(connectionString))
{
    // Создать таблицу на основе модели
    db.CreateTable<Product>();
    
    // Добавить колонку
    db.AddColumn<Product>(x => x.Description);
    
    // Создать индекс
    db.CreateIndex<Product>(nameof(Product.CategoryId));
}

// Явное обновление конкретной записи
db.Update(product);
 
// Частичное обновление - только определённых полей
db.Products
  .Where(p => p.Id == product.Id)
  .Set(p => p.Price, product.Price)
  .Set(p => p.Stock, product.Stock)
  .Update();
 
// Массовое обновление по условию
db.Products
  .Where(p => p.CategoryId == 5)
  .Set(p => p.Discontinued, true)
  .Update();

public class UnitOfWork
{
    private readonly DataConnection _db;
    private readonly Dictionary<object, EntityState> _entities = new();
 
    public UnitOfWork(DataConnection db) => _db = db;
 
    public void TrackEntity(object entity, EntityState state = EntityState.Modified)
    {
        _entities[entity] = state;
    }
 
    public void SaveChanges()
    {
        foreach (var (entity, state) in _entities)
        {
            switch (state)
            {
                case EntityState.Added:
                    _db.Insert(entity);
                    break;
                case EntityState.Modified:
                    _db.Update(entity);
                    break;
                case EntityState.Deleted:
                    _db.Delete(entity);
                    break;
            }
        }
        _entities.Clear();
    }
}

var connection = new DataConnection(
    ProviderName.SqlServer,
    "Server=.;Database=MyDb;Trusted_Connection=True;");

var connection = new DataConnection(
    ProviderName.PostgreSQL,
    "Host=localhost;Database=mydb;Username=postgres;Password=mysecretpassword");

var connection = new DataConnection(
    ProviderName.SQLite,
    "Data Source=mydb.sqlite");

public class MultiDbDataConnection : DataConnection
{
    public MultiDbDataConnection(string providerName, string connectionString) 
        : base(providerName, connectionString) { }
 
    // Специфичные для провайдера методы можно изолировать
    public string GetPagingSyntax()
    {
        return DataProvider.Name switch
        {
            ProviderName.SqlServer => "OFFSET {0} ROWS FETCH NEXT {1} ROWS ONLY",
            ProviderName.PostgreSQL => "OFFSET {0} LIMIT {1}",
            ProviderName.MySql => "LIMIT {0}, {1}",
            _ => throw new NotSupportedException($"Provider {DataProvider.Name} not supported")
        };
    }
}

// Вызов хранимой процедуры без параметров
var results = db.Procedure<Customer>("GetTopCustomers");
 
// С параметрами
var orders = db.Procedure<Order>("GetOrdersByDate",
    new { StartDate = DateTime.Today.AddDays(-30), EndDate = DateTime.Today });
 
// С выходными параметрами
var parameters = new DataParameter("@TotalAmount", null, DataType.Decimal) { Direction = ParameterDirection.Output };
db.Procedure("CalculateOrderTotal", new { OrderId = 12345 }, parameters);
var total = parameters.Value;

// Маппинг табличной функции на метод через расширение
[Sql.Function("fn_GetProducts", ServerSideOnly = true)]
public static ITable<Product> GetProducts(this DataConnection db, int categoryId)
{
    throw new InvalidOperationException();
}
 
// Использование
var electronicsProducts = db.GetProducts(5).Where(p => p.Price > 100);

var connection = new DataConnection(/* ... */);
var schema = connection.DataProvider.GetSchemaProvider().GetSchema(connection);
 
// Построение модели в рантайме
var modelType = new FluentModel()
    .Entity<Customer>()
    .Property(c => c.Id).IsPrimaryKey().IsIdentity()
    .Property(c => c.Name).HasLength(100).IsNotNull()
    .Property(c => c.Email).HasLength(255)
    .Build();

// Слой доступа к данным (DAL)
public interface IProductRepository
{
    Task<List<Product>> GetAllAsync();
    Task<Product> GetByIdAsync(int id);
    Task AddAsync(Product product);
    // и т.д.
}
 
public class ProductRepository : IProductRepository
{
    private readonly IDataContext _db;
    
    public ProductRepository(IDataContext db) => _db = db;
    
    public Task<List<Product>> GetAllAsync() => 
        _db.GetTable<Product>().ToListAsync();
    
    public Task<Product> GetByIdAsync(int id) => 
        _db.GetTable<Product>().FirstOrDefaultAsync(p => p.Id == id);
    
    public async Task AddAsync(Product product)
    {
        await _db.InsertAsync(product);
    }
}

public class ProductService
{
    private readonly IProductRepository _repository;
    
    public ProductService(IProductRepository repository) => 
        _repository = repository;
    
    public async Task<bool> ApplyDiscountAsync(int productId, decimal discount)
    {
        var product = await _repository.GetByIdAsync(productId);
        if (product == null) return false;
        
        product.Price *= (1 - discount / 100);
        await _repository.UpdateAsync(product);
        return true;
    }
}

services.AddLinqToDb(options => 
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
 
services.AddScoped<IProductRepository, ProductRepository>();
services.AddScoped<ProductService>();

var customers = db.Customers
    .LoadWith(c => c.Orders)
    .LoadWith(c => c.Orders.First().OrderDetails)
    .ToList();

// Явная загрузка после получения основного объекта
var customer = db.Customers.First(c => c.Id == 5);
db.LoadWith(customer, c => c.Orders);
 
// Фильтрация связанных данных
var customers = db.Customers
    .LoadWith(c => c.Orders.Where(o => o.OrderDate > DateTime.Now.AddDays(-30)))
    .ToList();

var query = from o in db.Orders
            join c in db.Customers on o.CustomerId equals c.Id
            join e in db.Employees on o.EmployeeId equals e.Id
            where o.OrderDate >= DateTime.Today.AddMonths(-3)
            group new { o, c } by new { e.Id, e.LastName } into g
            orderby g.Sum(x => x.o.TotalAmount) descending
            select new {
                EmployeeId = g.Key.Id,
                EmployeeName = g.Key.LastName,
                OrderCount = g.Count(),
                TotalSales = g.Sum(x => x.o.TotalAmount),
                TopCustomer = g.OrderByDescending(x => x.o.TotalAmount)
                               .Select(x => x.c.CompanyName)
                               .FirstOrDefault()
            };

var customers = db.Customers
    .Where(c => Sql.Like(c.CompanyName, "A%") && Sql.Between(c.Orders.Count, 5, 10))
    .OrderBy(c => Sql.Ext.DatePart("year", c.RegistrationDate))
    .ToList();

// Определение компилированного запроса
private static readonly Func<DataConnection, string, IEnumerable<Customer>> GetCustomersByCountry =
    CompiledQuery.Compile<DataConnection, string, IEnumerable<Customer>>(
        (db, country) => db.GetTable<Customer>().Where(c => c.Country == country)
    );
 
// Использование
var ukCustomers = GetCustomersByCountry(db, "UK").ToList();

// Кеширование результатов запроса
public async Task<List<Product>> GetPopularProductsAsync()
{
    const string cacheKey = "PopularProducts";
    
    if (!_cache.TryGetValue(cacheKey, out List<Product> products))
    {
        products = await _db.Products
            .Where(p => p.OrderDetails.Sum(od => od.Quantity) > 100)
            .OrderByDescending(p => p.OrderDetails.Sum(od => od.Quantity))
            .Take(20)
            .ToListAsync();
            
        _cache.Set(cacheKey, products, TimeSpan.FromMinutes(15));
    }
    
    return products;
}

// Асинхронная выборка
var products = await db.Products
    .Where(p => p.Category.Name == "Electronics")
    .ToListAsync();
 
// Асинхронное добавление
await db.InsertAsync(newProduct);
 
// Асинхронное обновление
await db.UpdateAsync(product);
 
// Асинхронное удаление
await db.DeleteAsync(product);

// Вставка множества записей одним запросом
await db.BulkCopyAsync(newProducts);
 
// Пакетное обновление
var affected = await db.Products
    .Where(p => p.CategoryId == 5)
    .Set(p => p.Discontinued, true)
    .Set(p => p.LastUpdate, DateTime.Now)
    .UpdateAsync();
 
// Массовое удаление
affected = await db.Products
    .Where(p => p.ExpiryDate < DateTime.Today)
    .DeleteAsync();

// Логирование SQL-запросов
DataConnection.TurnTraceSwitchOn(TraceLevel.Info);
DataConnection.WriteTraceLine = (s, l) => Debug.WriteLine(s);
 
// Получить SQL для конкретного LINQ-запроса
var query = db.Products.Where(p => p.CategoryId == 5);
var sql = query.ToString(); // Получаем SQL-текст без выполнения запроса

// Интеграция с MiniProfiler
db.AddInterceptor(new MiniProfilerInterceptor());
 
// Или собственный интерсептор для любой системы логирования
db.AddInterceptor(new SqlInterceptor(sql => _logger.LogDebug(sql)));

// Использование предзагрузки вместо обычного джойна
var customers = db.Customers
    .LoadWith(c => c.Orders)
    .LoadWith(c => c.Orders.First().OrderDetails)
    .LoadWith(c => c.Orders.First().OrderDetails.First().Product)
    .Where(c => c.Country == "Germany")
    .ToList();
 
// Explicit Join с контролем типа соединения
var query = from c in db.Customers
           join o in db.Orders.LeftJoin() on c.Id equals o.CustomerId
           where c.Country == "France"
           select new { Customer = c, Order = o };

// Вместо одного сложного запроса с множеством JOIN
using (var transaction = db.BeginTransaction())
{
    // Шаг 1: Получаем базовые данные
    var customers = db.Customers
        .Where(c => c.Country == "UK")
        .Select(c => new { c.Id, c.CompanyName })
        .ToList();
    
    // Шаг 2: Загружаем связанные данные для полученных ID
    var customerIds = customers.Select(c => c.Id).ToArray();
    var orders = db.Orders
        .Where(o => customerIds.Contains(o.CustomerId))
        .OrderByDescending(o => o.OrderDate)
        .Take(100)
        .ToList();
    
    transaction.Commit();
}

// Использование CTE
var query = db.GetTable<OrderDetail>()
    .With("OrderTotals", 
        db.GetTable<OrderDetail>()
            .GroupBy(od => od.OrderID)
            .Select(g => new { 
                OrderID = g.Key, 
                Total = g.Sum(od => od.UnitPrice * od.Quantity) 
            }))
    .InnerJoin("OrderTotals", ot => ot["OrderID"] == db.GetTable<OrderDetail>().OrderID)
    .Select(od => new { 
        od.OrderID, 
        od.ProductID, 
        Percentage = od.UnitPrice * od.Quantity / Convert.ToDecimal(od.GetValue<decimal>("OrderTotals.Total")) * 100 
    });

// Создание временной таблицы
db.CreateTempTable<ProductSummary>("ProductStats");
 
// Заполнение данными
db.BulkCopy(
    db.Products
        .GroupBy(p => p.CategoryId)
        .Select(g => new ProductSummary { 
            CategoryId = g.Key, 
            ProductCount = g.Count(), 
            AveragePrice = g.Average(p => p.Price) 
        }),
    "ProductStats"
);
 
// Запрос с использованием временной таблицы
var results = db.GetTable<ProductSummary>("ProductStats")
    .InnerJoin(db.Categories, (ps, c) => ps.CategoryId == c.Id)
    .Select(r => new { 
        Category = r.Get<Category>().Name, 
        r.Get<ProductSummary>().ProductCount, 
        r.Get<ProductSummary>().AveragePrice 
    })
    .ToList();

// Определение рекурсивного запроса для получения дерева категорий
var categoryTree = db.GetTable<Category>()
    .With("CategoryTree", 
        from c in db.GetTable<Category>()
        where c.ParentId == null // Корневые категории
        select new { c.Id, c.Name, c.ParentId, Level = 0 }
        union all
        from c in db.GetTable<Category>()
        from p in db.FromCte("CategoryTree").InnerJoin(ct => c.ParentId == ct["Id"])
        select new { c.Id, c.Name, c.ParentId, Level = p.GetValue<int>("Level") + 1 }
    )
    .OrderBy(r => r.GetValue<int>("Level"))
    .ThenBy(r => r.GetValue<string>("Name"))
    .Select(r => new CategoryNode { 
        Id = r.GetValue<int>("Id"), 
        Name = r.GetValue<string>("Name"), 
        ParentId = r.GetValue<int?>("ParentId"), 
        Level = r.GetValue<int>("Level") 
    })
    .ToList();

// Преобразование плоского списка в дерево
var rootNodes = categoryTree.Where(c => c.ParentId == null).ToList();
foreach (var node in rootNodes)
{
    BuildTree(node, categoryTree);
}
 
void BuildTree(CategoryNode parent, List<CategoryNode> allNodes)
{
    parent.Children = allNodes
        .Where(n => n.ParentId == parent.Id)
        .ToList();
    
    foreach (var child in parent.Children)
    {
        BuildTree(child, allNodes);
    }
}

// Базовый репозиторий
public class Repository<T> where T : class
{
    protected readonly IDataContext _db;
    
    public Repository(IDataContext db) => _db = db;
    
    public virtual IQueryable<T> GetAll() => _db.GetTable<T>();
    
    public virtual async Task<T> GetByIdAsync(object id)
    {
        var table = _db.GetTable<T>();
        var primaryKeyName = table.TableOptions.PrimaryKeys[0];
        var parameter = Expression.Parameter(typeof(T), "x");
        var predicate = Expression.Lambda<Func<T, bool>>(
            Expression.Equal(
                Expression.Property(parameter, primaryKeyName),
                Expression.Constant(id)
            ),
            parameter
        );
        
        return await table.FirstOrDefaultAsync(predicate);
    }
    
    public virtual async Task AddAsync(T entity) => await _db.InsertAsync(entity);
    public virtual async Task UpdateAsync(T entity) => await _db.UpdateAsync(entity);
    public virtual async Task DeleteAsync(T entity) => await _db.DeleteAsync(entity);
}
 
// Unit of Work
public class UnitOfWork : IDisposable
{
    private readonly IDataContext _db;
    private bool _disposed;
    
    // Коллекция репозиториев
    private Dictionary<Type, object> _repositories = new();
    
    public UnitOfWork(IDataContext db) => _db = db;
    
    public Repository<T> GetRepository<T>() where T : class
    {
        if (_repositories.TryGetValue(typeof(T), out var repository))
            return (Repository<T>)repository;
            
        var newRepository = new Repository<T>(_db);
        _repositories[typeof(T)] = newRepository;
        return newRepository;
    }
    
    public async Task<int> SaveChangesAsync()
    {
        using var transaction = await _db.BeginTransactionAsync();
        
        try
        {
            // Здесь мог бы быть код для реализации трекинга изменений
            // если вы хотите поведение, подобное EF
            
            await transaction.CommitAsync();
            return 1; // Возвращаем количество измененых записей
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
    
    public void Dispose()
    {
        if (!_disposed)
        {
            _db.Dispose();
            _disposed = true;
        }
    }
}

public class ProductsByCategory : IQuery<Product>
{
    private readonly int _categoryId;
    private readonly bool _includeDiscontinued;
    
    public ProductsByCategory(int categoryId, bool includeDiscontinued = false)
    {
        _categoryId = categoryId;
        _includeDiscontinued = includeDiscontinued;
    }
    
    public IQueryable<Product> Apply(IQueryable<Product> query)
    {
        var result = query.Where(p => p.CategoryId == _categoryId);
        
        if (!_includeDiscontinued)
            result = result.Where(p => !p.Discontinued);
            
        return result.OrderBy(p => p.Name);
    }
}
 
// Использование
var query = new ProductsByCategory(5).Apply(db.Products);
var electronics = await query.ToListAsync();

public interface ISpecification<T>
{
    Expression<Func<T, bool>> Criteria { get; }
    List<Expression<Func<T, object>>> Includes { get; }
    Expression<Func<T, object>> OrderBy { get; }
    Expression<Func<T, object>> OrderByDescending { get; }
}
 
public class ProductsWithLowStockSpecification : ISpecification<Product>
{
    public Expression<Func<Product, bool>> Criteria => p => p.Stock < p.ReorderLevel;
    
    public List<Expression<Func<Product, object>>> Includes => new()
    {
        p => p.Category,
        p => p.Supplier
    };
    
    public Expression<Func<Product, object>> OrderBy => p => p.Stock;
    
    public Expression<Func<Product, object>> OrderByDescending => null;
}

// Фасад БД, скрывающий детали реализации
public class ProductDataFacade
{
    private readonly ApplicationDbContext _efContext;
    private readonly IDataContext _linq2dbContext;
    
    public ProductDataFacade(ApplicationDbContext efContext, IDataContext linq2dbContext)
    {
        _efContext = efContext;
        _linq2dbContext = linq2dbContext;
    }
    
    // Админ-функции через EF с его удобными механизмами трекинга
    public async Task<Product> UpdateProductDetailsAsync(Product product)
    {
        var entity = await _efContext.Products.FindAsync(product.Id);
        _efContext.Entry(entity).CurrentValues.SetValues(product);
        await _efContext.SaveChangesAsync();
        return entity;
    }
    
    // Высоконагруженные операции через Linq2Db
    public async Task<List<ProductSalesDto>> GetTopSellingProductsAsync(int days = 30)
    {
        return await _linq2dbContext.GetTable<OrderDetail>()
            .Join(_linq2dbContext.GetTable<Order>(),
                  od => od.OrderId,
                  o => o.Id,
                  (od, o) => new { OrderDetail = od, Order = o })
            .Join(_linq2dbContext.GetTable<Product>(),
                  joined => joined.OrderDetail.ProductId,
                  p => p.Id,
                  (joined, p) => new { joined.OrderDetail, joined.Order, Product = p })
            .Where(j => j.Order.OrderDate >= DateTime.Today.AddDays(-days))
            .GroupBy(j => new { j.Product.Id, j.Product.Name })
            .OrderByDescending(g => g.Sum(j => j.OrderDetail.Quantity * j.OrderDetail.UnitPrice))
            .Take(20)
            .Select(g => new ProductSalesDto
            {
                ProductId = g.Key.Id,
                ProductName = g.Key.Name,
                TotalSales = g.Sum(j => j.OrderDetail.Quantity * j.OrderDetail.UnitPrice)
            })
            .ToListAsync();
    }
}

// Запрос (Query) — только чтение данных
public class GetProductsByCategory : IQuery<List<ProductDto>>
{
    public int CategoryId { get; }
    
    public GetProductsByCategory(int categoryId) => CategoryId = categoryId;
    
    public class Handler : IQueryHandler<GetProductsByCategory, List<ProductDto>>
    {
        private readonly IDataContext _db;
        
        public Handler(IDataContext db) => _db = db;
        
        public Task<List<ProductDto>> HandleAsync(GetProductsByCategory query, CancellationToken ct = default)
        {
            return _db.GetTable<Product>()
                .Where(p => p.CategoryId == query.CategoryId && !p.Discontinued)
                .Select(p => new ProductDto
                {
                    Id = p.Id,
                    Name = p.Name,
                    Price = p.Price,
                    Stock = p.StockLevel
                })
                .ToListAsync(ct);
        }
    }
}
 
// Команда (Command) — модификация данных
public class UpdateProductPrice : ICommand<bool>
{
    public int ProductId { get; }
    public decimal NewPrice { get; }
    
    public UpdateProductPrice(int productId, decimal newPrice)
    {
        ProductId = productId;
        NewPrice = newPrice;
    }
    
    public class Handler : ICommandHandler<UpdateProductPrice, bool>
    {
        private readonly IDataContext _db;
        
        public Handler(IDataContext db) => _db = db;
        
        public async Task<bool> HandleAsync(UpdateProductPrice command, CancellationToken ct = default)
        {
            var affected = await _db.GetTable<Product>()
                .Where(p => p.Id == command.ProductId)
                .Set(p => p.Price, command.NewPrice)
                .Set(p => p.LastUpdated, DateTime.UtcNow)
                .UpdateAsync(ct);
                
            return affected > 0;
        }
    }
}

// Потоковая обработка без загрузки всего набора в память
await db.Products
    .Where(p => p.CategoryId == 5)
    .ForEachAsync(product => {
        // Обработка каждого продукта по отдельности
        ProcessProduct(product);
    }, batchSize: 100);
 
// Пакетная обработка с использованием асинхронных методов
public async Task ProcessLargeDatasetAsync()
{
    const int batchSize = 500;
    int skip = 0;
    bool hasMore = true;
    
    while (hasMore)
    {
        var batch = await db.Products
            .OrderBy(p => p.Id)
            .Skip(skip)
            .Take(batchSize)
            .ToListAsync();
            
        if (batch.Count == 0)
        {
            hasMore = false;
            continue;
        }
        
        foreach (var product in batch)
        {
            // Обработка продукта
        }
        
        skip += batchSize;
    }
}

public async Task<bool> ProcessOrderAsync(Order order, List<OrderItem> items)
{
    using var transaction = await _db.BeginTransactionAsync();
    
    try
    {
        // Сохраняем основной заказ
        var orderId = await _db.InsertWithIdentityAsync(order);
        
        // Заполняем ID заказа во всех элементах
        foreach (var item in items)
        {
            item.OrderId = orderId;
        }
        
        // Массовое добавление элементов
        await _db.BulkCopyAsync(items);
        
        // Обновляем склад
        foreach (var item in items)
        {
            await _db.GetTable<Product>()
                .Where(p => p.Id == item.ProductId)
                .Set(p => p.Stock, p => p.Stock - item.Quantity)
                .UpdateAsync();
        }
        
        // Подтверждаем транзакцию
        await transaction.CommitAsync();
        return true;
    }
    catch (Exception ex)
    {
        // Логирование ошибки
        _logger.LogError(ex, "Failed to process order");
        
        // Откат транзакции
        await transaction.RollbackAsync();
        return false;
    }
}

// Оптимистическая блокировка через версионирование
[Table("Products")]
public class Product
{
    [PrimaryKey, Identity]
    public int Id { get; set; }
    
    [Column, NotNull]
    public string Name { get; set; }
    
    [Column]
    public decimal Price { get; set; }
    
    [Column]
    public byte[] RowVersion { get; set; } // Поле для оптимистической блокировки
}
 
// Использование при обновлении
public async Task<bool> UpdateProductAsync(Product product)
{
    try
    {
        var affected = await _db.GetTable<Product>()
            .Where(p => p.Id == product.Id && p.RowVersion == product.RowVersion)
            .UpdateAsync(p => new Product
            {
                Name = product.Name,
                Price = product.Price,
                RowVersion = GetNewRowVersion() // Обновляем версию
            });
            
        return affected > 0; // Если 0, значит запись была изменена другим процессом
    }
    catch (LinqToDBException ex) when (IsUniqueConstraintViolation(ex))
    {
        // Обработка нарушения уникальности
        return false;
    }
}

// Пессимистическая блокировка конкретной записи
var product = await _db.GetTable<Product>()
    .Where(p => p.Id == productId)
    .With(hints: SqlHints.Hints.TabLock | SqlHints.Hints.UpdateLock)
    .FirstOrDefaultAsync();

// Контекст для операций чтения — оптимизирован для производительности запросов
public class ReadOnlyDbContext : DataConnection
{
    public ReadOnlyDbContext(string connectionString) 
        : base(ProviderName.SqlServer, connectionString) 
    {
        // Настройка для чтения — отключаем отслеживание, устанавливаем таймауты
        this.CommandTimeout = 30; // Секунды
    }
    
    // Методы для оптимизированного чтения
    public async Task<List<T>> GetAllWithCachingAsync<T>(TimeSpan duration) where T : class
    {
        string cacheKey = $"All_{typeof(T).Name}";
        
        if (!_cache.TryGetValue(cacheKey, out List<T> result))
        {
            result = await GetTable<T>().ToListAsync();
            _cache.Set(cacheKey, result, duration);
        }
        
        return result;
    }
}
 
// Контекст для операций записи — оптимизирован для транзакций
public class WriteDbContext : DataConnection
{
    public WriteDbContext(string connectionString) 
        : base(ProviderName.SqlServer, connectionString) 
    {
        // Настройка для записи — нужны транзакции и изоляция
        this.OnBeforeConnectionOpen += connection => 
            connection.InitCommand.CommandText = "SET TRANSACTION ISOLATION LEVEL READ COMMITTED";
    }
    
    // Методы для безопасного обновления данных
    public async Task ExecuteInTransactionAsync(Func<Task> action)
    {
        using var transaction = await BeginTransactionAsync();
        try
        {
            await action();
            await transaction.CommitAsync();
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

public async Task SynchronizeProductsAsync(int supplierId, List<SupplierProduct> products)
{
    // Шаг 1: Создаём временную таблицу для импорта
    await _db.CreateTempTableAsync<SupplierProduct>("#IncomingProducts");
    
    // Шаг 2: Массово загружаем данные во временную таблицу
    await _db.BulkCopyAsync(products, "#IncomingProducts");
    
    // Шаг 3: Определяем новые, измененные и удаленные товары одним SQL-запросом
    using var transaction = await _db.BeginTransactionAsync();
    
    try
    {
        // Обновляем существующие товары
        await _db.GetTable<Product>()
            .Join(_db.GetTable<SupplierProduct>("#IncomingProducts"),
                  p => new { p.SupplierCode, SupplierId = supplierId },
                  ip => new { ip.SupplierCode, SupplierId = supplierId },
                  (p, ip) => new { Product = p, ImportedProduct = ip })
            .Where(j => j.Product.Price != j.ImportedProduct.Price || 
                        j.Product.Stock != j.ImportedProduct.Stock)
            .Set(j => j.Product.Price, j => j.ImportedProduct.Price)
            .Set(j => j.Product.Stock, j => j.ImportedProduct.Stock)
            .Set(j => j.Product.LastUpdated, () => DateTime.UtcNow)
            .UpdateAsync();
            
        // Добавляем новые товары
        var newProducts = await (
            from ip in _db.GetTable<SupplierProduct>("#IncomingProducts")
            where !_db.GetTable<Product>()
                      .Any(p => p.SupplierCode == ip.SupplierCode && 
                                p.SupplierId == supplierId)
            select new Product
            {
                Name = ip.Name,
                SupplierCode = ip.SupplierCode,
                SupplierId = supplierId,
                Price = ip.Price,
                Stock = ip.Stock,
                CreatedDate = DateTime.UtcNow,
                LastUpdated = DateTime.UtcNow
            }
        ).ToListAsync();
        
        await _db.BulkCopyAsync(newProducts);
        
        // Помечаем удаленные товары
        await _db.GetTable<Product>()
            .Where(p => p.SupplierId == supplierId && 
                        !_db.GetTable<SupplierProduct>("#IncomingProducts")
                             .Any(ip => ip.SupplierCode == p.SupplierCode))
            .Set(p => p.IsDeleted, true)
            .Set(p => p.LastUpdated, () => DateTime.UtcNow)
            .UpdateAsync();
            
        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
    finally
    {
        // Удаляем временную таблицу
        await _db.DropTableAsync("#IncomingProducts");
    }
}

public class ProductServiceTests
{
    [Fact]
    public async Task GetDiscountedProducts_ReturnsCorrectItems()
    {
        // Arrange
        var testData = new List<Product>
        {
            new Product { Id = 1, Name = "Test1", Price = 100, DiscountPercent = 10 },
            new Product { Id = 2, Name = "Test2", Price = 200, DiscountPercent = 0 },
            new Product { Id = 3, Name = "Test3", Price = 300, DiscountPercent = 15 }
        };
        
        // Создаём in-memory базу для тестирования
        var connection = new SQLiteDataConnection("DataSource=:memory:");
        connection.CreateTable<Product>();
        
        foreach (var product in testData)
        {
            connection.Insert(product);
        }
        
        var repository = new ProductRepository(connection);
        var service = new ProductService(repository);
        
        // Act
        var result = await service.GetDiscountedProductsAsync(minDiscount: 5);
        
        // Assert
        Assert.Equal(2, result.Count);
        Assert.Contains(result, p => p.Id == 1);
        Assert.Contains(result, p => p.Id == 3);
        Assert.DoesNotContain(result, p => p.Id == 2);
    }
}

// Вспомогательный класс для тестов с SQLite
public class InMemoryDatabase : IDisposable
{
    private readonly SQLiteConnection _connection;
    private readonly DataConnection _dataConnection;
    
    public InMemoryDatabase()
    {
        _connection = new SQLiteConnection("DataSource=:memory:");
        _connection.Open();
        
        _dataConnection = new DataConnection(
            SQLiteTools.GetDataProvider("SQLite"),
            _connection);
    }
    
    public DataConnection Connection => _dataConnection;
    
    public void CreateTables()
    {
        // Создаём схему для тестов
        _dataConnection.CreateTable<Product>();
        _dataConnection.CreateTable<Category>();
        // и т.д.
    }
    
    public void Dispose()
    {
        _dataConnection.Dispose();
        _connection.Dispose();
    }
}

LibraryManager/
├─ LibraryManager.Domain/        # Доменная модель и интерфейсы
├─ LibraryManager.Application/   # Сервисы и бизнес-логика
├─ LibraryManager.Infrastructure/# Реализация доступа к данным (Linq2Db)
└─ LibraryManager.Api/           # API-слой (контроллеры, аутентификация)

namespace LibraryManager.Domain.Entities
{
    public class Book
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Author { get; set; }
        public int Year { get; set; }
        public string ISBN { get; set; }
        public int CategoryId { get; set; }
        public Category Category { get; set; }
        public List<BookLoan> Loans { get; set; } = new();
    }
 
    public class Category
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public List<Book> Books { get; set; } = new();
    }
 
    public class Reader
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public DateTime RegisteredDate { get; set; }
        public List<BookLoan> BookLoans { get; set; } = new();
    }
 
    public class BookLoan
    {
        public int Id { get; set; }
        public int BookId { get; set; }
        public Book Book { get; set; }
        public int ReaderId { get; set; }
        public Reader Reader { get; set; }
        public DateTime LoanDate { get; set; }
        public DateTime? ReturnDate { get; set; }
    }
}

namespace LibraryManager.Domain.Repositories
{
    public interface IBookRepository
    {
        Task<List<Book>> GetAllAsync();
        Task<Book> GetByIdAsync(int id);
        Task<List<Book>> GetByAuthorAsync(string author);
        Task AddAsync(Book book);
        Task UpdateAsync(Book book);
        Task DeleteAsync(int id);
    }
 
    // Аналогично для других сущностей...
 
    public interface IUnitOfWork
    {
        IBookRepository Books { get; }
        ICategoryRepository Categories { get; }
        IReaderRepository Readers { get; }
        IBookLoanRepository BookLoans { get; }
        Task SaveChangesAsync();
    }
}

namespace LibraryManager.Infrastructure.DataAccess
{
    [Table("Books")]
    public class BookEntity
    {
        [PrimaryKey, Identity] public int Id { get; set; }
        [Column, NotNull] public string Title { get; set; }
        [Column, NotNull] public string Author { get; set; }
        [Column] public int Year { get; set; }
        [Column] public string ISBN { get; set; }
        [Column] public int CategoryId { get; set; }
 
        [Association(ThisKey = "CategoryId", OtherKey = "Id")]
        public CategoryEntity Category { get; set; }
 
        [Association(ThisKey = "Id", OtherKey = "BookId")]
        public List<BookLoanEntity> Loans { get; set; }
    }
 
    // Аналогично для других сущностей...
 
    public class LibraryDbContext : DataConnection
    {
        public LibraryDbContext(string connectionString) 
            : base(ProviderName.SqlServer, connectionString) { }
 
        public ITable<BookEntity> Books => GetTable<BookEntity>();
        public ITable<CategoryEntity> Categories => GetTable<CategoryEntity>();
        public ITable<ReaderEntity> Readers => GetTable<ReaderEntity>();
        public ITable<BookLoanEntity> BookLoans => GetTable<BookLoanEntity>();
    }
}

public class BookRepository : IBookRepository
{
    private readonly LibraryDbContext _context;
    
    public BookRepository(LibraryDbContext context) => _context = context;
    
    public async Task<List<Book>> GetAllAsync()
    {
        var entities = await _context.Books
            .LoadWith(b => b.Category)
            .ToListAsync();
            
        return entities.Select(MapToModel).ToList();
    }
    
    public async Task<Book> GetByIdAsync(int id)
    {
        var entity = await _context.Books
            .LoadWith(b => b.Category)
            .LoadWith(b => b.Loans.First().Reader)
            .FirstOrDefaultAsync(b => b.Id == id);
            
        return entity != null ? MapToModel(entity) : null;
    }
    
    // Другие методы и маппинг между сущностями и моделями...
    private Book MapToModel(BookEntity entity) => 
        new Book
        {
            Id = entity.Id,
            Title = entity.Title,
            Author = entity.Author,
            Year = entity.Year,
            ISBN = entity.ISBN,
            CategoryId = entity.CategoryId,
            Category = entity.Category != null 
                ? new Category { Id = entity.Category.Id, Name = entity.Category.Name }
                : null
        };
}

public class AuthService
{
    private readonly IUserRepository _userRepository;
    private readonly IConfiguration _configuration;
    
    public AuthService(IUserRepository userRepository, IConfiguration configuration)
    {
        _userRepository = userRepository;
        _configuration = configuration;
    }
    
    public async Task<string> AuthenticateAsync(string username, string password)
    {
        var user = await _userRepository.GetByUsernameAsync(username);
        
        if (user == null || !VerifyPassword(password, user.PasswordHash))
            return null;
            
        return GenerateJwtToken(user);
    }
    
    private string GenerateJwtToken(User user)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var key = Encoding.ASCII.GetBytes(_configuration["JWT:Secret"]);
        
        var tokenDescriptor = new SecurityTokenDescriptor
        {
            Subject = new ClaimsIdentity(new[]
            {
                new Claim(ClaimTypes.Name, user.Id.ToString()),
                new Claim(ClaimTypes.Role, user.Role)
            }),
            Expires = DateTime.UtcNow.AddDays(7),
            SigningCredentials = new SigningCredentials(
                new SymmetricSecurityKey(key),
                SecurityAlgorithms.HmacSha256Signature)
        };
        
        var token = tokenHandler.CreateToken(tokenDescriptor);
        return tokenHandler.WriteToken(token);
    }
}

public class BookLoanService
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMemoryCache _cache;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    
    // ...
    
    public async Task<bool> BorrowBookAsync(int bookId, int readerId)
    {
        await _semaphore.WaitAsync();
        try
        {
            using var transaction = await _unitOfWork.BeginTransactionAsync();
            
            var book = await _unitOfWork.Books.GetByIdAsync(bookId);
            if (book == null || book.Loans.Any(l => l.ReturnDate == null))
                return false;
                
            var loan = new BookLoan
            {
                BookId = bookId,
                ReaderId = readerId,
                LoanDate = DateTime.UtcNow
            };
            
            await _unitOfWork.BookLoans.AddAsync(loan);
            await _unitOfWork.SaveChangesAsync();
            await transaction.CommitAsync();
            
            // Инвалидируем кеш
            _cache.Remove($"book_{bookId}");
            
            return true;
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public class UnitOfWork : IUnitOfWork, IDisposable
{
    private readonly LibraryDbContext _context;
    private IBookRepository _bookRepository;
    private ICategoryRepository _categoryRepository;
    private IReaderRepository _readerRepository;
    private IBookLoanRepository _bookLoanRepository;
    private bool _disposed;
    
    public UnitOfWork(LibraryDbContext context) => _context = context;
    
    public IBookRepository Books => 
        _bookRepository ??= new BookRepository(_context);
        
    // Аналогично для других репозиториев...
    
    public async Task<IDbTransaction> BeginTransactionAsync()
    {
        return await _context.BeginTransactionAsync();
    }
    
    public async Task SaveChangesAsync()
    {
        // Здесь можно добавить логику аудита, валидации и т.д.
        // перед сохранением изменений
    }
    
    public void Dispose()
    {
        if (!_disposed)
        {
            _context.Dispose();
            _disposed = true;
        }
    }
}