202309U/YZXYH2017/YZXYH.Repository/BaseRepository.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using System.Data.Entity.Validation;
using System.Linq;
using System.Linq.Expressions;
using CommonTool;
using EntityFramework.Extensions;
using YZXYH.Repository.Models;
using YZXYH.Repository.Interface;

namespace YZXYH.Repository
{
	public class BaseRepository<T> 
		where T : class, new()
	{
		protected Yzxyh2017Context Context;
		internal DbSet<T> DbSet;
		protected IUnitOfWork UnitOfWork;

		public BaseRepository(Yzxyh2017Context context)
		{
			Context = context;
			DbSet = context.Set<T>();
			UnitOfWork = new UnitOfWork(context);
		}

		/// <summary>
		/// 是否存在
		/// </summary>
		/// <param name="exp">过滤条件</param>
		/// <returns></returns>
		public bool IsExist(Expression<Func<T, bool>> exp)
		{
			return Context.Set<T>().Any(exp);
		}

		/// <summary>
		/// 过滤排序查询
		/// </summary>
		/// <param name="exp">过滤条件（eg: u=>u.Id="1"）</param>
		/// <param name="orderBy">排序（eg: q=>q.OrderByDescending(u=>u.Name)）</param>
		/// <param name="includeProperties">外键</param>
		/// <returns> 对象集合</returns>
		public IQueryable<T> Get(Expression<Func<T, bool>> exp = null,
			Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeProperties = "")
		{
			IQueryable<T> dbSet = DbSet;
			if (exp != null)
				dbSet = DbSet.Where(exp);
			foreach (var includeProperty in includeProperties.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
			{
				dbSet = dbSet.Include(includeProperty);
			}
			if (orderBy != null)
			{
				return orderBy(dbSet);
			}
			return dbSet;
		}

		/// <summary>
		/// 分页排序记录
		/// </summary>
		/// <param name="pageindex">The pageindex.</param>
		/// <param name="pagesize">The pagesize.</param>
		/// <param name="orderBy">排序（eg: q=>q.OrderByDescending(u=>u.Name)）</param>
		/// <param name="exp">过滤条件（eg: u=>u.Id="1"）</param>
		/// <param name="includeProperties">外键</param>
		public IQueryable<T> Get(int pageindex, int pagesize, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, Expression<Func<T, bool>> exp = null, string includeProperties = "")
		{
			if (pageindex < 1) pageindex = 1;
			return Get(exp, orderBy, includeProperties).Skip(pagesize * (pageindex - 1)).Take(pagesize);
		}

		/// <summary>
		/// 查找单个
		/// </summary>
		public T GetSingle(Expression<Func<T, bool>> exp)
		{
			return DbSet.AsNoTracking().FirstOrDefault(exp);
		}

		/// <summary>
		/// 根据Id获取数据
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public T GetById(string id)
		{
			return DbSet.Find(id);
		}

		/// <summary>
		/// 根据过滤条件获取记录数
		/// </summary>
		public int GetCount(Expression<Func<T, bool>> exp = null)
		{
			return Get(exp).Count();
		}

		/// <summary>
		/// 普通插入
		/// </summary>
		/// <param name="t"></param>
		public void Insert(T t)
		{
			DbSet.Add(t);
		}

		/// <summary>
		/// 没有主键Id的插入
		/// </summary>
		/// <param name="t"></param>
		public void InsertNoId(T t)
		{

			var propertyInfo = t.GetType().GetProperty("Id");
			if (propertyInfo != null) propertyInfo.SetValue(t, Guid.NewGuid().ToString("N"));
			DbSet.Add(t);

		}

		/// <summary>
		/// 批量插入
		/// </summary>
		/// <param name="ts">The entities.</param>
		public void BatchInsert(T[] ts)
		{
			foreach (var t in ts)
			{
				
				var propertyInfo = t.GetType().GetProperty("Id");
				if (propertyInfo != null) propertyInfo.SetValue(t, Guid.NewGuid().ToString("N"));

			}
			DbSet.AddRange(ts);
		}

		/// <summary>
		/// 删除记录
		/// </summary>
		/// <param name="t"></param>
		public void Delete(T t)
		{
			DbSet.Attach(t);
			DbSet.Remove(t);
		}

		/// <summary>
		/// 删除记录
		/// </summary>
		/// <param name="exp">过滤条件</param>
		public virtual void Delete(Expression<Func<T, bool>> exp)
		{
			DbSet.Where(exp).Delete();
		}

		/// <summary>
		///根据Id删除
		/// </summary>
		/// <param name="id"></param>
		public void DeleteById(string id)
		{
			Delete(GetById(id));
		}

		/// <summary>
		/// 更新
		/// </summary>
		/// <param name="t"></param>
		public void Update(T t)
        {
            DbSet.Attach(t);
            Context.Entry(t).State = EntityState.Modified;
		}

		/// <summary>
		/// 实现按需要只更新部分更新
		/// <para>如：Update(u =>u.Id==1,u =>new User{Name="ok"});</para>
		/// </summary>
		/// <param name="where">The where.</param>
		/// <param name="t">The entity.</param>
		public void Update(Expression<Func<T, bool>> where, Expression<Func<T, T>> t)
		{
			Context.Set<T>().Where(where).Update(t);
		}

		/// <summary>
		/// 按指定id更新实体,会更新整个实体
		/// </summary>
		/// <param name="identityExp">The identity exp.</param>
		/// <param name="t">The entity.</param>
		public void Update(Expression<Func<T, object>> identityExp, T t)
		{
			DbSet.AddOrUpdate(identityExp, t);
		}


		/// <summary>
		/// 查询记录条数
		/// </summary>
		/// <param name="queryStrs">参数 “表名 | 条件语句 , 表名 | 条件语句”</param>
		/// （多个查询以 , 分隔，表名与条件语句以 | 分隔）
		/// <returns></returns>
		public string[] GetCounts(string[] queryStrs)
		{
			List<string> counts = new List<string> { "true" };
			foreach (var queryStr in queryStrs)
			{
				string[] strs = queryStr.Split('|');
				if (strs.Length != 2)
				{
					counts.Clear();
					counts.Add("参数有误，请检查！" + strs[0]);
					return counts.ToArray();
				}
				var tableName = strs[0];
				var whereStr = strs[1];

				try
				{
					var sqlStr = $"SELECT Count(*) FROM  {tableName} WHERE  {whereStr} ";
					var count = Context.Database.SqlQuery<int>(sqlStr).First().ToString();
					//var count = db.Database.SqlQuery<int>("SELECT Count(*) FROM @p0 WHERE @p1", new SqlParameter("@p0", tableName), new SqlParameter("@p1", whereStr)).First().ToString();
					counts.Add(count);
				}
				catch
				{
					counts.Clear();
					counts.Add("参数有误！请检查! " + tableName + " || " + whereStr);
					return counts.ToArray();
				}
			}
			return counts.ToArray();
		}

		public bool Save()
		{
			try
			{
				Context.SaveChanges();
				return true;
			}
			catch(DbEntityValidationException e)
			{
				LogHelper.Error(e.EntityValidationErrors.First().ValidationErrors.First().ErrorMessage);
				return false;
			}
		}


	}
}