// Добавление
await _repository.InsertAsync(entity);

// Пакетное добавление
await _repository.InsertAsync(entities);

// Добавление с использованием SqlBuilder
await SqlBuilder
        .Insert<MsdBoxEntity>(() =>
            entity)
        .ExecuteAsync(
            _repository);

// Пакетное добавление с использованием SqlBuilder
await SqlBuilder
        .Insert<MsdBoxEntity>(() =>
            new[]
            {
                new UserInfo { Name = "张三", Sex = 2 },
                new UserInfo { Name = "张三", Sex = 2 }
            })
        .ExecuteAsync(
            _repository);

// Удаление
await _repository.DeleteAsync(entity);

// Пакетное удаление
await _repository.DeleteAsync(entitties);

// Условное удаление
await _repository.DeleteAsync<MsdBoxEntity>(x => x.Id == "1");

// Удаление с использованием SqlBuilder
await SqlBuilder
        .Delete<MsdBoxEntity>()
        .Where(x =>
            x.Id == "1")
        .ExecuteAsync(
            _repository);

// Первичный ключ удаления
await
``` **SqlBuilder**

    .Delete<MsdBoxEntity>()
    .WithKey("1")
    .ExecuteAsync(_repository);

// обновление
await _repository.UpdateAsync(entity);

// пакетное обновление
await _repository.UpdateAsync(entities);

// условное обновление
await _repository.UpdateAsync<MsdBoxEntity>(x => x.Id == "1", () => entity);

// обновление
await SqlBuilder
        .Update<MsdBoxEntity>((() =>
            entity,
            DatabaseType.MySql,
            isEnableFormat: true))
        .Where(x =>
            x.Id == "1")
        .ExecuteAsync(_repository);

// простой запрос
await _repository.FindListAsync<MsdBoxEntity>(x => x.Id == "1");

// соединительный запрос
await SqlBuilder
        .Select<UserInfo, UserInfo, Account, Student, Class, City, Country>((u, t, a, s, d, e, f) =>
            new { u.Id, UId = t.Id, a.Name, StudentName = s.Name, ClassName = d.Name, e.CityName, CountryName = f.Name })
        .Join<UserInfo>((x, t) =>
            x.Id == t.Id) // обратите внимание на то, что здесь однотабличное соединение повторяется несколько раз, поэтому необходимо указать конкретное имя таблицы, иначе все будут считывать первое имя таблицы
        .Join<Account>((x, y) =>
            x.Id == y.UserId)
        .LeftJoin<Account, Student>((x, y) =>
            x.Id == y.AccountId)
        .RightJoin<Student, Class>((x, y) =>
            x.Id == y.UserId)
        .InnerJoin<Class, City>((x, y) =>
            x.CityId == y.Id)
        .FullJoin<City, Country>((x, y) =>
            x.CountryId == y.Id)
        .Where(x =>
            x.Id != null)
        .ToListAsync(_repository);

// постраничный запрос
var condition = LinqExtensions
                    .True<UserInfo, Account>()
                    .And((x, y) => 
                        x.Id == y.UserId)
                    .WhereIf(
                        !name.IsNullOrEmpty(), 
                        (x, y) => name.EndsWith("∞")
                        ? x.Name.Contains(name.Trim('∞'))
                        : x.Name == name);
var hasWhere = false;
await SqlBuilder
        .Select<UserInfo, Account>(
            (u, a) => new { u.Id, UserName = "u.Name" })
        .InnerJoin<Account>(
            condition)
        .WhereIf(
            !name.IsNullOrEmpty(),
            x => x.Email != null && 
            (!name.EndsWith("∞") ? x.Name.Contains(name.TrimEnd('∞', '*')) : x.Name == name),
            ref hasWhere)
        .WhereIf(
            !email.IsNullOrEmpty(),
            x => x.Email == email,
            ref hasWhere)
        .ToPageAsync(
            _repository.UseMasterOrSlave(false),
            input.OrderField,
            input.Ascending,
            input.PageSize,
            input.PageIndex);

// репозиторий постраничного запроса
await _repository.FindListAsync(condition, input.OrderField, input.Ascending, input.PageSize, input.PageIndex);

// расширенный запрос
Func<string[], string> @delegate = x => $"ks.{x[0]}{x[1]}{x[2]} WITH(NOLOCK)";

await SqlBuilder
        .Select<UserInfo, Account, Student, Class, City, Country>((u, a, s, d, e, f) =>
            new { u, a.Name, StudentName = s.Name, ClassName = d.Name, e.CityName, CountryName = f.Name },
            tableNameFunc: @delegate)
        .Join<Account>((x, y) =>
            x.Id == y.UserId,
            @delegate)
        .LeftJoin<Account, Student>((x, y) =>
            x.Id == y.AccountId,
            @delegate)
        .RightJoin<Class, Student>((x, y) =>
            y.Id == x.UserId,
            @delegate)
        .InnerJoin<Class, City>((x, y) =>
            x.CityId == y.Id,
            @delegate)
        .FullJoin<City, Country>((x, y) =>
            x.CountryId == y.Id,
            @delegate)
        .Where(u =>
            u.Id != null)
        .ToListAsync(
            _repository);

// предварительная очередь
_repository.AddQueue(async repo =>
    await repo.UpdateAsync<UserEntity>(
        x => x.Id == "1",
        () => new
        {
            Name = "test"
        }) > 0);

_repository.AddQueue(async repo =>
    await repo.DeleteAsync<UserEntity>(x =>
        x.Enabled == 1) > 0);

// единая очередь отправки, транзакция по умолчанию включена
var res = await _repository.SaveQueueAsync();

// Возвращаем null, не изменяем исходный SQL-оператор, здесь можно изменить выполняемый SQL-оператор
return null;

//appsettings.json
"ConnectionStrings": {
  "Base": [
    "Oracle",
    "Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.100)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=name)));Persist Security Info=True;User ID=test;Password=123;",
    "Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=name)));Persist Security Info=True;User ID=test;Password=123;",
    "Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.102)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=name)));Persist Security Info=True;User ID=test;Password=123;"
  ],
  "Cap": [
    "MySql",
    "Server=127.0.0.1;Database=db;Uid=root;Pwd=123456;SslMode=None;"
  ],
  "Oracle": [ "Oracle", "строка подключения к базе данных" ],
  "MySql": [ "MySql", "строка подключения к базе данных" ],
  "Sqlserver": [ "SqlServer", "строка подключения к базе данных" ],
  "Sqlite": [ "Sqlite", "строка подключения к базе данных" ],
  "Pgsql": [ "PostgreSql", "строка подключения к базе данных" ]
}

// Способ один
IRepository trans = null;
try
{
    // Открываем транзакцию
    trans = await _repository.BeginTransactionAsync();

    // Операция записи в базу данных
    await trans.InsertAsync(entity);

    // Фиксируем транзакцию
    await trans.CommitAsync();
}
catch (Exception)
{
    // Откатываем транзакцию
    if(trans != null)
        await tran.RollbackAsync();
       
    throw;
}

// Способ два
var res = await _repository.ExecuteTransactionAsync(async trans =>
{
    var retval = (await trans.InsertAsync(entity)) > 0;

    if (input.Action.EqualIgnoreCase(UnitAction.InDryBox))
        code = await _unitInfoService.InDryBoxAsync(dryBoxInput);
    else
        code = await _unitInfoService.OutDryBoxAsync(dryBoxInput);

    return code == ErrorCode.Successful && retval;
});

private readonly Func<string, IRepository> _handler;
private readonly IRepository _repository;

public MyService(Func<string, IRepository> hander)
{
    _handler = hander;

    // По умолчанию базовое хранилище данных
    _repository = hander(null);
}

// Базовое хранилище
var baseRepository = _handler("Base");

// Хранилище Cap
var capRepository = _handler("Cap");

// Способ один
_repository.Master = false;

// Способ два
_repository.UseMasterOrSlave(master)

// Внедрение SQLBuilder SkyWalking трассировки ссылок
services.AddSqlBuilderSkyApm()

// Использование SQLBuilder ElasticApm трассировки ссылок
app.UseSqlBuilderElasticApm(Configuration)