An excellent orm in dotnet circle -- FreeSQL

Preface

Today, I'm still thinking about the content of today's month , Then in the afternoon FreeSql Of QQ In the group , Unexpectedly, a melon came out . The general meaning is that there is a famous blogger , Measured several orm Performance of , As a result, the performance data of one domestic framework is not good in all aspects , The result? , The author of this framework with bad data is not happy , Private letter, the blogger of the test , Let others delete blogs , Change the test rules ... Anyway, I just feel that I can't hang on my face .

In fact, it's not a big deal , And anyone who has done development knows , Performance testing , In fact, it's plain , It's just doing something when you're free , There is no need to care too much , Instead of letting others delete blogs , It's better to do a good job in the framework , Or you can just give a test .

Don't say the , I haven't used that framework either , I just feel that open source domestic software should encourage each other , There is no need to hurt each other like this .

Recommended reasons

Get back to business .FreeSql It's a domestic frame , It's very well documented , It's also very powerful , To be specific, let's look directly

file

Well ~~

In actual production projects , What we like to see most , In fact, it is a clearer project framework , More reasonable layering , More neat and lightweight code , To complete more functions . Although the use of ORM It may indeed bring some performance impact , But I also believe that the current production projects , Not many of them need ORM Of , Especially now ORM The performance improvement has been very obvious , And more standardized , There is no need to build the data layer in the traditional way .

The application case

Again , The specific examples given in the official documents are also very perfect , But our project should be deeply integrated freesql The ability of , That is, it supports 100000 + User level websites , It also supports the very complex business logic OA System , So I will simply cite a few specific use cases here .

Injection service

With our OA System as an example , We are DotnetCore 5 Project , adopt startup The form of configuration orm

public void ConfigureServices(IServiceCollection services)
{
 // Log initialization
 services.ConfigureLog();
 
 // orm frame
 services.ConfigureOrm(Configuration);

 //  Cache configuration
 services.ConfigureRedis(Configuration);

 //  Login authorization , Cross domain policy ,session To configure
 services.ConfigurePolicy(Configuration);

 //mvc To configure
 services.ConfigureMvc(Configuration);

 // Other plug-in configuration  
 services.ConfigurePlug(Configuration);
}

In the above paragraph , I also released other configurations , To configure orm The entrance of is on the second line

The specific configuration is mentioned in the static class

static IdleBus<IFreeSql> ib = new IdleBus<IFreeSql>(TimeSpan.FromMinutes(10));
public static void ConfigureOrm(this IServiceCollection services, IConfiguration configuration)
{
 #region orm frame
 ib.Register(&quot;db_system&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;CysccSystemConnString&quot;)).Build());
 ib.Register(&quot;db_castic&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;CysccCasticConnString&quot;)).Build());
 ib.Register(&quot;db_robot&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;CysccRobotConnString&quot;)).Build());
 ib.Register(&quot;db_passport&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;PassportConnString&quot;)).Build());
 ib.Register(&quot;db_matchai&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;MatchAIConnString&quot;)).Build());
 ib.Register(&quot;db_checkin&quot;, () => new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, configuration.GetConnectionString(&quot;CheckInConnString&quot;)).Build());

 services.AddSingleton(ib);
 #endregion
 }

The difference between us and the official case is through IdleBus To match FreeSql, because OA To manage the background data of multiple projects , So there are multiple contexts to switch , use IdleBus The pool management function provided can better manage FreeSql Recovery and release of .

Generate model objects

In a formal project , use freesql After taking over the relational database , You need to generate the corresponding model , Here we are upgrading the existing projects , Therefore, the database first mode is adopted . Can pass freesql Provided CLI To generate the corresponding model .

The specific way is to first according to the project situation , stay CLI Enter the corresponding instructions in the tool , Connection string , Namespace and other parameters , Then all data models will be generated in the specified directory .（ In practice , We may not need to reference all models , You can create the specified directory in the project , Introduce the model we need as needed ）

Write basic operation methods and interfaces

Here is the so-called basic operation method , Is the method used to let other methods inherit , Some basic CURD operation , There is no need to rewrite all businesses , There is a basic generic operation class , Other business methods can be directly inherited , A lot of reduced code .

This , Because there are too many methods in my base class , It's not all listed , Make a brief list of , Because the basic methods are in official documents .

public class MatchAiRespository<T>: IMatchAiRespository<T> where T : class
{
 public class MatchAiRespository<T>: IMatchAiRespository<T> where T : class
 {
 IdleBus<IFreeSql> fsql = null;
 const string conn_str = &quot;db_matchai&quot;;
 public MatchAiRespository(IdleBus<IFreeSql> fsql)
 {
 this.fsql = fsql;
 }
 /// <summary>
 ///  Page search , And return the total
 /// </summary>
 /// <param name=&quot;predicate&quot;></param>
 /// <param name=&quot;pageIndex&quot;></param>
 /// <param name=&quot;pageSize&quot;></param>
 /// <param name=&quot;total&quot;></param>
 /// <returns></returns>
 public List<T> getList(Expression<Func<T, bool>> predicate, int pageIndex, int pageSize, out long total)
 {
 return fsql.Get(conn_str).Select<T>().Where(predicate).Count(out total).Page(pageIndex, pageSize).ToList();
 }

 /// <summary>
 ///  Get the number of records
 /// </summary>
 /// <param name=&quot;predicate&quot;></param>
 /// <returns></returns>
 public async Task<long> getCountAsync(Expression<Func<T, bool>> predicate)
 {
 return await fsql.Get(conn_str).Select<T>().Where(predicate).CountAsync();
 }

 /// <summary>
 ///  Add a single entry , Return the number of affected items
 /// </summary>
 /// <param name=&quot;t&quot;></param>
 /// <returns></returns>
 public int addItem(T t)
 {
 return fsql.Get(conn_str).Insert<T>(t).ExecuteAffrows();
 }
 
 ...
 }
}

Corresponding interface layer ( I am used to writing and realizing first , Then write the interface correspondingly , You can also write the interface first , Then write the implementation )

public interface IMatchAiRespository<T> where T:class
{
 /// <summary>
 ///  Page search , And return the total
 /// </summary>
 /// <param name=&quot;predicate&quot;></param>
 /// <param name=&quot;pageIndex&quot;></param>
 /// <param name=&quot;pageSize&quot;></param>
 /// <param name=&quot;total&quot;></param>
 /// <returns></returns>
 List<T> getList(Expression<Func<T, bool>> predicate, int pageIndex, int pageSize, out long total);

/// <summary>
 ///  Get the number of records （ asynchronous ）
 /// </summary>
 /// <param name=&quot;predicate&quot;></param>
 /// <returns></returns>
 Task<long> getCountAsync(Expression<Func<T, bool>> predicate);
 
 /// <summary>
 ///  Add a single entry , Return the number of affected items
 /// </summary>
 /// <param name=&quot;t&quot;></param>
 /// <returns></returns>
 int addItem(T t);
 
 ...
}

Okay , In fact, here , If you are implementing some basic operations , After creating the method classes and interfaces of the corresponding model , There is no need to write any method , After inheriting the base class , It can be directly used in the controller .

Here I will list another extension method , That is, it inherits the base class , However, some more complex operations need to be implemented , The interface is no longer posted .

public class CertRecordRepo : MatchAiRespository<Cert_Template>, Interfaces.ICertTemplateRespo
{
 private IdleBus<IFreeSql> fsql;
 const string conn_str = &quot;db_matchai&quot;;
 public CertRecordRepo(IdleBus<IFreeSql> fsql) : base(fsql)
 {
  this.fsql = fsql;
 }

 /// <summary>
 ///  Obtain certificate issuance records
 /// </summary>
 /// <param name=&quot;whereJsonStr&quot;></param>
 /// <param name=&quot;total&quot;></param>
 /// <param name=&quot;pageIndex&quot;></param>
 /// <param name=&quot;pageSize&quot;></param>
 /// <returns></returns>
 public dynamic GetCertRecords(string whereJsonStr, out long total, int pageIndex = 1, int pageSize = 10)
 {
 DynamicFilterInfo dyfilter = JsonConvert.DeserializeObject<DynamicFilterInfo>(whereJsonStr); 
 return fsql.Get(conn_str).Select<Cert_Record>()
 .WhereDynamicFilter(dyfilter)
 .Count(out total)
 .Page(pageIndex, pageSize)
 .ToList();
 }

 /// <summary>
 ///  Get certificate export record （ Trials ）
 /// </summary>
 /// <param name=&quot;whereJsonStr&quot;></param>
 /// <returns></returns>
 public async Task<List<CostumModels.CertRecordModel>> GetCertRecordsForExcel(string whereJsonStr)
 {
 DynamicFilterInfo dyfilter = JsonConvert.DeserializeObject<DynamicFilterInfo>(whereJsonStr);
 var list = await fsql.Get(conn_str).Select<Cert_Record, Cert_Template, VIW_ScratchProgramApplyMain>()
 .LeftJoin((a, b, c) => a.Template_id == b.TemplateID)
 .LeftJoin((a, b, c) => a.ProjectNo == c.ProjectNo)
 .WhereDynamicFilter(dyfilter)
 .ToListAsync((a, b, c) => new CostumModels.CertRecordModel
 {
 CertContent = a.CertContent,
 ProgramTypeCaption = c.ProgramTypeCaption,
 ProjectNo = a.ProjectNo,
 ProgramTypeCaptionParent = c.ProgramTypeCaptionParent,
 ProjectSortCaption = c.ProjectSortCaption,
 ProjectWorkCaption = c.ProjectWorkCaption,
 TeamCaption = c.TeamCaption,
 TemplateTypeCaption = b.TemplateTypeCaption,
 ProjectTitle = c.ProjectTitle,
 Score = c.Score,
 //HasScore = c.HasScored,
 AwardName = a.AwardName,
 ProvinceShortName = c.ProvinceShortName,
 CertType = a.CertType,
 CertNo = a.CertNum
 }); 
 return list;
 }
}

controller

The controller is injected directly through the constructor , Or through attribute injection , Inject the constructed interface

[Area("space")]
[Authorize]
public class CertController : Controller
{
 private readonly ICertRecordRepo certRepo;
 private readonly INpoiExcelOperationService npoi;
 private readonly IWebHostEnvironment en;
 private readonly IResponseHelper resp;
 /// <summary>
 ///  Constructors
 /// </summary>
 /// <param name=&quot;certRepo&quot;></param>
 /// <param name=&quot;resp&quot;></param>
 /// <param name=&quot;en&quot;></param>
 /// <param name=&quot;npoi&quot;></param>
 public CertController( ICertRecordRepo certRepo,IResponseHelper resp,IWebHostEnvironment en, INpoiExcelOperationService npoi)
 {
 this.certRepo = certRepo;
 this.en = en;
 this.resp = resp;
 this.npoi = npoi;
 }
 
 /// <summary>
 ///  Get the issuance record
 /// </summary>
 /// <param name=&quot;whereJsonstr&quot;></param>
 /// <param name=&quot;pageIndex&quot;></param>
 /// <param name=&quot;pageSize&quot;></param>
 /// <returns></returns>
 [ResponseCache(Duration =100,VaryByQueryKeys = new string[] {&quot;whereJsonstr&quot;,&quot;rid&quot;})]
 public IActionResult GetCertRecords(string whereJsonstr, int pageIndex = 1, int pageSize = 10)
 {
 long total = 0;
 return Json(_resp.success(new { items = _recordRepo.GetCertRecords(whereJsonstr, out total, pageIndex, pageSize), total }));
 }
 
 /// <summary>
 ///  Export table
 /// </summary>
 /// <param name=&quot;npoi&quot;></param>
 /// <param name=&quot;whereJsonstr&quot;></param>
 /// <returns></returns>
 [HttpPost,ValidateAntiForgeryToken]
 public async Task<IActionResult> ExportCertRecords([FromServices] INpoiExcelOperationService npoi, string whereJsonstr)
 {
 var list = await _recordRepo.GetCertRecordsForExcel(whereJsonstr);
 return Json(await npoi.ExcelDataExportTemplate($&quot; Event 【{list.First().ProgramTypeCaption}】 Certificate issuance record &quot;, list.First().ProgramTypeCaption, list, _en.WebRootPath));
 }

}

thus , Back end code , It's almost over , The code in the controller you can see is very concise , Basically each action Can be controlled in 1-3 Within the line .

Okay ,view I won't list the part of , Finally, let's take a look at the page effect .

Okay , That's basically it . Today's writing is a little miscellaneous , But I still recommend you to try

FreeSql