## v0.3.16

- 修复 IInsert/IUpdate.NoneParameter() 设成了反作用的 bug；
- 修复 IDbFirst.GetTablesByDatabase() 默认数据库 bool 判断 bug；
- 增加 FreeSql.Repository 之 IUnitOfWork 实现，[查看参数资料](https://github.com/2881099/FreeSql/wiki/%e5%b7%a5%e4%bd%9c%e5%8d%95%e5%85%83)；
- 增加 FreeSql.Repository 继承实现的仓储注入；
```csharp
builder.RegisterFreeRepository(
    filter => filter.Apply<Song>("test", a => a.Title == DateTime.Now.ToString() +
        Thread.CurrentThread.ManagedThreadId),
    this.GetType().Assembly
);
```

FreeSql.Repository/Repository/BaseRepository.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public abstract class BaseRepository<TEntity> : IRepository<TEntity>
+		where TEntity : class {
+
+		protected IFreeSql _fsql;
+		internal DbTransaction _tran;
+		public IDataFilter<TEntity> DataFilter { get; } = new DataFilter<TEntity>();
+
+		Func<string, string> _asTableVal;
+		protected Func<string, string> AsTable {
+			get => _asTableVal;
+			set {
+				_asTableVal = value;
+				AsTableSelect = value == null ? null : new Func<Type, string, string>((a, b) => a == EntityType ? value(b) : null);
+			}
+		}
+		protected Func<Type, string, string> AsTableSelect { get; private set; }
+		internal Func<Type, string, string> AsTableSelectInternal => AsTableSelect;
+
+		public Type EntityType { get; } = typeof(TEntity);
+
+		protected BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) : base() {
+			_fsql = fsql ?? throw new NullReferenceException(nameof(fsql));
+			Utils.SetRepositoryDataFilter(this, null);
+			DataFilter.Apply("", filter);
+			AsTable = asTable;
+		}
+
+		public ISelect<TEntity> Select => OrmSelect(null);
+		public IUpdate<TEntity> UpdateDiy => OrmUpdate(null);
+
+		public int Delete(Expression<Func<TEntity, bool>> predicate) => OrmDelete(null).Where(predicate).ExecuteAffrows();
+		public int Delete(TEntity entity) => OrmDelete(entity).ExecuteAffrows();
+		public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate) => OrmDelete(null).Where(predicate).ExecuteAffrowsAsync();
+		public Task<int> DeleteAsync(TEntity entity) => OrmDelete(entity).ExecuteAffrowsAsync();
+
+		public virtual TEntity Insert(TEntity entity) {
+			switch (_fsql.Ado.DataType) {
+				case DataType.SqlServer:
+				case DataType.PostgreSQL:
+					return OrmInsert(entity).ExecuteInserted().FirstOrDefault();
+				case DataType.MySql:
+				case DataType.Oracle:
+				case DataType.Sqlite:
+				default:
+					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
+			}
+		}
+		public virtual List<TEntity> Insert(IEnumerable<TEntity> entitys) {
+			switch (_fsql.Ado.DataType) {
+				case DataType.SqlServer:
+				case DataType.PostgreSQL:
+					return OrmInsert(entitys).ExecuteInserted();
+				case DataType.MySql:
+				case DataType.Oracle:
+				case DataType.Sqlite:
+				default:
+					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
+			}
+		}
+		async public virtual Task<TEntity> InsertAsync(TEntity entity) {
+			switch (_fsql.Ado.DataType) {
+				case DataType.SqlServer:
+				case DataType.PostgreSQL:
+					return (await OrmInsert(entity).ExecuteInsertedAsync()).FirstOrDefault();
+				case DataType.MySql:
+				case DataType.Oracle:
+				case DataType.Sqlite:
+				default:
+					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
+			}
+		}
+		public virtual Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys) {
+			switch (_fsql.Ado.DataType) {
+				case DataType.SqlServer:
+				case DataType.PostgreSQL:
+					return OrmInsert(entitys).ExecuteInsertedAsync();
+				case DataType.MySql:
+				case DataType.Oracle:
+				case DataType.Sqlite:
+				default:
+					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
+			}
+		}
+
+		public int Update(TEntity entity) => OrmUpdate(entity).ExecuteAffrows();
+		public Task<int> UpdateAsync(TEntity entity) => OrmUpdate(entity).ExecuteAffrowsAsync();
+
+		protected ISelect<TEntity> OrmSelect(object dywhere) {
+			var select = _fsql.Select<TEntity>(dywhere).WithTransaction(_tran);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) select.Where(filter.Value.Expression);
+			return select.AsTable(AsTableSelect);
+		}
+		protected IUpdate<TEntity> OrmUpdate(object dywhere) {
+			var entityObj = dywhere as TEntity;
+			var update = _fsql.Update<TEntity>(dywhere).WithTransaction(_tran);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				if (entityObj != null && filter.Value.ExpressionDelegate?.Invoke(entityObj) == false)
+					throw new Exception($"FreeSql.Repository Update 失败，因为设置了 {filter.Key}: {filter.Value.Expression}，更新的数据不符合");
+				update.Where(filter.Value.Expression);
+			}
+			return update.AsTable(AsTable);
+		}
+		protected IDelete<TEntity> OrmDelete(object dywhere) {
+			var delete = _fsql.Delete<TEntity>(dywhere).WithTransaction(_tran);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) delete.Where(filter.Value.Expression);
+			return delete.AsTable(AsTable);
+		}
+		protected IInsert<TEntity> OrmInsert(TEntity entity) => OrmInsert(new[] { entity });
+		protected IInsert<TEntity> OrmInsert(IEnumerable<TEntity> entitys) {
+			var insert = _fsql.Insert<TEntity>(entitys).WithTransaction(_tran);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				foreach (var entity in entitys)
+					if (entity != null && filter.Value.ExpressionDelegate?.Invoke(entity) == false)
+						throw new Exception($"FreeSql.Repository Insert 失败，因为设置了 {filter.Key}: {filter.Value.Expression}，插入的数据不符合");
+			}
+			return insert.AsTable(AsTable);
+		}
+
+		protected void ApplyDataFilter(string name, Expression<Func<TEntity, bool>> exp) => DataFilter.Apply(name, exp);
+	}
+
+	public abstract class BaseRepository<TEntity, TKey> : BaseRepository<TEntity>, IRepository<TEntity, TKey>
+		where TEntity : class {
+
+		public BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) : base(fsql, filter, asTable) {
+		}
+
+		public int Delete(TKey id) => OrmDelete(id).ExecuteAffrows();
+		public Task<int> DeleteAsync(TKey id) => OrmDelete(id).ExecuteAffrowsAsync();
+
+		public TEntity Find(TKey id) => OrmSelect(id).ToOne();
+		public Task<TEntity> FindAsync(TKey id) => OrmSelect(id).ToOneAsync();
+
+		public TEntity Get(TKey id) => Find(id);
+		public Task<TEntity> GetAsync(TKey id) => FindAsync(id);
+	}
+}

FreeSql.Repository/Repository/DefaultRepository.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public class DefaultRepository<TEntity, TKey> :
+		BaseRepository<TEntity, TKey>
+		where TEntity : class {
+
+		public DefaultRepository(IFreeSql fsql) : base(fsql, null, null) {
+
+		}
+
+		public DefaultRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter) : base(fsql, filter, null) {
+		}
+	}
+}

FreeSql.Repository/Repository/GuidRepository.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public class GuidRepository<TEntity> :
+		BaseRepository<TEntity, Guid>
+		where TEntity : class {
+
+		public GuidRepository(IFreeSql fsql) : this(fsql, null, null) {
+
+		}
+		public GuidRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable) : base(fsql, filter, asTable) {
+		}
+
+		public override List<TEntity> Insert(IEnumerable<TEntity> entity) {
+			OrmInsert(entity).ExecuteAffrows();
+			return entity.ToList();
+		}
+		async public override Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entity) {
+			await OrmInsert(entity).ExecuteAffrowsAsync();
+			return entity.ToList();
+		}
+
+		public override TEntity Insert(TEntity entity) {
+			OrmInsert(entity).ExecuteAffrows();
+			return entity;
+		}
+		async public override Task<TEntity> InsertAsync(TEntity entity) {
+			await OrmInsert(entity).ExecuteAffrowsAsync();
+			return entity;
+		}
+	}
+}

FreeSql.Repository/Repository/IBasicRepository.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public interface IBasicRepository<TEntity> : IReadOnlyRepository<TEntity>
+		where TEntity : class {
+		TEntity Insert(TEntity entity);
+
+		List<TEntity> Insert(IEnumerable<TEntity> entitys);
+
+		Task<TEntity> InsertAsync(TEntity entity);
+
+		Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys);
+
+		int Update(TEntity entity);
+
+		Task<int> UpdateAsync(TEntity entity);
+
+		IUpdate<TEntity> UpdateDiy { get; }
+
+		int Delete(TEntity entity);
+
+		Task<int> DeleteAsync(TEntity entity);
+	}
+
+	public interface IBasicRepository<TEntity, TKey> : IBasicRepository<TEntity>, IReadOnlyRepository<TEntity, TKey>
+		where TEntity : class {
+		int Delete(TKey id);
+
+		Task<int> DeleteAsync(TKey id);
+	}
+}
+

FreeSql.Repository/Repository/IReadOnlyRepository.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public interface IReadOnlyRepository<TEntity> : IRepository
+		where TEntity : class {
+
+		IDataFilter<TEntity> DataFilter { get; }
+
+		ISelect<TEntity> Select { get; }
+	}
+
+	public interface IReadOnlyRepository<TEntity, TKey> : IReadOnlyRepository<TEntity>
+		where TEntity : class {
+		TEntity Get(TKey id);
+
+		Task<TEntity> GetAsync(TKey id);
+
+		TEntity Find(TKey id);
+
+		Task<TEntity> FindAsync(TKey id);
+	}
+}

FreeSql.Repository/Repository/IRepository.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+
+	public interface IRepository {
+		Type EntityType { get; }
+	}
+
+	public interface IRepository<TEntity> : IReadOnlyRepository<TEntity>, IBasicRepository<TEntity>
+		where TEntity : class {
+		int Delete(Expression<Func<TEntity, bool>> predicate);
+
+		Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate);
+	}
+
+	public interface IRepository<TEntity, TKey> : IRepository<TEntity>, IReadOnlyRepository<TEntity, TKey>, IBasicRepository<TEntity, TKey>
+		where TEntity : class {
+	}
+}