框架結構
物體層：
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 強制執行，重寫已經存在的物體檔案
鏈接： asp.net core3.1 實戰開發（EF+Mysql 從資料庫生成物體類到專案）
二：封裝資料訪問層
封裝倉儲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 = https://www.cnblogs.com/ouyangkai/p/new List>();
var bb = new Dictionary
{
{ "Wyy", "123456" }
};
data.Add(bb);
ret.Code = 200;
ret.Msg = "訪問成功!";
ret.Data =data ;
return ret;
}
///
/// 登錄測驗
///
///
/// keyValuePairs = new Dictionary
{
{ "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);
}
///
/// 異步查詢
/// [ApiExplorerSettings(IgnoreApi = true)] 隱藏介面
///
/// AsyGetTest(string token)
{
return Ok(await _service.AsyGetTest());
}
///
/// 同步查詢
///
///
/// 條件查詢
///
/// AsyGetTestName(int id)
{
return Ok(await _service.AsyGetTestName(id));
}
///
/// 過濾查詢
///
/// AsyGetTestG(string name )
{
var courses = _coreDbContext.typecho_test
.Where(w => w.name.Contains(name));
return Ok( await courses.FirstAsync());
}
///
/// 模糊查詢
///
/// AsyGetTestLink(string name )
{
var courses = _coreDbContext.typecho_test
.Where(w=>EF.Functions.Like(w.name,"%"));
return Ok( await courses.ToListAsync());
}
///
/// 異步洗掉資料
///
///
/// AsyDetTestId(int id)
{
return Ok(await _service.AsyDetTestId(id));
}
///
/// 同步洗掉資料
///
///
///
/// 異步添加資料
///
/// > AsyIntTest(typecho_test test)
{
return Ok(await _service.AsyIntTest(test));
}
///
/// 同步添加資料
///
/// IntTest(typecho_test test)
{
return Ok(_service.IntTest(test));
}
///
/// 異步更新資料
///
///
/// AysUpTest(typecho_test test)
{
var data=await Task.Run(()=> _service.AysUpTest(test));
return Ok(data);
}
///
/// 同步更新資料
///
///
///
/// 圖示
參考：.Net Core2.2 + EF Core + DI，三層框架專案搭建教程
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/33221.html
標籤：.NET Core