data-transfer/SnapshotWinFormsApp/Repository/TargetRepository.cs

using Abp.Collections.Extensions;
using SnapshotWinFormsApp.Application.Dtos;
using SnapshotWinFormsApp.Entities.NewHotline;
using SnapshotWinFormsApp.Repository.Interfaces;
using SqlSugar;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SnapshotWinFormsApp.Repository;

public class ConcurrentQueueRepository<TEntity> where TEntity : Entity, new()
{
    private ConcurrentQueue<TEntity> _queue = new ConcurrentQueue<TEntity>();

    public void Insert(TEntity entity, ISqlSugarClient sugarClient, bool isEnd)
    {
        _queue.Enqueue(entity);
        if (_queue.Count != 100 && isEnd == false) return;
        sugarClient.Ado.BeginTran();
        sugarClient.Insertable(_queue.ToList()).ExecuteCommand();
        sugarClient.Ado.CommitTran();
        _queue.Clear();
    }
}


public class TargetRepository<T> : ITargetRepository<T> where T : OldIdEntity, new()
{
    private readonly SqlSugarClient _db;
    public readonly ConcurrentQueueRepository<T> _queue;

    public SqlSugarClient db => this._db;

    public TargetRepository(CreateInstanceInDto inDto)
    {
        var context = inDto.DbSqlServer;
        _db = context.DbItems.GetValueOrDefault(inDto.Key + "PGSQLDB");
        _queue = new ConcurrentQueueRepository<T>();
    }

    public async Task<IList<T>> GetAllAsync(CancellationToken token)
    {
        return await _db.Queryable<T>().ToListAsync(token);
    }

    public T GetById(int id)
    {
        return _db.Queryable<T>().InSingle(id);
    }

    public async Task<string> InsertAsync(T entity, CancellationToken token)
    {
        if (entity.Id.IsNullOrEmpty())
            entity.InitId();
        await _db.Insertable(entity).ExecuteCommandAsync(token);
        return entity.Id;
    }

    public ISugarQueryable<T> Queryable()
    {
        return _db.Queryable<T>();
    }

    public void Update(T entity)
    {
        _db.Updateable<T>(entity).ExecuteCommand();
    }

    public IUpdateable<T> Updateable()
        => _db.Updateable<T>();

    public async Task<int> ExecuteSqlAsync(string sql)
    {
        return await _db.Ado.ExecuteCommandAsync(sql, new List<SugarParameter>());
    }

    public DataTable GetDataTable(string sql)
        => _db.Ado.GetDataTable(sql);

    public string InsertBulk(T entity, bool isEnd)
    {
        if (entity.Id.IsNullOrEmpty())
            entity.InitId();
        _queue.Insert(entity,_db, isEnd);
        return entity.Id;
    }

    public IList<T> GetAll()
    {
        return _db.Queryable<T>().ToList();

    }
}