DW5S/DW5S.Repostory/Repository/IRepository.cs

using DW5S.Entity;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace DW5S.Repostory
{
    public interface IRepository<T>
    {
        IQueryable<T> AsQueryable();


        Task<T> GetByIdAsync(object id);
        Task<IEnumerable<T>> GetAllAsync();
        Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
        Task<IEnumerable<Res>> GetDistinctAsync<Res>(Expression<Func<T, Res>> selector);

        Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate);
        Task<T> AddAsync(T entity);
        Task AddRangeAsync(IEnumerable<T> entitis);


        void Update(T entity);
        void Delete(T entity);

        /// <summary>
        /// 根据ID删除
        /// </summary>
        /// <param name="ids">ids可以是int、long、IEnumerable等类型</param>
        void DeleteById(object ids);
    }

    public class Repository<T> : IRepository<T> where T : class
    {
        protected readonly OracleContext ctx;
        protected readonly DbSet<T> dbSet;

        public Repository(OracleContext ctx)
        {
            this.ctx = ctx;
            this.dbSet = ctx.Set<T>();
        }
        public IQueryable<T> AsQueryable()
        {
            return dbSet.AsQueryable();
        }
        public async Task<T> GetByIdAsync(object id)
        {
            return await dbSet.FindAsync(id);
        }
        public async Task<IEnumerable<T>> GetAllAsync()
        {
            return await dbSet.ToListAsync();
        }

        public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
        {
            return await dbSet.Where(predicate).ToListAsync();
        }
        public async Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate)
        {
            return await dbSet.Where(predicate).FirstOrDefaultAsync();
        }

        public async Task<IEnumerable<Res>> GetDistinctAsync<Res>(Expression<Func<T, Res>> selector)
        {
            var res = await dbSet.Select(selector).Distinct().ToListAsync();
            return res;
        }
        public async Task<T> AddAsync(T entity)
        {
            var res = await dbSet.AddAsync(entity);
            return res.Entity;
        }
        public async Task AddRangeAsync(IEnumerable<T> entitis)
        {
            await dbSet.AddRangeAsync(entitis);
        }
        public void Update(T entity)
        {
            dbSet.Update(entity);
        }

        public void Delete(T entity)
        {
            dbSet.Remove(entity);
        }
        /// <summary>
        /// 高性能的删除
        /// </summary>
        /// <param name="id">ids可以是int、long、IEnumerable<int>、IEnumerable<long>等类型</param>
        public async void DeleteById(object id)
        {
            if (id == null) return;
            string table = typeof(T).Name;
            if (id is IEnumerable<long> ids1)
            {
                //如果ID是连续的，这里可以使用大于小于等条件进一步优化
                string sql = $"delete from {table} where id in ({string.Join(",", ids1)})";
                await ctx.ExecuteSqlAsync(sql);
            }
            else if (id is IEnumerable<int> ids2)
            {
                string sql = $"delete from {table} where id in ({string.Join(",", ids2)})";
                await ctx.ExecuteSqlAsync(sql);
            }
            else
            {
                string sql = $"delete from {table} where id={id}";
                await ctx.ExecuteSqlAsync(sql);
            }
        }
    }

}