lg_backend/langguanApi/Service/BaseService.cs

using langguanApi.Model;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Options;
using MongoDB.Bson;
using MongoDB.Driver;
using System.Linq.Expressions;

namespace langguanApi.Service
{
    public class BaseService<T> where T : BaseModel
    {
        private readonly IMongoCollection<T> _collection;   //数据表操作对象
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="config"></param>
        /// <param name="tableName"></param>
        public BaseService(IConfiguration config, string tableName)
        {

            var client = new MongoClient(config.GetSection("ConnectionStrings:MongoDBConn").Value);    //获取链接字符串
            var database = client.GetDatabase(config.GetSection("ConnectionStrings:DBName").Value);
            _collection = database.GetCollection<T>(tableName);
            if (_collection == null)
            {
                database.CreateCollection(tableName);
            }
        }
        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns></returns>
        public List<T> Get()
        {
            return _collection.Find(T => true).ToList();
        }
        /// <summary>
        /// 获取单个
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get(string id)
        {
            return _collection.Find<T>(T => T.Id == id).FirstOrDefault();
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="T"></param>
        /// <returns></returns>
        public T Create(T T)
        {
            _collection.InsertOne(T);
            return T;
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <param name="TIn"></param>
        public void Update(string id, T TIn)
        {
            _collection.ReplaceOne(T => T.Id == id, TIn);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="TIn"></param>
        public void Remove(T TIn)
        {
            _collection.DeleteOne(T => T.Id == TIn.Id);
        }

        /// <summary>
        /// 根据id删除
        /// </summary>
        /// <param name="id"></param>
        public void Remove(string id)
        {
            _collection.DeleteOne(T => T.Id == id);
        }
        #region 异步操作
        /// <summary>
        /// 取列表
        /// </summary>
        /// <returns></returns>
        public async Task<List<T>> GetAsync()
        {
            return await _collection.Find(T => true).ToListAsync();
        }
        /// <summary>
        /// 取单条
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<T> GetAsync(string id)
        {
            return await _collection.Find<T>(T => T.Id == id).FirstOrDefaultAsync();
        }
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="T"></param>
        /// <returns></returns>
        public async Task<T> CreateAsync(T T)
        {
            await _collection.InsertOneAsync(T);
            return T;
        }
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="T"></param>
        /// <returns></returns>
        public async Task CreateManyAsync(IEnumerable<T> T)
        {
            await _collection.InsertManyAsync(T);
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <param name="TIn"></param>
        /// <returns></returns>
        public async Task UpdateAsync(string id, T TIn)
        {
            await _collection.ReplaceOneAsync(T => T.Id == id, TIn);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task RemoveAsync(string id)
        {
            await _collection.DeleteOneAsync(T => T.Id == id);
        }
        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task BatchRemoveAsync(IEnumerable<string> ids)
        {
            var filter = Builders<T>.Filter.In(s => s.Id, ids);
            await _collection.DeleteManyAsync(filter);
        }
        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public async Task BatchRemoveAsync(Expression<Func<T, bool>> expression)
        {
            await _collection.DeleteManyAsync(expression);
        }
        #endregion
        /// <summary>
        /// 表达式取数据
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public Task<IQueryable<T>> GetListWithExp(Expression<Func<T, bool>> expression)
        {
            //  var temp = _collection.AsQueryable<T>().Where(expression).ToList();
            return Task.FromResult(_collection.AsQueryable<T>().Where(expression));
        }
        /// <summary>
        /// 表达式计数
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public Task<long> Count(Expression<Func<T, bool>> expression)
        {
            return Task.FromResult(_collection.AsQueryable<T>().Where(expression).LongCount());
        }
        /// <summary>
        /// filter查找
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public async Task<List<T>> FindListByFilter(Expression<Func<T, bool>> filter)
        {
            FilterDefinition<T> filters = Builders<T>.Filter.Where(filter);
            return await _collection.Find(filters).ToListAsync();
        }

        /// <summary>
        /// filter查找 流式数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public async Task<List<T>> FindListyFilter(FilterDefinition<T> filter)
        {
            List<T> result = new List<T>();
            var cursor = await _collection.FindAsync(filter);
            while (await cursor.MoveNextAsync())
            {
                var batch = cursor.Current;
                foreach (var document in batch)
                {
                    result.Add(document);
                    //    Console.WriteLine(document.ToString());
                }
            }
            return result;
        }
        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public Task<bool> Exist(Expression<Func<T, bool>> expression)
        {
            var result = _collection.AsQueryable().Where(expression).Any();
            return Task.FromResult(result);
        }
        /// <summary>
        /// 分页取数据
        /// </summary>
        /// <param name="req"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public async Task<ApiResult> GetPager(ReqPaing req, Expression<Func<T, bool>> exp = null)
        {
            req.pageSize = req.pageSize == 0 ? 10 : req.pageSize;
            var query = await GetListWithExp(exp);
            var total = query.Count();
            var items = query.OrderByDescending(s => s.CreateDateTime)
                .Skip(req.pageSize * (req.current - 1)).Take(req.pageSize).ToList();
            return new ApiResult()
            {
                code = 0,
                data = new { total, items }
            };
        }
        /// <summary>
        /// 分页取数据
        /// </summary>
        /// <param name="req"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public async Task<Tuple<long, List<T>>> GetListByPage(ReqPaing req, Expression<Func<T, bool>> exp = null)
        {
            req.pageSize = req.pageSize == 0 ? 10 : req.pageSize;
            var query = await GetListWithExp(exp);
            var total = query.Count();
            var items = query.OrderByDescending(s => s.CreateDateTime)
                .Skip(req.pageSize * (req.current - 1)).Take(req.pageSize).ToList();
            return new Tuple<long, List<T>>(total, items);
        }
        /// <summary>
        /// 聚合查询
        /// </summary>
        /// <param name="pipeline"></param>
        /// <returns></returns>
        public async Task<List<BsonDocument>> GetGroupedResultsAsync(BsonDocument[] pipeline)
        {
            return await _collection.Aggregate<BsonDocument>(pipeline).ToListAsync();
        }
    }
}