框架結構
實體層：
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程序集中
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);
}
}
圖示
