框架結構 實體層： Typecho.Enties 倉儲層： Typecho.IRepository IconcardContext.cs IRepositoryFactory.cs IRepositorys.cs Typecho.Repository RepositoryFactory.cs Rep ...
框架結構
實體層：
Typecho.Enties
倉儲層：
Typecho.IRepository
IconcardContext.cs
IRepositoryFactory.cs
IRepositorys.cs
Typecho.Repository
RepositoryFactory.cs
Repositorys.cs
typechoContext.cs
業務層：
Typecho.IService
IBaseService.cs
ITypechoTestService.cs
Typecho.Service
BaseService.cs
TypechoService.cs
UI層（api）：
TypechoCore1
TestController.cs
一： EF從資料庫生成實體類到Enties
1.執行以下語句安裝依賴包
Install-Package MySql.Data.EntityFrameworkCore -Pre
Install-Package Pomelo.EntityFrameworkCore.MySql
Install-Package Microsoft.EntityFrameworkCore.Tools
Install-Package Microsoft.VisualStudio.Web.CodeGeneration.Design
2.在程式包包管理器控制台
Scaffold-DbContext "server=localhost;userid=root;pwd=1;port=3306;database=syerp;sslmode=none;" Pomelo.EntityFrameworkCore.MySql -OutputDir Models -Force
自動生成所有類模型文件，typechoContext.cs資料庫上下文自動創建好了
-OutputDir 實體文件所存放的文件目錄
-ContextDir DbContext文件存放的目錄
-Context DbContext文件名
-Schemas 需要生成實體數據的數據表所在的模式
-Tables 需要生成實體數據的數據表的集合
-DataAnnotations
-UseDatabaseNames 直接使用資料庫中的表名和列名（某些版本不支持）
-Force 強制執行，重寫已經存在的實體文件
二：封裝數據訪問層
封裝倉儲Repositorys模式，把typechoContext.cs這個類複製到Typecho.Repository程式集中
typechoContext類：
using Microsoft.EntityFrameworkCore;
using Typecho.Enties.Models;
using Typecho.IRepository;
namespace Typecho.Repository
{
public partial class typechoContext : DbContext , IconcardContext
{
public typechoContext(DbContextOptions<typechoContext> options)
: base(options)
{
}
public virtual DbSet<typecho_comments> typecho_comments { get; set; }
public virtual DbSet<typecho_contents> typecho_contents { get; set; }
public virtual DbSet<typecho_fields> typecho_fields { get; set; }
public virtual DbSet<typecho_links> typecho_links { get; set; }
public virtual DbSet<typecho_metas> typecho_metas { get; set; }
public virtual DbSet<typecho_options> typecho_options { get; set; }
public virtual DbSet<typecho_relationships> typecho_relationships { get; set; }
public virtual DbSet<typecho_users> typecho_users { get; set; }
public virtual DbSet<typecho_test> typecho_test { get; set; }
// protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
// {
// if (!optionsBuilder.IsConfigured)
// {
//#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
// optionsBuilder.UseMySql("server=localhost;userid=root;pwd=woshishui;port=3306;database=typecho;sslmode=none", x => x.ServerVersion("8.0.16-mysql"));
// }
// }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<typecho_comments>(entity =>
{
entity.HasKey(e => e.coid)
.HasName("PRIMARY");
entity.HasIndex(e => e.cid)
.HasName("cid");
entity.HasIndex(e => e.created)
.HasName("created");
entity.Property(e => e.coid).HasColumnType("int(10) unsigned");
entity.Property(e => e.agent)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.author)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.authorId)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.cid)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.created)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.ip)
.HasColumnType("varchar(64)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.mail)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.ownerId)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.parent)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.stars)
.HasColumnType("int(10)")
.HasDefaultValueSql("'0'");
entity.Property(e => e.status)
.HasColumnType("varchar(16)")
.HasDefaultValueSql("'approved'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.text)
.HasColumnType("text")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.type)
.HasColumnType("varchar(16)")
.HasDefaultValueSql("'comment'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.url)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
modelBuilder.Entity<typecho_contents>(entity =>
{
entity.HasKey(e => e.cid)
.HasName("PRIMARY");
entity.HasIndex(e => e.created)
.HasName("created");
entity.HasIndex(e => e.slug)
.HasName("slug")
.IsUnique();
entity.Property(e => e.cid).HasColumnType("int(10) unsigned");
entity.Property(e => e.allowComment)
.HasColumnType("char(1)")
.HasDefaultValueSql("'0'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.allowFeed)
.HasColumnType("char(1)")
.HasDefaultValueSql("'0'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.allowPing)
.HasColumnType("char(1)")
.HasDefaultValueSql("'0'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.authorId)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.commentsNum)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.created)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.modified)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.order)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.parent)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.password)
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.slug)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.status)
.HasColumnType("varchar(16)")
.HasDefaultValueSql("'publish'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.template)
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.text)
.HasColumnType("longtext")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.title)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.type)
.HasColumnType("varchar(16)")
.HasDefaultValueSql("'post'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.views)
.HasColumnType("int(10)")
.HasDefaultValueSql("'0'");
});
modelBuilder.Entity<typecho_fields>(entity =>
{
entity.HasKey(e => new { e.cid, e.name })
.HasName("PRIMARY");
entity.HasIndex(e => e.float_value)
.HasName("float_value");
entity.HasIndex(e => e.int_value)
.HasName("int_value");
entity.Property(e => e.cid).HasColumnType("int(10) unsigned");
entity.Property(e => e.name)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.float_value).HasDefaultValueSql("'0'");
entity.Property(e => e.int_value)
.HasColumnType("int(10)")
.HasDefaultValueSql("'0'");
entity.Property(e => e.str_value)
.HasColumnType("text")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.type)
.HasColumnType("varchar(8)")
.HasDefaultValueSql("'str'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
modelBuilder.Entity<typecho_links>(entity =>
{
entity.HasKey(e => e.lid)
.HasName("PRIMARY");
entity.Property(e => e.lid)
.HasColumnType("int(10) unsigned")
.HasComment("links表主鍵");
entity.Property(e => e.description)
.HasColumnType("varchar(200)")
.HasComment("links描述")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.image)
.HasColumnType("varchar(200)")
.HasComment("links圖片")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.name)
.HasColumnType("varchar(200)")
.HasComment("links名稱")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.order)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'")
.HasComment("links排序");
entity.Property(e => e.sort)
.HasColumnType("varchar(200)")
.HasComment("links分類")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.url)
.HasColumnType("varchar(200)")
.HasComment("links網址")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.user)
.HasColumnType("varchar(200)")
.HasComment("自定義")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
modelBuilder.Entity<typecho_metas>(entity =>
{
entity.HasKey(e => e.mid)
.HasName("PRIMARY");
entity.HasIndex(e => e.slug)
.HasName("slug");
entity.Property(e => e.mid).HasColumnType("int(10) unsigned");
entity.Property(e => e.count)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.description)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.name)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.order)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.parent)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.slug)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.type)
.IsRequired()
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
modelBuilder.Entity<typecho_options>(entity =>
{
entity.HasKey(e => new { e.name, e.user })
.HasName("PRIMARY");
entity.Property(e => e.name)
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.user).HasColumnType("int(10) unsigned");
entity.Property(e => e.value)
.HasColumnType("text")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
modelBuilder.Entity<typecho_relationships>(entity =>
{
entity.HasKey(e => new { e.cid, e.mid })
.HasName("PRIMARY");
entity.Property(e => e.cid).HasColumnType("int(10) unsigned");
entity.Property(e => e.mid).HasColumnType("int(10) unsigned");
});
modelBuilder.Entity<typecho_users>(entity =>
{
entity.HasKey(e => e.uid)
.HasName("PRIMARY");
entity.HasIndex(e => e.mail)
.HasName("mail")
.IsUnique();
entity.HasIndex(e => e.name)
.HasName("name")
.IsUnique();
entity.Property(e => e.uid).HasColumnType("int(10) unsigned");
entity.Property(e => e.activated)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.authCode)
.HasColumnType("varchar(64)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.created)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.group)
.HasColumnType("varchar(16)")
.HasDefaultValueSql("'visitor'")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.logged)
.HasColumnType("int(10) unsigned")
.HasDefaultValueSql("'0'");
entity.Property(e => e.mail)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.name)
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.password)
.HasColumnType("varchar(64)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.screenName)
.HasColumnType("varchar(32)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
entity.Property(e => e.url)
.HasColumnType("varchar(200)")
.HasCharSet("utf8")
.HasCollation("utf8_general_ci");
});
OnModelCreatingPartial(modelBuilder);
}
partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}
}
IRepositorys介面：
public interface IRepositorys<T> : IDisposable where T : class
{
/// <summary>
/// 顯式開啟數據上下文事務
/// </summary>
/// <param name="isolationLevel">指定連接的事務鎖定行為</param>
void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.Unspecified);
/// <summary>
/// 提交事務的更改
/// </summary>
void Commit();
/// <summary>
/// 顯式回滾事務，僅在顯式開啟事務後有用
/// </summary>
void Rollback();
/// <summary>
/// 提交當前單元操作的更改
/// </summary>
int SaveChanges();
Task<int> SaveChangesAsync();
/// <summary>
/// 獲取 當前實體類型的查詢數據集，數據將使用不跟蹤變化的方式來查詢，當數據用於展現時，推薦使用此數據集，如果用於新增，更新，刪除時，請使用<see cref="TrackEntities"/>數據集
/// </summary>
IQueryable<T> Entities { get; }
/// <summary>
/// 獲取 當前實體類型的查詢數據集，當數據用於新增，更新，刪除時，使用此數據集，如果數據用於展現，推薦使用<see cref="Entities"/>數據集
/// </summary>
IQueryable<T> TrackEntities { get; }
/// <summary>
/// 插入 - 通過實體對象添加
/// </summary>
/// <param name="entity">實體對象</param>
/// <param name="isSave">是否執行</param>
/// /// <returns></returns>
T Add(T entity, bool isSave = true);
Task<T> AysAdd(T entity, bool isSave = true);
/// <summary>
/// 批量插入 - 通過實體對象集合添加
/// </summary>
/// <param name="entitys">實體對象集合</param>
/// <param name="isSave">是否執行</param>
void AddRange(IEnumerable<T> entitys, bool isSave = true);
/// <summary>
/// 刪除 - 通過實體對象刪除
/// </summary>
/// <param name="entity">實體對象</param>
/// <param name="isSave">是否執行</param>
void Delete(T entity, bool isSave = true);
/// <summary>
/// 批量刪除 - 通過實體對象集合刪除
/// </summary>
/// <param name="entitys">實體對象集合</param>
/// <param name="isSave">是否執行</param>
void Delete(bool isSave = false, params T[] entitys);
/// <summary>
/// 刪除 - 通過主鍵ID刪除
/// </summary>
/// <param name="id">主鍵ID</param>
Task<int> AsyDelete(object id);
int Delete(object id);
/// <summary>
/// 批量刪除 - 通過條件刪除
/// </summary>
/// <param name="where">過濾條件</param>
/// <param name="isSave">是否執行</param>
void Delete(Expression<Func<T, bool>> @where, bool isSave = true);
/// <summary>
/// 修改 - 通過實體對象修改
/// </summary>
/// <param name="entity">實體對象</param>
Task<int> AysUpdate(T entity);
int Update(T entity);
/// <summary>
/// 批量修改 - 通過實體對象集合修改
/// </summary>
/// <param name="entitys">實體對象集合</param>
void Update( params T[] entitys);
/// <summary>
/// 是否滿足條件
/// </summary>
/// <param name="where">過濾條件</param>
/// <returns></returns>
bool Any(Expression<Func<T, bool>> @where);
/// <summary>
/// 返回總條數
/// </summary>
/// <returns></returns>
int Count();
/// <summary>
/// 返回總條數 - 通過條件過濾
/// </summary>
/// <param name="where">過濾條件</param>
/// <returns></returns>
int Count(Expression<Func<T, bool>> @where);
/// <summary>
/// 返回第一條記錄
/// </summary>
/// <param name="where">過濾條件</param>
/// <returns></returns>
T FirstOrDefault(Expression<Func<T, bool>> @where);
/// <summary>
/// 返回第一條記錄 - 通過條件過濾
/// </summary>
/// <typeparam name="TOrder">排序約束</typeparam>
/// <param name="where">過濾條件</param>
/// <param name="order">排序條件</param>
/// <param name="isDesc">排序方式</param>
/// <returns></returns>
T FirstOrDefault<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, bool isDesc = false);
/// <summary>
/// 去重查詢
/// </summary>
/// <param name="where">過濾條件</param>
/// <returns></returns>
IQueryable<T> Distinct(Expression<Func<T, bool>> @where);
/// <summary>
/// 條件查詢
/// </summary>
/// <param name="where">過濾條件</param>
/// <returns></returns>
IQueryable<T> Where(Expression<Func<T, bool>> @where);
/// <summary>
/// 條件查詢 - 支持排序
/// </summary>
/// <typeparam name="TOrder">排序約束</typeparam>
/// <param name="where">過濾條件</param>
/// <param name="order">排序條件</param>
/// <param name="isDesc">排序方式</param>
/// <returns></returns>
IQueryable<T> Where<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, bool isDesc = false);
/// <summary>
/// 條件分頁查詢 - 支持排序
/// </summary>
/// <typeparam name="TOrder">排序約束</typeparam>
/// <param name="where">過濾條件</param>
/// <param name="order">排序條件</param>
/// <param name="pageIndex">當前頁碼</param>
/// <param name="pageSize">每頁記錄條數</param>
/// <param name="count">返回總條數</param>
/// <param name="isDesc">是否倒序</param>
/// <returns></returns>
IEnumerable<T> Where<TOrder>(Func<T, bool> @where, Func<T, TOrder> order, int pageIndex, int pageSize, out int count, bool isDesc = false);
/// <summary>
/// 條件分頁查詢 - 支持排序 - 支持Select導航屬性查詢
/// </summary>
/// <typeparam name="TOrder">排序約束</typeparam>
/// <param name="where">過濾條件</param>
/// <param name="order">排序條件</param>
/// <param name="pageIndex">當前頁碼</param>
/// <param name="pageSize">每頁記錄條數</param>
/// <param name="count">返回總條數</param>
/// <param name="isDesc">是否倒序</param>
/// <returns></returns>
IQueryable<T> Where<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, int pageIndex, int pageSize, out int count, bool isDesc = false);
/// <summary>
/// 獲取所有數據
/// </summary>
/// <returns></returns>
IQueryable<T> GetAll();
/// <summary>
/// 獲取所有數據 - 支持排序
/// </summary>
/// <typeparam name="TOrder">排序約束</typeparam>
/// <param name="order">排序條件</param>
/// <param name="isDesc">排序方式</param>
/// <returns></returns>
IQueryable<T> GetAll<TOrder>(Expression<Func<T, TOrder>> order, bool isDesc = false);
/// <summary>
/// 根據ID查詢
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="id">主鍵ID</param>
/// <returns></returns>
T GetById<TType>(TType id);
/// <summary>
/// 獲取最大值
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="column">欄位條件</param>
/// <returns></returns>
TType Max<TType>(Expression<Func<T, TType>> column);
/// <summary>
/// 獲取最大值
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="column">欄位條件</param>
/// <param name="where">過濾條件</param>
/// <returns></returns>
TType Max<TType>(Expression<Func<T, TType>> column, Expression<Func<T, bool>> @where);
/// <summary>
/// 獲取最小值
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="column">欄位條件</param>
/// <returns></returns>
TType Min<TType>(Expression<Func<T, TType>> column);
/// <summary>
/// 獲取最小值
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="column">欄位條件</param>
/// <param name="where">過濾條件</param>
/// <returns></returns>
TType Min<TType>(Expression<Func<T, TType>> column, Expression<Func<T, bool>> @where);
/// <summary>
/// 獲取總數
/// </summary>
/// <typeparam name="TType">欄位類型</typeparam>
/// <param name="selector">欄位條件</param>
/// <param name="where">過濾條件</param>
/// <returns></returns>
TType Sum<TType>(Expression<Func<T, TType>> selector, Expression<Func<T, bool>> @where) where TType : new();
}
Repositorys類，CRUD功能的封裝
public class Repositorys<T> : IRepositorys<T> where T : class
{
private typechoContext _dbContext;
private readonly DbSet<T> _dbSet;
private readonly string _connStr;
public Repositorys(IconcardContext mydbcontext)
{
_dbContext = mydbcontext as typechoContext;
if (_dbContext == null)
{
return;
}
_dbSet = _dbContext.Set<T>();
_connStr = _dbContext.Database.GetDbConnection().ConnectionString;
}
public void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.Unspecified)
{
if (_dbContext.Database.CurrentTransaction == null)
{
_dbContext.Database.BeginTransaction(isolationLevel);
}
}
public void Commit()
{
var transaction = this._dbContext.Database.CurrentTransaction;
if (transaction != null)
{
try
{
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
public void Rollback()
{
if (_dbContext.Database.CurrentTransaction != null)
{
_dbContext.Database.CurrentTransaction.Rollback();
}
}
public int SaveChanges()
{
return _dbContext.SaveChanges();
}
public async Task<int> SaveChangesAsync()
{
return await _dbContext.SaveChangesAsync();
}
public IQueryable<T> Entities
{
get { return _dbSet.AsNoTracking(); }
}
public IQueryable<T> TrackEntities
{
get { return _dbSet; }
}
public T Add(T entity, bool isSave = true)
{
_dbSet.Add(entity);
if (isSave)
{
SaveChanges();
}
return entity;
}
public async Task<T> AysAdd(T entity, bool isSave = true)
{
await _dbSet.AddAsync(entity);
if (isSave)
{
await SaveChangesAsync();
}
return entity;
}
public void AddRange(IEnumerable<T> entitys, bool isSave = true)
{
_dbSet.AddRange(entitys);
if (isSave)
{
SaveChanges();
}
}
public void Delete(T entity, bool isSave = true)
{
this._dbSet.Remove(entity);
if (isSave)
{
this.SaveChanges();
}
}
public void Delete(bool isSave = true, params T[] entitys)
{
this._dbSet.RemoveRange(entitys);
if (isSave)
{
this.SaveChanges();
}
}
public async Task<int> AsyDelete(object id)
{
int de = 0;
//執行查詢
var todoItem = await _dbSet.FindAsync(id);
if (todoItem == null)
{
//return NotFound();
de = 0;
}
else
{
_dbSet.Remove(todoItem);
de = SaveChanges();
}
return de;
}
public int Delete(object id)
{
int de = 0;
//執行查詢
var todoItem =_dbSet.Find(id);
if (todoItem == null)
{
//return NotFound();
de = 0;
}
else
{
_dbSet.Remove(todoItem);
de = SaveChanges();
}
return de;
}
public void Delete(Expression<Func<T, bool>> @where, bool isSave = true)
{
T[] entitys = this._dbSet.Where(@where).ToArray();
if (entitys.Length > 0)
{
this._dbSet.RemoveRange(entitys);
}
if (isSave)
{
this.SaveChanges();
}
}
public async Task<int> AysUpdate(T entity)
{
var entry = this._dbContext.Entry(entity);
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Modified;
}
var da = await Task.Run(SaveChangesAsync);
return da;
}
public int Update(T entity)
{
var entry = this._dbContext.Entry(entity);
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Modified;
}
var da = SaveChanges();
return da;
}
public void Update( params T[] entitys)
{
var entry = this._dbContext.Entry(entitys);
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Modified;
}
SaveChanges();
}
public bool Any(Expression<Func<T, bool>> @where)
{
return this._dbSet.AsNoTracking().Any(@where);
}
public int Count()
{
return this._dbSet.AsNoTracking().Count();
}
public int Count(Expression<Func<T, bool>> @where)
{
return this._dbSet.AsNoTracking().Count(@where);
}
public T FirstOrDefault(Expression<Func<T, bool>> @where)
{
return this._dbSet.AsNoTracking().FirstOrDefault(@where);
}
public T FirstOrDefault<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, bool isDesc = false)
{
if (isDesc)
{
return this._dbSet.AsNoTracking().OrderByDescending(order).FirstOrDefault(@where);
}
else
{
return this._dbSet.AsNoTracking().OrderBy(order).FirstOrDefault(@where);
}
}
public IQueryable<T> Distinct(Expression<Func<T, bool>> @where)
{
return this._dbSet.AsNoTracking().Where(@where).Distinct();
}
public IQueryable<T> Where(Expression<Func<T, bool>> @where)
{
return this._dbSet.Where(@where);
}
public IQueryable<T> Where<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, bool isDesc = false)
{
if (isDesc)
{
return this._dbSet.Where(@where).OrderByDescending(order);
}
else
{
return this._dbSet.Where(@where).OrderBy(order);
}
}
public IEnumerable<T> Where<TOrder>(Func<T, bool> @where, Func<T, TOrder> order, int pageIndex, int pageSize, out int count, bool isDesc = false)
{
count = Count();
if (isDesc)
{
return this._dbSet.Where(@where).OrderByDescending(order).Skip((pageIndex - 1) * pageSize).Take(pageSize);
}
else
{
return this._dbSet.Where(@where).OrderBy(order).Skip((pageIndex - 1) * pageSize).Take(pageSize);
}
}
public IQueryable<T> Where<TOrder>(Expression<Func<T, bool>> @where, Expression<Func<T, TOrder>> order, int pageIndex, int pageSize, out int count, bool isDesc = false)
{
count = Count();
if (isDesc)
{
return this._dbSet.Where(@where).OrderByDescending(order).Skip((pageIndex - 1) * pageSize).Take(pageSize);
}
else
{
return this._dbSet.Where(@where).OrderBy(order).Skip((pageIndex - 1) * pageSize).Take(pageSize);
}
}
public IQueryable<T> GetAll()
{
return this._dbSet.AsNoTracking();
}
public IQueryable<T> GetAll<TOrder>(Expression<Func<T, TOrder>> order, bool isDesc = false)
{
if (isDesc)
{
return this._dbSet.AsNoTracking().OrderByDescending(order);
}
else
{
return this._dbSet.AsNoTracking().OrderBy(order);
}
}
public T GetById<TType>(TType id)
{
return this._dbSet.Find(id);
}
public TType Max<TType>(Expression<Func<T, TType>> column)
{
if (this._dbSet.AsNoTracking().Any())
{
return this._dbSet.AsNoTracking().Max(column);
}
return default(TType);
}
public TType Max<TType>(Expression<Func<T, TType>> column, Expression<Func<T, bool>> @where)
{
if (this._dbSet.AsNoTracking().Any(@where))
{
return this._dbSet.AsNoTracking().Where(@where).Max(column);
}
return default(TType);
}
public TType Min<TType>(Expression<Func<T, TType>> column)
{
if (this._dbSet.AsNoTracking().Any())
{
return this._dbSet.AsNoTracking().Min(column);
}
return default(TType);
}
public TType Min<TType>(Expression<Func<T, TType>> column, Expression<Func<T, bool>> @where)
{
if (this._dbSet.AsNoTracking().Any(@where))
{
return this._dbSet.AsNoTracking().Where(@where).Min(column);
}
return default(TType);
}
public TType Sum<TType>(Expression<Func<T, TType>> selector, Expression<Func<T, bool>> @where) where TType : new()
{
object result = 0;
if (new TType().GetType() == typeof(decimal))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, decimal>>);
}
if (new TType().GetType() == typeof(decimal?))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, decimal?>>);
}
if (new TType().GetType() == typeof(double))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, double>>);
}
if (new TType().GetType() == typeof(double?))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, double?>>);
}
if (new TType().GetType() == typeof(float))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, float>>);
}
if (new TType().GetType() == typeof(float?))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, float?>>);
}
if (new TType().GetType() == typeof(int))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, int>>);
}
if (new TType().GetType() == typeof(int?))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, int?>>);
}
if (new TType().GetType() == typeof(long))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, long>>);
}
if (new TType().GetType() == typeof(long?))
{
result = this._dbSet.AsNoTracking().Where(where).Sum(selector as Expression<Func<T, long?>>);
}
return (TType)result;
}
public void Dispose()
{
this._dbContext.Dispose();
}
}
三： 通過DI創建實例
添加RepositoryFactory類和IRepositoryFactory介面
IRepositoryFactory介面：
public interface IRepositoryFactory
{
IRepositorys<T> CreateRepository<T>(IconcardContext mydbcontext) where T : class;
}
RepositoryFactory類：
public class RepositoryFactory : IRepositoryFactory
{
public IRepositorys<T> CreateRepository<T>(IconcardContext mydbcontext) where T : class
{
return new Repositorys<T>(mydbcontext);
}
}
四：Service層
添加BaseService類和IBaseService介面
IBaseService介面：
public interface IBaseService
{
IRepositorys<T> CreateService<T>() where T : class, new();
}
BaseService類：
public class BaseService : IBaseService
{
private IRepositoryFactory _repositoryFactory;
private IconcardContext _mydbcontext;
public BaseService(IRepositoryFactory repositoryFactory, IconcardContext mydbcontext)
{
this._repositoryFactory = repositoryFactory;
this._mydbcontext = mydbcontext;
}
public IRepositorys<T> CreateService<T>() where T : class, new()
{
return _repositoryFactory.CreateRepository<T>(_mydbcontext);
}
}
添加Service模塊xxxService類和IxxxService介面，xxxService類繼承父類BaseService，生成構造函數。
//構造函數 自動生成
public TypechoService(IRepositoryFactory repositoryFactory, IconcardContext mydbcontext) : base(repositoryFactory, mydbcontext)
{
}
五：DI依賴註入配置
註冊DbContext
services.AddDbContext<typechoContext>(options=>options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));
\\appsettings.json
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;database=typecho;uid=root;pwd=woshishui;"
}
services.AddScoped<IconcardContext, typechoContext>();//dbc
services.AddScoped<IRepositoryFactory, RepositoryFactory>();//泛型工廠
services.AddScoped<ITypechoTestService, TypechoService>();//ioc
六：UI層調用service介面
TestController ：實現調用倉儲封裝增刪改查
[Route("api/[controller]")]
[ApiController]
public class TestController : Controller
{
private readonly typechoContext _coreDbContext;
private readonly ITokenHelper _tokenHelper = null;
// ITypechoTestService service = new TypechoService();
private readonly ITypechoTestService _service; //IOC依賴註入
public TestController(typechoContext coreDbContext,ITokenHelper tokenHelper,ITypechoTestService service)
{
_coreDbContext = coreDbContext;
_tokenHelper = tokenHelper;
_service=service;
}
/// <summary>
/// 驗證Token
/// </summary>
/// <param name="tokenStr">token</param>
/// <returns></returns>
[HttpGet("ValiToken")]
public ReturnModel ValiToken(string tokenStr)
{
var ret = new ReturnModel
{
TnToken = new TnToken()
};
bool isvilidate = _tokenHelper.ValiToken(tokenStr);
if(isvilidate)
{
ret.Code = 200;
ret.Msg = "Token驗證成功";
ret.TnToken.TokenStr = tokenStr;
}
else
{
ret.Code = 500;
ret.Msg = "Token驗證失敗";
ret.TnToken.TokenStr = tokenStr;
}
return ret;
}
/// <summary>
/// 驗證Token 帶返回狀態
/// </summary>
/// <param name="tokenStr"></param>
/// <returns></returns>
[HttpGet("ValiTokenState")]
public ReturnModel ValiTokenState(string tokenStr)
{
var ret = new ReturnModel
{
TnToken = new TnToken()
};
string loginID = "";
TokenType tokenType = _tokenHelper.ValiTokenState(tokenStr, a => a["iss"] == "WYY" && a["aud"] == "EveryTestOne", action => { loginID = action["loginID"]; });
if (tokenType == TokenType.Fail)
{
ret.Code = 202;
ret.Msg = "token驗證失敗";
return ret;
}
if (tokenType == TokenType.Expired)
{
ret.Code = 205;
ret.Msg = "token已經過期";
return ret;
}
//..............其他邏輯
var data = new List<Dictionary<string, string>>();
var bb = new Dictionary<string, string>
{
{ "Wyy", "123456" }
};
data.Add(bb);
ret.Code = 200;
ret.Msg = "訪問成功!";
ret.Data =data ;
return ret;
}
/// <summary>
/// 登錄測試
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
[HttpPost("Login")]
public IActionResult Login([FromBody]LoginInput user)
{
var ret = new ReturnModel();
try
{
if (string.IsNullOrWhiteSpace(user.Username) || string.IsNullOrWhiteSpace(user.Password))
{
ret.Code = 201;
ret.Msg = "用戶名密碼不能為空";
return NotFound();
}
//登錄操作 我就沒寫了 || 假設登錄成功
if (true)
{
Dictionary<string, string> keyValuePairs = new Dictionary<string, string>
{
{ "loginID", user.Username }
};
ret.Code = 200;
ret.Msg = "登錄成功";
ret.TnToken= _tokenHelper.CreateToken(keyValuePairs);
}
}
catch(Exception ex)
{
ret.Code = 500;
ret.Msg = "登錄失敗:"+ex.Message;
}
return Ok(ret);
}
/// <summary>
/// 非同步查詢
/// [ApiExplorerSettings(IgnoreApi = true)] 隱藏介面
/// </summary>
/// <returns></returns>
[ServiceFilter(typeof(TokenFilter))]
[HttpGet("AsyGetTest")]
public async Task<IActionResult> AsyGetTest(string token)
{
return Ok(await _service.AsyGetTest());
}
/// <summary>
/// 同步查詢
/// </summary>
/// <returns></returns>
[HttpGet("GetTest")]
public IActionResult GetTest()
{
return Ok(_service.GetTest());
}
/// <summary>
/// 條件查詢
/// </summary>
/// <returns></returns>
[HttpGet("AsyGetTestName")]
public async Task<IActionResult> AsyGetTestName(int id)
{
return Ok(await _service.AsyGetTestName(id));
}
/// <summary>
/// 過濾查詢
/// </summary>
/// <returns></returns>
[HttpGet("AsyGetTestG")]
public async Task<IActionResult> AsyGetTestG(string name )
{
var courses = _coreDbContext.typecho_test
.Where(w => w.name.Contains(name));
return Ok( await courses.FirstAsync());
}
/// <summary>
/// 模糊查詢
/// </summary>
/// <returns></returns>
[HttpGet("AsyGetTestLink")]
public async Task<IActionResult> AsyGetTestLink(string name )
{
var courses = _coreDbContext.typecho_test
.Where(w=>EF.Functions.Like(w.name,"%"));
return Ok( await courses.ToListAsync());
}
/// <summary>
/// 非同步刪除數據
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete("AsyDetTestId")]
public async Task<IActionResult> AsyDetTestId(int id)
{
return Ok(await _service.AsyDetTestId(id));
}
/// <summary>
/// 同步刪除數據
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete("DetTestId")]
public IActionResult DetTestId(int id)
{
return Ok( _service.DetTestId(id));
}
/// <summary>
/// 非同步添加數據
/// </summary>
/// <returns></returns>
[HttpPost("AsyIntTest")]
public async Task<ActionResult<typecho_test>> AsyIntTest(typecho_test test)
{
return Ok(await _service.AsyIntTest(test));
}
/// <summary>
/// 同步添加數據
/// </summary>
/// <returns></returns>
[HttpPost("IntTest")]
public ActionResult<typecho_test> IntTest(typecho_test test)
{
return Ok(_service.IntTest(test));
}
/// <summary>
/// 非同步更新數據
/// </summary>
/// <param name="test"></param>
/// <returns></returns>
[HttpPut("AysUpTest")]
public async Task<IActionResult> AysUpTest(typecho_test test)
{
var data=await Task.Run(()=> _service.AysUpTest(test));
return Ok(data);
}
/// <summary>
/// 同步更新數據
/// </summary>
/// <param name="id"></param>
/// <param name="test"></param>
/// <returns></returns>
[HttpPut("UpTest")]
public IActionResult UpTest(int id, typecho_test test)
{
var data= _service.UpTest(test);
return Ok(data);
}
}
圖示
