![\"数据模型示意图\"](\"https://docs.taosdata.com/assets/images/data-model-b937dfef72001fd8842294bf8fb10cd0.png\")
TDengine 是一款开源、高性能、云原生的时序数据库, 它专为物联网、车联网、工业互联网、金融、IT 运维等场景优化设计
\nTDengine 文档 | TDengine 文档 | 涛思数据
\nFreeSql.Provider.TDengine
\n.NET CLI
\ndotnet add package FreeSql.Provider.TDenginePackage Manager
\nInstall-Package FreeSql.Provider.TDengine如果选择原生连接，而且应用程序不在 TDengine 同一台服务器上运行，你需要先安装客户端驱动，否则可以跳过此一步。为避免客户端驱动和服务端不兼容，请使用一致的版本。
\n\n\n\n建议尽量使用无参数化
\n
static IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.TDengine,\n \"host=localhost;port=6030;username=root;password=taosdata;protocol=Native;db=test;\")\n .UseMonitorCommand(cmd => Console.WriteLine($\"Sql：{cmd.CommandText}\\r\\n\"))\n .UseNoneCommandParameter(true) //无参数化\n .Build();采用“一个数据采集点一张表”的设计虽然有助于针对性地管理每个采集点，但随着设备数量不断增加表的数量也会急剧增加，这给数据库管理和数据分析带来了挑战。在进行跨数据采集点的聚合操作时，用户需要面对大量的表，工作变得异常繁重。
\n为了解决这个问题，TDengine 引入超级表（Super Table，简称为 STable）的概念。超级表是一种数据结构，它能够将某一特定类型的数据采集点聚集在一起，形成一张逻辑上的统一表。这些数据采集点具有相同的表结构，但各自的静态属性（如标签）可能不同。创建超级表时，除了定义采集量以外，还需定义超级表的标签。一张超级表至少包含一个时间戳列、一个或多个采集量列以及一个或多个标签列。此外，超级表的标签可以灵活地进行增加、修改或删除操作。
\n在 TDengine 中，表代表具体的数据采集点，而超级表则代表一组具有相同属性的数据采集点集合。以智能电表为例，我们可以为该类型的电表创建一张超级表，其中包含了所有智能电表的共有属性和采集量。这种设计不仅简化了表的管理，还便于进行跨数据采集点的聚合操作，从而提高数据处理的效率。
\n子表是数据采集点在逻辑上的一种抽象表示，它是隶属于某张超级表的具体表。用户可以将超级表的定义作为模板，并通过指定子表的标签值来创建子表。这样，通过超级表生成的表便被称为子表。超级表与子表之间的关系主要体现在以下几个方面。
\n在 TDengine 中，查询操作既可以在子表上进行，也可以在超级表上进行。针对超级表的查询，TDengine 将所有子表中的数据视为一个整体，首先通过标签筛选出满足查询条件的表，然后在这些子表上分别查询时序数据，最终将各张子表的查询结果合并。本质上，TDengine 通过对超级表查询的支持，实现了多个同类数据采集点的高效聚合。为了更好地理解采集量、标签、超级表与子表之间的关系，这里以智能电表的数据模型为例进行说明。可以参考图 3-1 的数据模型，以便更直观地了解这些概念。
\n为了更好地理解采集量、标签、超级与子表的关系，以智能电表为例，可以参考下图
\n [TDengineSuperTable(Name = \"meters\")]\n class Meters\n {\n [Column(Name = \"ts\")]\n public DateTime Ts { get; set; }\n\n [Column(Name = \"current\")]\n public float Current { get; set; }\n\n [Column(Name = \"voltage\")]\n public int Voltage { get; set; }\n\n [Column(Name = \"describe\", StringLength = 50)]\n public string? Describe { get; set; }\n\n [TDengineTag(Name = \"location\")]\n public virtual string? Location { get; set; }\n\n [TDengineTag(Name = \"group_id\")]\n public virtual int GroupId { get; set; }\n }\n\n [TDengineSubTable(SuperTableName = \"meters\", Name = \"d1001\")]\n class D1001 : Meters\n {\n [TDengineTag(Name = \"location\")]\n public override string Location { get; set; } = \"BeiJIng.ChaoYang\";\n\n [TDengineTag(Name = \"group_id\")]\n public override int GroupId { get; set; } = 1;\n }\n\n\n [TDengineSubTable(SuperTableName = \"meters\", Name = \"d1002\")]\n class D1002 : Meters\n {\n [TDengineTag(Name = \"location\")]\n public new string Location { get; set; } = \"California.SanFrancisco\";\n\n [TDengineTag(Name = \"group_id\")]\n public new int GroupId { get; set; } = 2;\n }\n\nCodeFirst创建表
\n
//尽量确定表结构\n//同步子表会自动创建超表\nfsql.CodeFirst.SyncStructure<D1001>();\nfsql.CodeFirst.SyncStructure<D1002>();\n\n插入数据
\n
//向子表插入数据\nvar affrows = fsql.Insert(new D1002()\n{\n Ts = DateTime.Now,\n Current = 1,\n Voltage = 1,\n Describe = \"D10021\"\n}).ExecuteAffrows();\n\n//批量向子表插入数据，注意 一定要关闭参数化\nvar batchRes = fsql.Insert(new List<D1002>()\n{\n new D1002()\n {\n Ts = DateTime.Now,\n Current = 6,\n Voltage = 6,\n Describe = \"D10026\"\n },\n new D1002()\n {\n Ts = DateTime.Now,\n Current = 3,\n Voltage = 3,\n Describe = \"D10023\"\n },\n new D1002()\n {\n Ts = DateTime.Now,\n Current = 4,\n Voltage = 4,\n Describe = \"D10024\"\n }\n}).ExecuteAffrows();\n\n查询
\n
//查询子表\nvar list = fsql.Select<D1001>().ToList();\n//查询超表\nvar metersList = fsql.Select<Meters>().Where(d => d.GroupId == 2).ToList();\n\n删除
\n
var startTime = DateTime.Parse(\"2024-11-30T02:33:52.308+00:00\");\nvar endTime = DateTime.Parse(\"2024-11-30T02:40:58.961+00:00\");\n//必须包含时间戳\nvar executeAffrows = fsql.Delete<Meters>().Where(meters => meters.Ts >= startTime && meters.Ts <= endTime && meters.GroupId == 1).ExecuteAffrows();DuckDB 是一款进程内分析数据库，它可以在无需维护分布式多服务器系统的情况下处理出人意料的大型数据集。
\nDuckDB has two configurable options for concurrency:
\nFreeSql.Provider.Duckdb
\n.NET CLI
\ndotnet add package FreeSql.Provider.DuckdbPackage Manager
\nInstall-Package FreeSql.Provider.Duckdbstatic IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.DuckDB, \"DataSource = train_services.db\")\n .UseMonitorCommand(cmd => Console.WriteLine($\"Sql：{cmd.CommandText}\"))\n .UseAutoSyncStructure(true) //自动创建表\n .Build();依赖的第三方 ado.net 驱动源代码：https://github.com/Giorgi/DuckDB.NET
\n| Connection String | Description |\n|
\n", "date_published": "2024-08-17T09:27:08.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "ClickHouse", "url": "https://freesql.net/guide/freesql-provider-clickhouse.html", "id": "https://freesql.net/guide/freesql-provider-clickhouse.html", "summary": "介绍 ClickHouse 是一个高性能的开源列式数据库，专为实时大数据分析设计。它以列存储数据，支持快速查询和聚合操作，适合处理大规模数据集。ClickHouse 具备分布式架构、数据压缩和高可用性特性，使其在处理复杂查询和实时数据分析时表现出色。 ClickHouse | 官网 安装包 FreeSql.Provider.ClickHouse .NE...", "content_html": "ClickHouse 是一个高性能的开源列式数据库，专为实时大数据分析设计。它以列存储数据，支持快速查询和聚合操作，适合处理大规模数据集。ClickHouse 具备分布式架构、数据压缩和高可用性特性，使其在处理复杂查询和实时数据分析时表现出色。
FreeSql.Provider.ClickHouse
\n.NET CLI
\ndotnet add package FreeSql.Provider.ClickHousePackage Manager
\nInstall-Package FreeSql.Provider.ClickHousestatic IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.ClickHouse,\n \"DataCompress=False;BufferSize=32768;SocketTimeout=10000;CheckCompressedHash=False;Encrypt=False;Compressor=lz4;\" +\n \"Host=192.168.0.121;Port=8125;Database=PersonnelLocation;Username=root;Password=123\")\n .UseMonitorCommand(cmd => Console.WriteLine($\"Sql：{cmd.CommandText}\"))\n .Build();Firebird 是一个开源的关系型数据库管理系统，它支持嵌入式部署。Firebird 嵌入式数据库适用于需要在本地应用程序中直接集成数据库的场景，无需单独的数据库服务器。它提供了强大的事务处理、数据完整性和并发控制功能，同时保持轻量级和高效。适合小型到中型应用程序，特别是那些需要在不依赖外部数据库服务器的情况下进行本地数据存储和操作的情况。
Firebird 和 Sqlite 都是本地数据库，Firebird 支持并发读写，Sqlite 不支持并发写。
FreeSql.Provider.Firebird
\n.NET CLI
\ndotnet add package FreeSql.Provider.FirebirdPackage Manager
\nInstall-Package FreeSql.Provider.Firebirdstatic IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.Firebird, \"database=localhost:D:\\fbdata\\EXAMPLES.fdb;user=sysdba;password=123456\")\n .UseMonitorCommand(cmd => Console.WriteLine($\"Sql：{cmd.CommandText}\"))\n .UseAutoSyncStructure(true) //自动创建表\n .Build();FreeSql 最多支持 SqlServer2000，根据不同的需求选择驱动包，微软提供了两个 SqlClient 访问包，因此我们也发布了两个，分别是：
\nvar list = fsql.Select<Region>()\n .WithLock()\n .Limit(1).ToList();\n//SELECT TOP 1 ... FROM [Region] a With(NoLock)\n\nvar list = fsql.Select<Region>()\n .WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)\n .Limit(1).ToList();\n//SELECT TOP 1 ... FROM [Region] a With(NoLock, NoWait)\n\nvar list = fsql.Select<Region>()\n .WithLock()\n .WithIndex(\"idx_01\")\n .Limit(1).ToList();\n//SELECT TOP 1 ... FROM [Region] a With(index=idx_01, NoLock)多表：
\nvar list = Select<Region, T2>()\n .InnerJoin((a, b) => a.x == b.xx)\n .WithLock(SqlServerLock.NoLock, new Dictionary<Type, bool>\n {\n [typeof(T2)] = false\n })\n .WithIndex(\"idx_01\", new Dictionary<Type, string>\n {\n [typeof(T2)] = \"idx_02\"\n })\n .Limit(1).ToList();\n//SELECT TOP 1 ..\n//FROM [Region] a With(index=idx_01, NoLock)\n//INNER JOIN [T2] b With(index=idx_02) ON a.[x] = b.[xx]全局设置 NoLock：
\n//所有实体类生效\nfsql.SetGlobalSelectWithLock(SqlServerLock.NoLock, null);\n\n//【指定】实体类生效\nfsql.SetGlobalSelectWithLock(SqlServerLock.NoLock, new Dictionary<Type, bool>\n{\n [typeof(Region)] = true,\n [typeof(T2)] = true\n});fsql.Insert(items)\n .ExecuteSqlBulkCopy();\n\nfsql.Update<T>.SetSource(items)\n .ExecuteSqlBulkCopy(); //临时表 + MERGE INTO\n\nfsql.InsertOrUpdate<T>.SetSource(items)\n .ExecuteSqlBulkCopy(); //临时表 + MERGE INTO使用自定义适配更多的数据库，比如 mssql2000、db2，自定义适配将牺牲一些功能：
\n使用者只需求重写类 FreeSql.Custom.CustomAdapter 就可以自定义访问不同的数据库。
\n默认做了一套 sqlserver 的语法和映射适配，代码在 CustomAdapter.cs，请查看代码了解。
\nclass Mssql2000Adapter : FreeSql.Custom.CustomAdapter\n{\n public override string InsertAfterGetIdentitySql => \"SELECT SCOPE_IDENTITY()\";\n //可以重写更多的设置\n}\n\npublic class DB\n{\n static Lazy<IFreeSql> sqliteLazy = new Lazy<IFreeSql>(() =>\n {\n var fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(DataType.Custom, () => new OdbcConnection(...))\n .UseMonitorCommand(cmd => Trace.WriteLine($\"Sql：{cmd.CommandText}\"))\n .Build();\n fsql.SetCustomAdapter(new Mssql2000Adapter());\n return fsql;\n });\n public static IFreeSql Sqlite => sqliteLazy.Value;\n}适配好新的 CustomAdapter 后，请在 FreeSqlBuilder.Build 之后调用 IFreeSql.SetCustomAdapter 方法生效。
\n使用 ODBC 访问古董数据库。
\n", "date_published": "2024-07-25T07:47:58.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "AdminBlazor", "url": "https://freesql.net/guide/AdminBlazor.html", "id": "https://freesql.net/guide/AdminBlazor.html", "summary": "AdminBlazor 项目介绍 AdminBlazor 是一款 Blazor Server SaaS 中台项目，支持 RABC 权限菜单/按钮，支持快速代码生成一对一、一对多、多对多导航属性的 .razor 界面。 集成功能：菜单、角色、用户、公司组织、定时任务、数据字典、参数配置、租户、审批、审计、OSS文件管理 依赖组件：BootstrapBla...", "content_html": "\nAdminBlazor 是一款 Blazor Server SaaS 中台项目，支持 RABC 权限菜单/按钮，支持快速代码生成一对一、一对多、多对多导航属性的 .razor 界面。
\n集成功能：菜单、角色、用户、公司组织、定时任务、数据字典、参数配置、租户、审批、审计、OSS文件管理
\n依赖组件：BootstrapBlazor、FreeSql、FreeScheduler、Rougamo
\n![\"image\"](\"/adminblazor/0008.png\")
![\"image\"](\"/adminblazor/0001.png\")
\n\ndotnet new install AdminBlazor.Template
\n
\n\ndotnet new admin
\n
\n\n项目结构简洁（没有过多的分层）
\n
\n\nhttp://localhost:5231
\n
用户名：admin 密码：admin
\n![\"image\"](\"/adminblazor/0002.png\")
![\"image\"](\"/adminblazor/0003.png\")
提示：AdminContext 类型已注入为 Scoped
\nclass AdminContext\n{\n public IServiceProvider Service { get; }\n public SysUser User { get; set; }\n public List<SysRole> Roles { get; }\n public List<SysMenus> RoleMenus { get; }\n\n //路由、按钮权限验证\n public bool AuthPath(string path);\n public bool AuthButton(string path)\n}按钮权限，在 razor 中设置特性：
\n[AdminButton(\"name\")]\nvoid ButtonClick()\n{\n}\n\n//或者 webapi\n[Route(\"api/菜单路径\")]\nclass XxxController : ControllerBase\n{\n [HttpGet(\"@name\")]\n public JsonResult ButtonClick()\n {\n }\n}之后菜单管理，会出现对应的按钮项，勾选设置角色是否有按钮的权限。
\n![\"image\"](\"/adminblazor/0004.png\")
![\"image\"](\"/adminblazor/0006.png\")
![\"image\"](\"/adminblazor/0007.png\")
提示：AdminContext 类型已注入为 Scoped
\nclass AdminContext\n{\n public IServiceProvider Service { get; }\n public SysTenant Tenant { get; }\n}每个租户独立数据库，注入方式：
\n\n\nFreeSqlCloud API 访问方式与 IFreeSql 一样\nIAggregateRootRepository 是级联操作友好的仓储模式
\n
![\"image\"](\"/adminblazor/0005.png\")
[Scheduler(\"任务1\", \"0/30 * * * * *\")]\nstatic void Scheduler001()\n{\n System.Console.WriteLine(\"任务1 被触发...\");\n}\n\n[Scheduler(\"任务2\", Interval = TaskInterval.SEC, Argument = \"10\")]\nstatic void Scheduler002(IServiceProvider service, TaskInfo task)\n{\n System.Console.WriteLine(\"任务2 被触发...\");\n}\n\n//运行时 scheduler.AddTask(\"任务3\"...)\n[Scheduler(\"任务3\")]\nstatic void Scheduler003()\n{\n System.Console.WriteLine(\"任务3 被触发...\");\n}以下几个是 AdminBlazor 封装的组件，更多丰富的 UI 组件可以看：BootstrapBlazor
\n| 名称 | 说明 |\n|
\n", "image": "https://freesql.net/adminblazor/0008.png", "date_published": "2024-01-31T07:25:26.000Z", "date_modified": "2025-10-24T10:02:25.000Z", "authors": [], "tags": [] }, { "title": "低代码", "url": "https://freesql.net/guide/lowcode.html", "id": "https://freesql.net/guide/lowcode.html", "summary": "低代码 本篇是继文档之后的大功能，专门为低代码设计。 FreeSql 默认依赖实体类型，虽然运行时可以动态创建 Type，但不断的动态编译导致会内存无法释放，对 Type 的版本也难以管理。 本功能是独立的，使用纯字典（无实体类型）进行 CRUD，支持导航属性，级联操作等功能。 注意：本功能是独立的，请勿与其他文档的级联机制搞混。 字典 CUD（单表）...", "content_html": "\n本篇是继《动态操作》文档之后的大功能，专门为低代码设计。
\nFreeSql 默认依赖实体类型，虽然运行时可以动态创建 Type，但不断的动态编译导致会内存无法释放，对 Type 的版本也难以管理。
\n本功能是独立的，使用纯字典（无实体类型）进行 CRUD，支持导航属性，级联操作等功能。
\n注意：本功能是独立的，请勿与其他文档的级联机制搞混。
\nvar dic = new Dictionary<string, object>();\ndic.Add(\"id\", 1);\ndic.Add(\"name\", \"xxxx\");\n\nfsql.InsertDict(dic).AsTable(\"table1\").ExecuteAffrows();\nfsql.UpdateDict(dic).AsTable(\"table1\").WherePrimary(\"id\").ExecuteAffrows();\nfsql.DeleteDict(dic).AsTable(\"table1\").ExecuteAffrows();\nfsql.InsertOrUpdateDict(dic).AsTable(\"table1\").WherePrimary(\"id\").ExecuteAffrows();InsertDict/UpdateDict/DeleteDict/InsertOrUpdateDict 都支持批量操作，对应类型 List<Dictionary<string, object>>
\n不依赖实体类型，不需要动态编译，纯字典操作，支持导航属性，级联保存，AOT 编译福音。
\nnuget 安装：
\n\n\ndotnet add package FreeSql.Extensions.ZeroEntity
\n
var ctx = new ZeroDbContext(fsql, JsonConvert.DeserializeObject<TableDescriptor[]>(json)); //在文档后面\n\nvar item = JsonConvert.DeserializeObject<Dictionary<string, object>>(@\"\n{\n \"\"Name\"\":\"\"user1\"\",\n \"\"Ext\"\":\n {\n \"\"Remarks\"\":[{\"\"Remark\"\":\"\"remark1\"\"},{\"\"Remark\"\":\"\"remark2\"\"}]\n },\n \"\"Claims\"\":[{\"\"ClaimName\"\":\"\"claim1\"\"},{\"\"ClaimName\"\":\"\"claim2\"\"},{\"\"ClaimName\"\":\"\"claim3\"\"}],\n \"\"Roles\"\":[{\"\"Name\"\":\"\"role1\"\"},{\"\"Name\"\":\"\"role2\"\"}]\n}\");\nctx.Insert(item);\n\nvar item2 = JsonConvert.DeserializeObject<Dictionary<string, object>>(@\"\n{\n \"\"Id\"\":1,\n \"\"Name\"\":\"\"user1111\"\",\n \"\"Ext\"\":{},\n \"\"Claims\"\":[{\"\"Id\"\":1,\"\"ClaimName\"\":\"\"claim1111\"\"},{\"\"Id\"\":\"\"3\"\",\"\"ClaimName\"\":\"\"claim3222222\"\"},{\"\"ClaimName\"\":\"\"claim0000\"\"}],\n \"\"Roles\"\":[{\"\"Name\"\":\"\"role111100001\"\"},{\"\"Id\"\":2,\"\"Name\"\":\"\"role2\"\"}]\n}\");\nctx.Update(item2);\nctx.Delete(item2);INSERT INTO [Role]([Name]) OUTPUT INSERTED.[Id] as [Id], INSERTED.[Name] as [Name] VALUES(N'role1'), (N'role2')\nINSERT INTO [User]([Name]) OUTPUT INSERTED.[Id] as [Id], INSERTED.[Name] as [Name] VALUES(N'user1')\nINSERT INTO [UserExt]([UserId]) VALUES(1)\nINSERT INTO [UserExtRemarks]([RemarkId], [UserId], [Remark]) VALUES('6570e3f8-a226-c3ac-00d1-a3dd18b30339', 1, N'remark1'), ('6570e3f8-a226-c3ac-00d1-a3de16d9aa68', 1, N'remark2')\nINSERT INTO [UserClaim]([UserId], [ClaimName]) OUTPUT INSERTED.[Id] as [Id], INSERTED.[UserId] as [UserId], INSERTED.[ClaimName] as [ClaimName] VALUES(1, N'claim1'), (1, N'claim2'), (1, N'claim3')\nINSERT INTO [UserRole]([UserId], [RoleId]) VALUES(1, 5), (1, 6)\n\nINSERT INTO [Role]([Name]) OUTPUT INSERTED.[Id] as [Id], INSERTED.[Name] as [Name] VALUES(N'role111100001'), (N'role2')\nINSERT INTO [UserClaim]([UserId], [ClaimName]) OUTPUT INSERTED.[Id] as [Id], INSERTED.[UserId] as [UserId], INSERTED.[ClaimName] as [ClaimName] VALUES(1, N'claim0000')\nINSERT INTO [UserRole]([UserId], [RoleId]) VALUES(1, 7), (1, 8)\nDELETE FROM [UserRole] WHERE ([UserId] = 1 AND [RoleId] = 6)\nDELETE FROM [UserRole] WHERE ([UserId] = 1 AND [RoleId] = 5)\nDELETE FROM [UserClaim] WHERE ([Id] = 2)\nUPDATE [User] SET [Name] = N'user1111'\nWHERE ([Id] = 1)\nUPDATE [UserClaim] SET [ClaimName] = CASE [Id]\nWHEN 1 THEN N'claim1111'\nWHEN 3 THEN N'claim3222222' END\nWHERE ([Id] IN (1,3))\n\nDELETE FROM [UserRole] WHERE (([UserId] = 1 AND [RoleId] = 7) OR ([UserId] = 1 AND [RoleId] = 8))\nDELETE FROM [UserClaim] WHERE ([Id] IN (1,3,4))\nDELETE FROM [UserExt] WHERE ([UserId] = 1)\nDELETE FROM [User] WHERE ([Id] = 1)查询，返回结果是字典 Dictionary<string, object>：
\n//自动级联\nctx.Select.Where(\"id\", 1).ToList();\n\n//单独查询\nctx.SelectNoTracking(\"User\")\n //.IncludeAll()\n .Include(\"Ext.Remarks\", then => then.Where(\"remark\", \"like\", \"error\"))\n .Include(\"Roles\", then => then.Include(\"Users\",\n then => then.Include(\"Ext.Remarks\")))\n .ToList();\n\n//普通多表查询\nctx.SelectNoTracking(\"User\")\n .LeftJoin(\"UserExt\", \"UserId\", \"User.Id\")\n .ToList();\n//[{id:1, UserExt:{} },..]上述 ctx 对象依赖 json 配置如下：
\n\n\n提示：ctx.LoadSchemaFromDatabase(\"User\") 从数据库动态加载描述（可能不完善）
\n
[\n {\n \"Name\": \"User\",\n \"Comment\": \"用户表\",\n \"Columns\": [\n {\n \"Name\": \"Id\",\n \"IsPrimary\": true,\n \"IsIdentity\": true,\n \"MapType\": \"System.Int32\"\n },\n { \"Name\": \"Name\", \"MapType\": \"System.String\" }\n ],\n \"Navigates\": [\n { \"Name\": \"Ext\", \"Type\": \"OneToOne\", \"RelTable\": \"UserExt\" },\n {\n \"Name\": \"Claims\",\n \"Type\": \"OneToMany\",\n \"RelTable\": \"UserClaim\",\n \"Bind\": \"UserId\"\n },\n {\n \"Name\": \"Roles\",\n \"Type\": \"ManyToMany\",\n \"RelTable\": \"Role\",\n \"ManyToMany\": \"UserRole\"\n }\n ],\n \"Indexes\": []\n },\n {\n \"Name\": \"UserExt\",\n \"Comment\": \"用户扩展信息表\",\n \"Columns\": [\n { \"Name\": \"UserId\", \"IsPrimary\": true, \"MapType\": \"System.Int32\" }\n ],\n \"Navigates\": [\n {\n \"Name\": \"Remarks\",\n \"Type\": \"OneToMany\",\n \"RelTable\": \"UserExtRemarks\",\n \"Bind\": \"UserId\"\n }\n ]\n },\n {\n \"Name\": \"UserExtRemarks\",\n \"Comment\": \"用户扩展信息表-子表\",\n \"Columns\": [\n { \"Name\": \"RemarkId\", \"IsPrimary\": true, \"MapType\": \"System.Guid\" },\n { \"Name\": \"UserId\", \"MapType\": \"System.Int32\" },\n { \"Name\": \"Remark\", \"MapType\": \"System.String\" }\n ]\n },\n {\n \"Name\": \"UserClaim\",\n \"Comment\": \"一对多测试表\",\n \"Columns\": [\n {\n \"Name\": \"Id\",\n \"IsPrimary\": true,\n \"IsIdentity\": true,\n \"MapType\": \"System.Int32\"\n },\n { \"Name\": \"UserId\", \"MapType\": \"System.Int32\" },\n { \"Name\": \"ClaimName\", \"MapType\": \"System.String\" }\n ]\n },\n {\n \"Name\": \"Role\",\n \"Comment\": \"权限表\",\n \"Columns\": [\n {\n \"Name\": \"Id\",\n \"IsPrimary\": true,\n \"IsIdentity\": true,\n \"MapType\": \"System.Int32\"\n },\n { \"Name\": \"Name\", \"MapType\": \"System.String\" }\n ],\n \"Navigates\": [\n {\n \"Name\": \"Users\",\n \"Type\": \"ManyToMany\",\n \"RelTable\": \"User\",\n \"ManyToMany\": \"UserRole\"\n }\n ],\n \"Indexes\": []\n },\n {\n \"Name\": \"UserRole\",\n \"Comment\": \"多对多中间表\",\n \"Columns\": [\n { \"Name\": \"UserId\", \"IsPrimary\": true, \"MapType\": \"System.Int32\" },\n { \"Name\": \"RoleId\", \"IsPrimary\": true, \"MapType\": \"System.Int32\" }\n ],\n \"Navigates\": [\n {\n \"Name\": \"User\",\n \"Type\": \"ManyToOne\",\n \"RelTable\": \"User\",\n \"Bind\": \"UserId\"\n },\n {\n \"Name\": \"Role\",\n \"Type\": \"ManyToOne\",\n \"RelTable\": \"Role\",\n \"Bind\": \"RoleId\"\n }\n ]\n }\n]理解本机制之前，请先忘记 Repository/DbContext 等之前的级联机制，他们没有关联。
\nschemas[] 是一组表映射信息定义，包含表名、列名、导航属性、索引等信息
\n举例：
\nCURD 都是基于 schemas[0] 聚合根进行操作
\n对比保存：
\n将当前操作的聚合根与状态管理的副本进行对比，计算出发生变化的列
\n| 导航属性 | 副本 | 最新 | 动作 |\n|
\n", "date_published": "2023-12-07T05:53:21.000Z", "date_modified": "2025-04-18T06:21:41.000Z", "authors": [], "tags": [] }, { "title": "QuestDB", "url": "https://freesql.net/guide/freesql-provider-questdb.html", "id": "https://freesql.net/guide/freesql-provider-questdb.html", "summary": "介绍 QuestDB 是一款针对时序数据实时处理优化的关系型列存数据库， 支持 Rest API 方式访问，同时兼容 PostgreSQL 访问协议，以及 InfluxDB 写入的访问协议。自带 Web Console，方便数据库的基本访问 QuestDB | 官网 安装包 FreeSql.Provider.QuestDb .NET CLI Packa...", "content_html": "QuestDB 是一款针对时序数据实时处理优化的关系型列存数据库， 支持 Rest API 方式访问，同时兼容 PostgreSQL 访问协议，以及 InfluxDB 写入的访问协议。自带 Web Console，方便数据库的基本访问
FreeSql.Provider.QuestDb
\n.NET CLI
\ndotnet add package FreeSql.Provider.QuestDbPackage Manager
\nInstall-Package FreeSql.Provider.QuestDbstatic IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.QuestDb,\n @\"host=localhost;port=8812;username=admin;password=quest;database=qdb;ServerCompatibilityMode=NoTypeLoading;\") //连接字符串\n .UseMonitorCommand(cmd => Console.WriteLine($\"Sql：{cmd.CommandText}\"))\n .UseQuestDbRestAPI(\"localhost:9000\", \"username\", \"password\") //RestAPI，建议开启\n .Build();fsql.SelectLongSequence(10, () => new\n {\n rndstr = QuestFunc.rnd_str(10, 5, 10, 0),\n rnddate = QuestFunc.rnd_date(QuestFunc.to_date(\"2020\", \"yyyy\"), QuestFunc.to_date(\"2023\", \"yyyy\"))\n })\n .From<User1>()\n .InnerJoin((a, b) => a.rndstr == b.Username)\n .ToList();\n//SELECT *\n//FROM (\n// SELECT rnd_str(10,5,10,0) \"rndstr\", rnd_date(to_date('2020','yyyy'),to_date('2023','yyyy'),0) \"rnddate\"\n// FROM long_sequence(10)\n//) a\n//INNER JOIN \"user1\" b ON a.\"rndstr\" = b.\"username\"\n\n\nSAMPLE BY用于时间序列数据，将大型数据集汇总为同质时间块的聚合，作为SELECT语句的一部分
\n
fsql.Select<Table>()\n .SampleBy(1, SampleUnit.day)\n .WithTempQuery(q => new { q.Id, q.Activos, count = SqlExt.Count(q.Id).ToValue() })\n .Where(q => q.Id != \"xxx\")\n .ToSql();\n\n生成SQL
\n
SELECT *\nFROM (\n SELECT a.\"Id\", a.\"Activos\", count(a.\"Id\") \"count\"\n FROM \"Table\" a SAMPLE BY 1d\n) a\nWHERE (a.\"Id\" <> '1')\n\n\n需要注意的是 QuestDB 的 GroupBy 与其他关系型 数据库不同
\n
//这里通过WithTempQuery实现\nfsql.Select<Table>()\n .WithTempQuery(q => new { q.Id, q.xxx, count = SqlExt.Count(q.Id).ToValue() })\n .Where(q => q.Id != \"1\" && q.count > 1)\n .ToSql();\n\n生成SQL
\n
SELECT *\nFROM (\n SELECT a.\"Id\", a.\"xxx\", count(a.\"Id\") \"count\"\n FROM \"Table\" a\n) a\nWHERE (a.\"Id\" <> '1' AND a.\"count\" > 1)\n\n\n对于多个时间序列存储在同一个表中的场景，根据时间戳检索给定键或键组合的最新项
\n
fsql.Select<Table>()\n .LatestOn(q => q.CreateTime, q => new { q.xxx, q.xxx })\n .ToSql();\n\n生成SQL
\n
SELECT a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\", a.\"xxx\"\nFROM \"Table\" a\nLATEST ON a.xxxx PARTITION BY a.xxxx\n\n实测七列10W数据预热后只需1.5秒，100W数据14秒左右
\n
//需要启用RestAPI\nfsql.Insert(list).ExecuteBulkCopyAsync();注意：RestAPI 不经过 ado.net，因为不触发 UseMonitorCommand/Aop.CommandBefore/After 等事件
\n\n\nQuestDB 支持自动分表
\n
[Index(\"Id_Index\", nameof(Id), false)]\nclass Table\n{\n //索引类型必须是symbol\n [Column(DbType = \"symbol\")]\n public string Id { get; set; }\n public string Name { get; set; }\n public double? Activos { get; set; }\n //按天分表\n [AutoSubtable(SubtableType.Day)]\n //特性标记类型必须是DateTime\n public DateTime? CreateTime { get; set; }\n public bool? IsCompra { get; set; }\n}多线程并发查询时会出现 table busy [reason=insert] 异常
\n\n\n\n解决方案，启用RestAPI后 Insert/Update就会默认使用HTTP方式
\n
//在FreeSqlBuilder增加UseQuestDbRestAPI()\nnew FreeSql.FreeSqlBuilder()\n .UseQuestDbRestAPI(\"localhost:9000\", \"username\", \"password\")注意：RestAPI 不经过 ado.net，因为不触发 UseMonitorCommand/Aop.CommandBefore/After 等事件
\nQuestDb WebConsole并不支持设置账号密码，但是官网给出解决方案 使用Nginx代理
\nSetting up Basic Authentication for QuestDB open source using Nginx | QuestDB
\nQuestDB | 在线测试 提供了最新的QuestDB发行版和示例数据集:
\n| Query | Execution time |\n|
\n", "date_published": "2023-02-22T05:25:18.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "聚合根（实验室）", "url": "https://freesql.net/guide/aggregateroot.html", "id": "https://freesql.net/guide/aggregateroot.html", "summary": "聚合根（实验室） FreeSql.DbContext 定义了 IBaseRepositoryFreeSql.DbContext 定义了 IBaseRepository<T> 仓储接口，（虽然）支持了级联保存、级联删除功能，（但是）使用时需要人工自己判断何时开启、何时使用。
\n本文看上去像 EF，实则有区别，主要区别在级联边界的规则设定，例如我们允许 OneToMany 从下层向上递归级联，但是仅限查询，不能增删改。研究目的希望从机制上杜绝痛点，让操作变得更可控。
\nAggregateRootRepository 是 IBaseRepository<T> 一种新的尝试实现，根据聚合根特点，实现可控的级联添加、级联更新、级联删除、级联查询（查询时自动 Include/IncludeMany）操作。
\nvar repository = fsql.GetAggregateRootRepository<Order>();\n\ndotnet add package FreeSql.Extensions.AggregateRoot
\n
意见征集、讨论区：https://github.com/dotnetcore/FreeSql/discussions/1235
\n接下来的内容，严重依赖【导航属性】的正确配置，请先学会再继续向下！
\n将一个主要的实体类认定为聚合根，设定好安全的管辖范围（边界），CRUD 时会把边界之内的所有内容看作一个整体。
\n边界之外的导航属性，增删改 递归时会忽略：
边界之内的导航属性，增删改 递归时会级联操作：
示例1：在聚合根内递归所有 OneToOne/OneToMany 导航属性
\nclass Order\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public string Field2 { get; set; }\n\n public OrderExt Extdata { get; set; }\n\n [Navigate(nameof(OrderDetail.OrderId))]\n public List<OrderDetail> Details { get; set; }\n}\nclass OrderExt\n{\n [Key]\n public int OrderId { get; set; }\n public string Field3 { get; set; }\n\n public Order Order { get; set; }\n}\nclass OrderDetail\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public int OrderId { get; set; }\n public string Field4 { get; set; }\n\n public OrderDetailExt Extdata { get; set; }\n}\nclass OrderDetailExt\n{\n [Key]\n public int OrderDetailId { get; set; }\n public string Field5 { get; set; }\n\n public OrderDetail OrderDetail { get; set; }\n}示例2：在聚合根内递归所有 ManyToMany 导航属性对应的中间表
\nclass Order\n{\n // ..\n [Navigate(ManyToMany = typeof(OrderTag))]\n public List<Tag> Tags { get; set; }\n}\nclass OrderTag\n{\n [Key]\n public int OrderId { get; set; }\n [Key]\n public int TagId { get; set; }\n\n [Navigate(nameof(OrderId))]\n public Order Order { get; set; }\n [Navigate(nameof(TagId))]\n public Tag Tag { get; set; }\n}\nclass Tag\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public string Name { get; set; }\n\n [Navigate(ManyToMany = typeof(OrderTag))]\n public List<Order> Orders { get; set; }\n}根据上面设定的边界，插入时会自动 级联插入 边界以内的内容。
var order = new Order\n{\n Field2 = \"field2\",\n Extdata = new OrderExt { Field3 = \"field3\" },\n Details = new List<OrderDetail>\n {\n new OrderDetail { Field4 = \"field4_01\", Extdata = new OrderDetailExt { Field5 = \"field5_01\" } },\n new OrderDetail { Field4 = \"field4_02\", Extdata = new OrderDetailExt { Field5 = \"field5_02\" } },\n new OrderDetail { Field4 = \"field4_03\", Extdata = new OrderDetailExt { Field5 = \"field5_03\" } },\n },\n Tags = fsql.Select<Tag>().Where(a => new [] { 1,2,3 }.Contains(a.Id)).ToList()\n};\nrepository.Insert(order); //级联插入\n\n注意：即使 order.Tags 在数据库不存在，也不会插入 Tag 表记录
\n
根据上面设定的边界，查询时会自动 Include/IncludeMany 边界以内的内容。
var list = repository.Select\n .Where(a => a.Id < 10)\n .ToList();效果等同于：
\nvar list = fsql.Select<Order>()\n .Include(a => a.Extdata)\n .IncludeMany(a => a.Details,\n then => then.Include(b => b.Extdata))\n .IncludeMany(a => a.Tags)\n .Where(a => a.Id < 10)\n .ToList();扩展查询边界：
\n\n\n提示：[AggregateRootBoundary(\"name\", Break = true)] 设置边界范围，请往后面看。。
\n
class OrderRepository : AggregateRootRepository<Order>\n{\n public OrderRepository(IFreeSql fsql, UnitOfWorkManager uowManager) : base(uowManager?.Orm ?? fsql)\n {\n Console.WriteLine(AggregateRootUtils.GetAutoIncludeQueryStaicCode(null, fsql, typeof(Order)));\n //控制台输出一块 Include/IncludeMany 字符串，内容与下方 SelectDiy 代码块相同\n }\n\n public override ISelect<IFreeSql> Select => this.SelectDiy\n //.TrackToList(this.SelectAggregateRootTracking) 状态跟踪\n .Include(a => a.Extdata)\n .IncludeMany(a => a.Details,\n then => then.Include(b => b.Extdata))\n .IncludeMany(a => a.Tags);\n}重写 Select 可以把边界以外的数据一起查询出来（例如 ManyToOne 导航属性），但是 添加/修改/删除 仍然采用默认边界规则
手工使用 SelectDiy Include/IncludeMany 包含内容，如果小于默认边界规则，则建议不要开启 状态跟踪 （保存数据可能造成不一致），反之则应该开启。（详细请往后看 更新数据）
根据上面设定的边界，删除时会自动 级联删除 边界以内的内容。
repository.Delete(order);删除数据是在内存递归 order 实例进行的，因此需要使用 repository 提前查询，内容庞大时有性能缺陷。
\n如果设置了数据库表外键的级联删除功能，则只需删除 Order 表对应的记录，并且不需要提前查询。
\n根据上面设定的边界，更新时会自动 级联保存 边界以内的内容。
repository.Attach 存储更新前的数据快照（查询会自动快照），称为副本，repository.Update 的时候和副本进行级联对比保存。
\nvar order = repository.Select.Where(a => a.Id == 1).First(); //此时已自动 Attach\norder.Tags.Add(new Tag { Id = 4 });\norder.Details.RemoveAt(1);\norder.Details[0].Extdata.Field5 = \"field5_01_01\";\norder.Field2 = \"field2_02\";\nrepository.Update(order);完整保存 先查询再更新，机制容易理解，数据一致性也更有保障。但是如果聚合根下内容较庞大，将会造成性能问题。
例如 Order 下面的评论数据大约有 1000 条，每天还不断有新的记录，每次 Load 内存再保存代价就太大了。
\n利用对比保存的特点，可以变向实现 追加记录：
class Order\n{\n // ..\n [Navigate(nameof(OrderComment.OrderId))]\n public List<OrderComment> Comments { get; set; }\n}\nclass OrderComment\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public int OrderId { get; set; }\n public string Field6 { get; set; }\n}\n\nvar order = fsql.Select<Order>()\n .Where(a => a.Id == 1)\n .First(); //单表数据\nrepository.Attach(order); //快照时 Comments 是 NULL/EMPTY\norder.Comments = new List<OrderComment>();\norder.Comments.Add(new OrderComment { Field6 = \"field6_01\" });\norder.Comments.Add(new OrderComment { Field6 = \"field6_02\" });\nrepository.Update(order);\n\n我为什么不直接对 OrderComment 进行单表操作啊？？？
\n
\n\n答案你们回答！！！
\n
对比保存 规则说明：
| 导航属性 | 副本 | 最新 | 结果 |\n|
\n", "date_published": "2022-09-04T08:40:48.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "FreeSql+CAP事务", "url": "https://freesql.net/extra/freesql-cap.html", "id": "https://freesql.net/extra/freesql-cap.html", "summary": "FreeSql+CAP事务 背景描述 在CAP中，事务对象需要交给CAP进行提交从而在事务实现提交后对缓存消息到 Broker 的 Flush 动作，而目前的Orm大部分都有自己的事务管理对象进行事务的提交。CAP官方直接原生支持使用 ADO.NET 和 EntityFrameworkCore 进行事务集成，而对于第三方ORM本文提供了一种扩展用以集成...", "content_html": "\n在CAP中，事务对象需要交给CAP进行提交从而在事务实现提交后对缓存消息到 Broker 的 Flush 动作，而目前的Orm大部分都有自己的事务管理对象进行事务的提交。CAP官方直接原生支持使用 ADO.NET 和 EntityFrameworkCore 进行事务集成，而对于第三方ORM本文提供了一种扩展用以集成的示例。
\n接入有二种方式
\nFreeSql包dotnet add package FreeSql\ndotnet add package FreeSql.DbContext\ndotnet add package FreeSql.Provider.MySqlConnectorCAP相关包dotnet add package Savorboard.CAP.InMemoryMessageQueue\ndotnet add package DotNetCore.CAP.MySql\ndotnet add package DotNetCore.CAP.Dashboard{\n \"ConnectionStrings\": {\n \"MySql\": \"Data Source=localhost;Port=3306;User ID=root;Password=root;Initial Catalog=lincms;Charset=utf8mb4;SslMode=none;Max pool size=1;Connection LifeTime=20\"\n }\n} IConfigurationSection mysqlSelection = configuration.GetSection($\"ConnectionStrings:MySql\");\n IFreeSql fsql = new FreeSqlBuilder()\n .UseConnectionString(DataType.MySql,mysqlSelection.Value)\n .UseNameConvert(NameConvertType.PascalCaseToUnderscoreWithLower)\n .UseAutoSyncStructure(true)\n .UseMonitorCommand(cmd => { Trace.WriteLine(cmd.CommandText + \";\"); })\n .Build()\n services.AddSingleton(fsql);\n services.AddFreeRepository();\n services.AddScoped<UnitOfWorkManager>();至少你要配置一个消息队列和一个事件存储（UseMySql）
\n services.AddCap(x =>\n {\n x.UseInMemoryMessageQueue();\n x.UseMySql(opt=>{\n //MySqlOptions\n opt.ConnectionString = mysqlSelection.Value\n });\n // x.UseXXX ...\n x.UseDashboard();\n });默认情况下，你可以访问 http://localhost:xxx/cap 这个地址打开Dashboard。
\n public static class CapUnitOfWorkExtensions\n {\n public static void Flush(this ICapTransaction capTransaction)\n {\n capTransaction?.GetType().GetMethod(\"Flush\", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(capTransaction, null);\n }\n public static ICapTransaction BeginTransaction(this IUnitOfWork unitOfWork, ICapPublisher publisher, bool autoCommit = false)\n {\n var dbTransaction = unitOfWork.GetOrBeginTransaction();\n publisher.Transaction = ActivatorUtilities.CreateInstance<MySqlCapTransaction>(publisher.ServiceProvider);\n publisher.Transaction.DbTransaction = dbTransaction;\n publisher.Transaction.AutoCommit = autoCommit;\n return publisher.Transaction;\n }\n\n public static void Commit(this ICapTransaction capTransaction, IUnitOfWork unitOfWork)\n {\n unitOfWork.Commit();\n capTransaction.Flush();\n }\n }public class BookController : Controller\n{\n [HttpGet(\"~/freesql/unitofwork\")]\n public DateTime FreeSqlUnitOfWorkManagerTransaction([FromServices] IBaseRepository<Book> repo,\n [FromServices] UnitOfWorkManager unitOfWorkManager,\n [FromServices] ICapPublisher capBus\n )\n {\n DateTime now = DateTime.Now;\n using (IUnitOfWork uow = unitOfWorkManager.Begin())\n {\n ICapTransaction trans = uow.BeginTransaction(capBus, false);\n\n repo.Insert(new Book()\n {\n Author = \"叶老板\",\n Title = \"FreeSql源码解析与实战\",\n Summary = \"带你了解FreeSql源码细节，掌握FreeSql的实战操作，扩展FreeSql的功能，提升你的开发效率。\"\n });\n\n capBus.Publish(\"freesql.time\", now);\n trans.Commit(uow);\n }\n return now;\n }\n [NonAction]\n [CapSubscribe(\"freesql.time\")]\n public void GetTime(DateTime time)\n {\n Console.WriteLine($\"time:{time}\");\n }\n}\n\n[Table(Name = \"book\")]\npublic class Book\n{\n [Column(IsIdentity = true, IsPrimary = true)]\n public long Id { get; set; }\n\n [Column(StringLength = 30)]\n public string Author { get; set; }\n\n [Column(StringLength = 1000)]\n public string Summary { get; set; }\n\n [Column(StringLength = 50)]\n public string Title { get; set; }\n\n}public class FreeSqlRepositoryPatternTransaction : CapTransactionBase\n{\n public FreeSqlRepositoryPatternTransaction(IDispatcher dispatcher, IUnitOfWork uow) : base(dispatcher)\n {\n Uow = uow;\n }\n\n public IUnitOfWork Uow { get; }\n\n public override object? DbTransaction => Uow.GetOrBeginTransaction();\n\n public override void Commit()\n {\n Uow.Commit();\n Flush();\n }\n\n public override Task CommitAsync(CancellationToken cancellationToken = default)\n {\n throw new NotImplementedException();\n }\n\n public override void Rollback()\n {\n Uow.Rollback();\n }\n\n public override Task RollbackAsync(CancellationToken cancellationToken = default)\n {\n throw new NotImplementedException();\n }\n\n public override void Dispose()\n {\n Uow.Dispose();\n }\n}\n\npublic static class Extensions\n{\n // 注意：你可以酌情修改此扩展以支持你的使用习惯，参考下方讨论内容\n public static ICapTransaction BeginTransaction(this IUnitOfWork unitOfWork, ICapPublisher publisher, bool autoCommit = false)\n {\n var dispatcher = publisher.ServiceProvider.GetRequiredService<IDispatcher>();\n var transaction = new FreeSqlRepositoryPatternTransaction(dispatcher, unitOfWork)\n {\n AutoCommit = autoCommit\n };\n return publisher.Transaction.Value = transaction;\n }使用方式：
\n[HttpGet(\"~/freesql/Withtransaction\")]\npublic DateTime WithTransaction([FromServices] IBaseRepository<Book> repo,\n[FromServices] UnitOfWorkManager unitOfWorkManager,\n[FromServices] ICapPublisher capBus\n)\n{\n DateTime now = DateTime.Now;\n using (IUnitOfWork uow = unitOfWorkManager.Begin())\n {\n ICapTransaction trans = uow.BeginTransaction(capBus, false);\n\n repo.Insert(new Book()\n {\n Author = \"叶老板\",\n Title = \"FreeSql源码解析与实战\",\n Summary = \"带你了解FreeSql源码细节，掌握FreeSql的实战操作，扩展FreeSql的功能，提升你的开发效率。\"\n });\n\n capBus.Publish(\"freesql.time\", now);\n trans.Commit();\n }\n return now;\n}二者区别在于后者，trans.Commit()不需要传递``IUnitOfWork`参数
它是 FreeSql 衍生出来的 .NETCore MVC 中间件扩展包 FreeSql.AdminLTE.Preview.dll，基于 AdminLTE 前端框架动态产生实体的增删查改界面。
\n\n\n推荐使用：AdminBlazor 集成了菜单、角色、用户、公司组织、定时任务、数据字典、参数配置、租户、审批、审计等功能。
\n
\n\ndotnet add packages FreeSql.AdminLTE.Preview
\n
输入：实体1、实体2、实体3
\n输出：后台管理的功能
\napp.UseFreeAdminLtePreview(\"/\",\n typeof(Config),\n typeof(Role),\n typeof(Menu),\n typeof(User),\n\n typeof(Department),\n typeof(Employee),\n typeof(Position),\n\n typeof(AppLog),\n typeof(LoginLog),\n typeof(OprationLog),\n\n typeof(FreeScheduler.TaskInfo),\n typeof(FreeScheduler.TaskLog)\n);只需要传入实体，就可以生产 curd 的管理功能，是不是有些骚啊~~~
\n![\"image\"](\"https://user-images.githubusercontent.com/16286519/187557633-351e3fbe-ae87-461f-9e45-f1c31c6a2b92.png\")
![\"image\"](\"https://user-images.githubusercontent.com/16286519/187557677-5333484e-92d3-42a4-8543-6baf89814540.png\")
对于通用后台管理系统的生成，除了单纯的对单表 crud 操作外，我还喜欢利用导航属性的操作，比如：
\n1、Song、Tag 多对多场景，添加/更新 Song 时可以把 Tag 一起保存；
\n2、列表页，希望外键、多对多出现在过滤筛选条件；
\n3、列表页，希望枚举出现在过滤筛选条件；
\n4、删除时，级联删除所有相关数据；
\n等等诸如此类的繁琐操作，之所以说繁琐，是因为这些工作技术不难，属于严重的重复劳动。
\n1、添加、修改数据
\n中件间产生的界面包括添加、修改数据的功能，普通实体的根据属性的类型与 Html5 UI 一一映射；
\n比较特殊的映射规则：
\n| c# 类型 | Html5 |\n|
\n", "image": "https://user-images.githubusercontent.com/16286519/187557633-351e3fbe-ae87-461f-9e45-f1c31c6a2b92.png", "date_published": "2022-08-30T23:01:53.000Z", "date_modified": "2025-03-15T16:02:54.000Z", "authors": [], "tags": [] }, { "title": "FreeIM", "url": "https://freesql.net/guide/freeim.html", "id": "https://freesql.net/guide/freeim.html", "summary": "FreeIM FreeIM v2.0.0 调整：已将 ClientId Guid 改为 long； 修复：JoinChan/LeaveChan 数量统计问题； 增加：SendBroadcastMessage 广播消息； 优化：SendChanMessage 性能； FreeIM 使用 websocket 协议实现简易、高性能（单机支持5万+连接）、集群...", "content_html": "\nFreeIM 使用 websocket 协议实现简易、高性能（单机支持5万+连接）、集群即时通讯组件，支持点对点通讯、群聊通讯、上线下线事件消息等众多实用性功能。
\n使用场景：好友聊天、群聊天、直播间、实时评论区、游戏。
\n接受定制项目开发，详细请联系作者
\n开源地址：https://github.com/2881099/FreeIM
\n扩展资料：《C#.NET im 聊天通讯架构设计 -- FreeIM 支持集群、职责分明、高性能》
\n\n\ndotnet add package FreeIM
\n
![\"image\"](\"/freeim/001.png\") | \n![\"image\"](\"/freeim/002.png\") | \n
|---|---|
![\"image\"](\"/freeim/003.png\") | \n![\"image\"](\"/freeim/004.png\") | \n
![\"image\"](\"/freeim/005.png\") | \n![\"image\"](\"/freeim/006.png\") | \n
![\"image\"](\"/freeim/007.png\")
public void Configure(IApplicationBuilder app)\n{\n app.UseFreeImServer(new ImServerOptions\n {\n Redis = new FreeRedis.RedisClient(\"127.0.0.1:6379,poolsize=5\"),\n Servers = new[] { \"127.0.0.1:6001\" }, //集群配置\n Server = \"127.0.0.1:6001\"\n });\n}\n//dotnet run --urls=http://127.0.0.1:6001\n\n一套永远不需要迭代更新的
\nImServer服务端，支持 .NET6.0、.NETCore2.1+、NETStandard2.0
public void Configure(IApplicationBuilder app)\n{\n //...\n\n ImHelper.Initialization(new ImClientOptions\n {\n Redis = new FreeRedis.RedisClient(\"127.0.0.1:6379,poolsize=5\"),\n Servers = new[] { \"127.0.0.1:6001\" }\n });\n\n ImHelper.EventBus(\n t => Console.WriteLine(t.clientId + \"上线了\"),\n t => Console.WriteLine(t.clientId + \"下线了\"));\n}| ImHelper方法 | 参数 | 描述 |\n|
\n", "image": "https://freesql.net/freeim/001.png", "date_published": "2022-08-30T05:43:50.000Z", "date_modified": "2025-12-18T10:33:38.000Z", "authors": [], "tags": [] }, { "title": "FreeScheduler", "url": "https://freesql.net/guide/freescheduler.html", "id": "https://freesql.net/guide/freescheduler.html", "summary": "FreeScheduler FreeScheduler 是利用 IdleBus 实现的轻量化定时任务调度，支持集群、临时的延时任务和重复循环任务(可持久化)，可按秒，每天/每周/每月固定时间，自定义间隔执行，支持 .NET Core 2.1+、.NET Framework 4.0+ 运行环境。 开源地址：https://github.com/28810...", "content_html": "\nFreeScheduler 是利用 IdleBus 实现的轻量化定时任务调度，支持集群、临时的延时任务和重复循环任务(可持久化)，可按秒，每天/每周/每月固定时间，自定义间隔执行，支持 .NET Core 2.1+、.NET Framework 4.0+ 运行环境。
\n开源地址：https://github.com/2881099/FreeScheduler
\n扩展资料：《.NET 定时任务 -- FreeScheduler 支持 cron、持久化、可变定时设置》
\n\n\ndotnet add package FreeScheduler
\n
\n\nInstall-Package FreeScheduler
\n
static Scheduler scheduler = new FreeSchedulerBuilder()\n .UseTimeZone(TimeSpan.FromHours(8)) //默认为UTC时间，国内可指定时区+8，任务将按本地时间执行\n .OnExecuting(task =>\n {\n Console.WriteLine($\"[{DateTime.Now.ToString(\"HH:mm:ss.fff\")}] {task.Topic} 被执行\");\n switch (task.Topic)\n {\n case \"武林大会\": Wulin(task.Body); break;\n case \"攻城活动\": AttackCity(task.Body); break;\n }\n })\n .Build();| Method | 说明 |\n|
\n", "image": "https://freesql.net/281375469-a5d5f4bb-6af9-4695-9570-8777c39d7329.png", "date_published": "2022-08-30T05:41:38.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "FreeRedis", "url": "https://freesql.net/guide/freeredis.html", "id": "https://freesql.net/guide/freeredis.html", "summary": "FreeRedis CSRedisCore 是 .NETFramework 4.0 及以上 访问 redis-server 的客户端组件，也是 FreeSql 作者早年发布的 nuget 版本。 后来重构了更简易的 FreeRedis，目前推荐大家使用 FreeRedis，支持几乎所有 .NET 平台和 AOT。 开源地址：https://github...", "content_html": "\nCSRedisCore 是 .NETFramework 4.0 及以上 访问 redis-server 的客户端组件，也是 FreeSql 作者早年发布的 nuget 版本。
后来重构了更简易的 FreeRedis，目前推荐大家使用 FreeRedis，支持几乎所有 .NET 平台和 AOT。
开源地址：https://github.com/2881099/FreeRedis
\npublic static RedisClient cli = new RedisClient(\"127.0.0.1:6379,password=123,defaultDatabase=13\");\n//cli.Serialize = obj => JsonConvert.SerializeObject(obj);\n//cli.Deserialize = (json, type) => JsonConvert.DeserializeObject(json, type);\ncli.Notice += (s, e) => Console.WriteLine(e.Log); //打印命令日志\n\ncli.Set(\"key1\", \"value1\");\ncli.MSet(\"key1\", \"value1\", \"key2\", \"value2\");\n\nstring value1 = cli.Get(\"key1\");\nstring[] vals = cli.MGet(\"key1\", \"key2\");\n\n支持 STRING、HASH、LIST、SET、ZSET、BITMAP、HyperLogLog、GEO、Stream 以及布隆过滤器等。
\n
| 参数 | 默认值 | 说明 |\n| :
\n", "date_published": "2022-08-30T05:39:40.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "其他作品", "url": "https://freesql.net/guide/otherworks.html", "id": "https://freesql.net/guide/otherworks.html", "summary": "其他作品 FreeSql 作者是一个入行 18 年的老批，他目前写的开源项目还有： 更早的作品可以直接访问 https://github.com/2881099 查看。 AdminBlazor AdminBlazor 是一款 Blazor Server SaaS 中台项目，支持 RABC 权限菜单/按钮，支持快速代码生成一对一、一对多、多对多导航属性的...", "content_html": "\nFreeSql 作者是一个入行 18 年的老批，他目前写的开源项目还有：
\n| 开源项目 | 描述 | 开源地址 | 开源协议 |\n|
\n", "date_published": "2022-08-30T05:35:49.000Z", "date_modified": "2025-03-20T05:57:57.000Z", "authors": [], "tags": [] }, { "title": "联合查询", "url": "https://freesql.net/guide/unionall.html", "id": "https://freesql.net/guide/unionall.html", "summary": "联合查询 在之前都是推荐使用 ToSql + WithSql 完成联合查询操作，v3.2.666 新增功能直接使用 UnionAll 方法。 GroupBy + WithTempQuery(嵌套查询) + FromQuery + UnionAll 组合使用，会让查询功能更加强大、灵活。 单表 UNION ALL 多表 UNION ALL 注意：如上 S...", "content_html": "\n在之前都是推荐使用 ToSql + WithSql 完成联合查询操作，v3.2.666 新增功能直接使用 UnionAll 方法。
\nGroupBy + WithTempQuery(嵌套查询) + FromQuery + UnionAll 组合使用，会让查询功能更加强大、灵活。
\nvar sql = fsql.Select<User>().Where(a => a.Id == 1)\n .UnionAll(\n fsql.Select<User>().Where(a => a.Id == 2),\n fsql.Select<User>().Where(a => a.Id == 3)\n )\n .Where(a => a.Id == 1 || a.Id == 2)\n .ToSql();SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\nFROM ( SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User\" a\n WHERE (a.\"Id\" = 1)\n UNION ALL\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User\" a\n WHERE (a.\"Id\" = 2)\n UNION ALL\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User\" a\n WHERE (a.\"Id\" = 3) ) a\nWHERE ((a.\"Id\" = 1 OR a.\"Id\" = 2))var sql = fsql.Select<User, Group>()\n .InnerJoin((a, b) => a.GroupId == b.Id)\n .Where((a, b) => a.Id == 1)\n .WithTempQuery((a, b) => new { user = a, group = b }) //匿名类型\n\n .UnionAll(\n fsql.Select<User, Group>()\n .InnerJoin((a, b) => a.GroupId == b.Id)\n .Where((a, b) => a.Id == 2)\n .WithTempQuery((a, b) => new { user = a, group = b }) //匿名类型\n )\n .Where(a => a.user.Id == 1 || a.user.Id == 2)\n .ToSql();SELECT *\nFROM ( SELECT *\n FROM (\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\", b.\"Id\", b.\"GroupName\"\n FROM \"User\" a\n INNER JOIN \"UserGroup\" b ON a.\"GroupId\" = b.\"Id\"\n WHERE (a.\"Id\" = 1) ) a\n UNION ALL\n SELECT *\n FROM (\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\", b.\"Id\", b.\"GroupName\"\n FROM \"User\" a\n INNER JOIN \"UserGroup\" b ON a.\"GroupId\" = b.\"Id\"\n WHERE (a.\"Id\" = 2) ) a ) a\nWHERE ((a.\"Id\" = 1 OR a.\"Id\" = 2))注意：如上 SQL 会执行报错，因为 User、UserGroup 都存在相同的 Id 字段名称，暂时的解决办法需要指定字段
\n .WithTempQuery((a, b) => new\n {\n user = a,\n group = new\n {\n GroupId = b.Id,\n GroupName = b.GroupName\n }\n })开启参数化查询功能后，使用 WithParameters 共享参数化，可避免产生相同的参数名称：
\nvar dbpars = new List<DbParameter>();\n\nvar id1 = 1;\nvar id2 = 2;\nvar sql = fsql.Select<User>()\n .WithParameters(dbpars)\n .Where(a => a.Id == id1)\n\n .UnionAll(\n fsql.Select<User>()\n .WithParameters(dbpars)\n .Where(a => a.Id == id2)\n )\n .Where(a => a.Id == 1 || a.Id == 2)\n .ToSql();SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\nFROM ( SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User1\" a\n WHERE (a.\"Id\" = @exp_0)\n UNION ALL\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User1\" a\n WHERE (a.\"Id\" = @exp_1) ) a\nWHERE ((a.\"Id\" = 1 OR a.\"Id\" = 2))fsql.Insert<object>().AsType(实体类型)\n .AppendData(data).ExecuteAffrows();\n\nfsql.Update<object>().AsType(实体类型)\n .SetSource(data).ExecuteAffrows();\n\nfsql.Delete<object>().AsType(实体类型)\n .Where(a => (a as BaseEntity).Id == 1).ExecuteAffrows();\n\n//fsql.Select<object>()...\n\n//或者仓储\nvar repo = fsql.GetRepository<object>();\nrepo.AsType(实体类型);\n\nrepo.Insert(..);\nrepo.Update(..);\nrepo.Delete(..);\nrepo.InsertOrUpdate(..);v3.2.695 emit 动态创建实体类型
\nvar table = fsql.CodeFirst.DynamicEntity(\"user\", new TableAttribute { Name = \"t_user\" })\n .Property(\"id\", typeof(int), new ColumnAttribute { IsIdentity = true, IsPrimary = rue })\n .Property(\"username\", typeof(string), new ColumnAttribute { StringLength = 32 })\n .Build();\n\n//如果有必要，请将 table 缓存起来\nif (fsql.DbFirst.ExistsTable(table.DbName) == false)\n fsql.CodeFirst.SyncStructure(table.Type); //创建表\n\nvar dict = new Dictionary<string, object>();\ndict[\"id\"] = 1;\ndict[\"username\"] = \"xxx\";\n\n//将字典转化成 type 对应的 object\n//也可以直接使用 InsertDict/UpdateDict/DeleteDict 等字典 CUD 功能\nobject obj = table.CreateInstance(dict);\n\nfsql.Insert<object>().AsType(table.Type).AppendData(obj).ExecuteAffrows();\nfsql.Update<object>().AsType(table.Type).SetSource(obj).ExecuteAffrows();\nfsql.InsertOrUpdate<object>().AsType(table.Type).SetSource(obj).ExecuteAffrows();\nfsql.Delete<object>().AsType(table.Type).WhereDynamic(obj).ExecuteAffrows();\nList<object> objs = fsql.Select<object>().AsType(table.Type).ToList();var dic = new Dictionary<string, object>();\ndic.Add(\"id\", 1);\ndic.Add(\"name\", \"xxxx\");\n\nfsql.InsertDict(dic).AsTable(\"table1\").ExecuteAffrows();\nfsql.UpdateDict(dic).AsTable(\"table1\").WherePrimary(\"id\").ExecuteAffrows();\nfsql.DeleteDict(dic).AsTable(\"table1\").ExecuteAffrows();\nfsql.InsertOrUpdateDict(dic).AsTable(\"table1\").WherePrimary(\"id\").ExecuteAffrows();InsertDict/UpdateDict/DeleteDict/InsertOrUpdateDict 都支持批量操作，对应类型 List<Dictionary<string, object>>
\n不依赖实体类型，不需要动态编译，纯字典操作，支持导航属性，级联保存，AOT 编译福音。
\n内容较长，请移步《低代码》
\n1、仓储 Repository
\nvar repo = fsql.GetRepository<Log>();\nrepo.AsTable(old => $\"{old}_201903\"); //对 Log_201903 表 CRUD\n//repo.AsTable((t, old) => $\"{old}_201903\"); //对 Log_201903 表 CRUD（级联有关表也增加该后辍）\nrepo.Insert(new Log { ... });2、原生 IFreeSql
\nfsql.Select<Log>().AsTable((t, old) => $\"{old}_201903\").ToList(); //对 Log_201903 表查询\nfsql.Insert(new Log { ... }).AsTable(\"Log_201903\").ExecuteAffrows(); //对 Log_201903 表插入\nfsql.Update<Log>().AsTable(\"Log_201903\").SetSource(item).ExecuteAffrows(); //对 Log_201903 表更新\nfsql.Delete<Log>().AsTable(\"Log_201903\").Where(a => a.Id == 1).ExecuteAffrows(); //对 Log_201903 表删除\nfsql.InsertOrUpdate<Log>().AsTable(\"Log_201903\").SetSource(item).ExecuteAffrows(); //对 Log_201903 表插入或更新1、ISelect.Where(string sql) 使用原生条件：
\nfsql.Select<Region>().Where(\"a.id > 0\") //提示：存在SQL注入安全问题2、动态 Lambda 表达式
\nAnd、Or扩展方法 LambadaExpressionExtensions.csExpression<Func<Region, bool>> where = null;\nwhere = where.And(b => b.Id > 10);\nwhere = where.Or(b => b.Id == 1);\nfsql.Select<Region>().Where(where).ToList();\n//WHERE id > 10 OR id = 13、ISelect.WhereDynamicFilter 方法实现动态过滤条件（与前端交互），支持的操作符：
\nDynamicFilterInfo dyfilter = JsonConvert.DeserializeObject<DynamicFilterInfo>(@\"\n{\n \"\"Logic\"\": \"\"And\"\",\n \"\"Filters\"\":\n [\n { \"\"Field\"\": \"\"id\"\", \"\"Operator\"\": \"\"Equals\"\", \"\"Value\"\": 1 },\n {\n \"\"Logic\"\": \"\"Or\"\",\n \"\"Filters\"\":\n [\n { \"\"Field\"\": \"\"id\"\", \"\"Operator\"\": \"\"Equals\"\", \"\"Value\"\": 2 },\n { \"\"Field\"\": \"\"id\"\", \"\"Operator\"\": \"\"Equals\"\", \"\"Value\"\": 3 }\n ]\n }\n ]\n}\");\nfsql.Select<Region>().WhereDynamicFilter(dyfilter).ToList();\n//WHERE id = 1 AND (id = 2 OR id = 3)《高效理解 FreeSql WhereDynamicFilter，深入了解设计初衷》
\n实现 Custom 的例子：
\n{\n \"Logic\": \"And\",\n \"Filters\": [\n { \"Field\": \"id\", \"Operator\": \"Equals\", \"Value\": 1 },\n {\n \"Logic\": \"Or\",\n \"Filters\": [\n { \"Field\": \"id\", \"Operator\": \"Equals\", \"Value\": 2 },\n {\n \"Field\": \"{{ DynamicFilterCustomImpl.CustomLinq }}\",\n \"Operator\": \"Custom\",\n \"Value\": \"Title.StartsWith('new topic 1')\"\n }\n ]\n }\n ]\n}var dyfilter = JsonConvert.DeserializeObject<DynamicFilterInfo>(json);\nfsql.Select<Topic>().WhereDynamicFilter(dyfilter).ToList();\n// WHERE id = 1 AND (id = 2 OR title like 'new topic 1%')\n\n//nuget 安装 System.Linq.Dynamic.Core\npublic class DynamicFilterCustomImpl\n{\n //JSON Field 对应这个值\n public static string CustomLinq = $\"{nameof(DynamicFilterCustomImpl.DynamicLinq)} {typeof(DynamicFilterCustomImpl).FullName},{typeof(DynamicFilterCustomImpl).Assembly.FullName}\";\n\n [DynamicFilterCustom]\n public static LambdaExpression DynamicLinq(object sender, string value)\n {\n if (string.IsNullOrWhiteSpace(value)) value = \"1==2\";\n ParameterExpression t = Expression.Parameter(sender.GetType().GetGenericArguments()[0], \"t\");\n var exp = DynamicExpressionParser.ParseLambda(new ParameterExpression[] { t }, typeof(bool), value);\n return exp;\n }\n}1、ISelect.OrderBy(string sql) 使用原生排序：
\nfsql.Select<Region>().OrderBy(\"a.id desc\") //提示：存在SQL注入安全问题2、ISelect.OrderByPropertyName 使用属性名排序：
\n1、ISelect.IncludeByPropertyName 方法实现动态贪婪加载，对应 Include/IncludeMany：
\nfsql.Select<Region>()\n .IncludeByPropertyName(\"Parent.Parent.Parent\")\n .IncludeByPropertyName(\"Childs\")\n\n .IncludeByPropertyName(\"Childs\", then => then\n .IncludeByPropertyName(\"Parent.Parent\")\n .IncludeByPropertyName(\"Parent.Childs\"))\n .ToList();2、List<TDto>.IncludeByPropertyName 扩展方法也实现了 OneToMany 动态贪婪加载：
\n\n\n非实体类型，也可以级联加载，他们不需要配置导航属性关系。
\n
var dtos = fsql.Select<Region>().ToList<Dto>();\n\ndtos.IncludeByPropertyName(\n orm: fsql,\n property: \"Childs\",\n where: \"ParentId=Id\", //临时关系\n take: 5,\n select: \"id,name\",\n then => then.IncludeByPropertyName(\"Parent\")\n);1、ISelect.ToList 使用原生SQL返回数据：
\nList<(int, string)> list = fsql.Select<Region>()\n .ToList<(int, string)>(\"a.id,a.name\") //提示：存在SQL注入安全问题2、ISelect.ToDataTableByPropertyName 使用属性名返回数据：
\nDataTable dt = fsql.Select<Region>()\n .ToDataTableByPropertyName(new [] {\n \"Parent.Code\",\n \"b.Id\"\n });FreeSql 提供 Where(sql)、GroupBy(sql)、OrderBy(sql)、ToList(sql) 等直接使用 SQL 片段的 API。
\n使用这些 API 时请务必注意SQL注入安全问题。
\n不建议前端直接 POST SQL 到后端使用它们，而应该在后端做一层映射，例如：
\nvar whereMapping = new Dictionary<string, string>\n{\n [\"where1\"] = \"a.id > {0}\",\n [\"where2\"] = \"len(a.name) > {0}\"\n};\nvar orderByMapping = new Dictionary<string, string>\n{\n [\"order1\"] = \"a.id asc, a.name desc\",\n [\"order2\"] = \"len(a.name) desc\"\n};\n\n//假设前端 POST 内容是 postWhere=where1&postWhereValue=100&postOrder=order1\nfsql.Select<Region>()\n .WhereIf(\n whereMapping.TryGetValue(postWhere, out var whereSql),\n string.Format(whereSql, postWhereValue)\n )\n .OrderBy(\n orderByMapping.TryGetValue(postOrder, out var orderSql),\n orderSql\n )尝试过 ado.net、dapper、ef，以及Repository仓储，甚至自己还写过生成器工具，以便做常规CRUD操作。
\n它们日常操作不方便之处：
\n每次使用前需要声明，再操作；
\n很多人一个实体类，对应一个操作类（或DAL、DbContext、Repository）；
\nBaseEntity 是一种极简单的 CodeFirst 开发方式，特别对单表或多表CRUD，利用继承节省了每个实体类的重复属性（创建时间、ID等字段），软删除等功能，进行 crud 操作时不必时常考虑仓储的使用；
\n本文介绍 BaseEntity 一种极简约的 CRUD 操作方法。
\n自动迁移实体结构（CodeFirst），到数据库；
\n直接操作实体的方法，进行 CRUD 操作；
\n简化用户定义实体类型，省去主键、常用字段的配置（如CreateTime、UpdateTime）；
\n实现单表、多表查询的软删除逻辑；
\ndotnet add package FreeSql.Extensions.BaseEntity\ndotnet add package FreeSql.Provider.SqliteBaseEntity.Initialization(fsql, null);1、定义一个主键 int 并且自增的实体类型，BaseEntity TKey 指定为 int/long 时，会认为主键是自增；
\npublic class UserGroup : BaseEntity<UserGroup, int>\n{\n public string GroupName { get; set; }\n}如果不想主键是自增键，可以重写属性：
\npublic class UserGroup : BaseEntity<UserGroup, int>\n{\n [Column(IsIdentity = false)]\n public override int Id { get; set; }\n public string GroupName { get; set; }\n}\n\n有关更多实体的特性配置，请参考资料：实体特性
\n
2、定义一个主键 Guid 的实体类型，保存数据时会自动产生有序不重复的 Guid 值（不用自己指定 Guid.NewGuid()）；
\npublic class User : BaseEntity<UserGroup, Guid>\n{\n public string UserName { get; set; }\n}//添加\nvar item = new UserGroup { GroupName = \"组一\" };\nitem.Insert();\n\n//更新\nitem.GroupName = \"组二\";\nitem.Update();\n\n//添加或更新\nitem.Save();\n\n//软删除\nitem.Delete();\n\n//恢复软删除\nitem.Restore();\n\n//根据主键获取对象\nvar item = UserGroup.Find(1);\n\n//查询数据\nvar items = UserGroup.Where(a => a.Id > 10).ToList();实体类型.Select 是一个查询对象，使用方法和 FreeSql.ISelect 一样；
\n支持多表查询时，软删除条件会附加在每个表中；
\n\n\n有关更多查询方法，请参考资料：查询
\n
1、同线程事务，不支持异步：
\nfsql.Transaction(() =>\n{\n //todo ...\n})2、如果你是异步控
\n由于 AsyncLocal 平台兼容不好，所以交给外部管理事务。
\nstatic AsyncLocal<IUnitOfWork> _asyncUow = new AsyncLocal<IUnitOfWork>();\n\nBaseEntity.Initialization(fsql, () => _asyncUow.Value);在 Scoped 开始时：_asyncUow.Value = fsql.CreateUnitOfWork(); (也可以使用 UnitOfWorkManager 对象获取 uow)
\n在 Scoped 结束时：_asyncUow.Value = null;
\n如下：
\nusing (var uow = fsql.CreateUnitOfWork())\n{\n _asyncUow.Value = uow;\n\n try\n {\n //todo ... BaseEntity 内部 curd 方法保持使用 uow 事务\n }\n finally\n {\n _asyncUow.Value = null;\n }\n\n uow.Commit();\n}接下来的内容，严重依赖【导航属性】的正确配置，请先学会再继续向下！
\n级联只针对 OneToOne/OneToMany/ManyToMany 三种导航属性，级联保存文档已经解释过。
\n\n\n比如 Include/IncludeMany 查询的对象，可以使用此方法级联删除它们。
\n
var repo = fsql.GetRepository<UserGroup>();\nrepo.DbContextOptions.EnableCascadeSave = true; //关键设置\nrepo.Insert(new UserGroup\n{\n GroupName = \"group01\",\n Users = new List<User>\n {\n new User { Username = \"admin01\", Password = \"pwd01\", UserExt = new UserExt { Remark = \"用户备注01\" } },\n new User { Username = \"admin02\", Password = \"pwd02\", UserExt = new UserExt { Remark = \"用户备注02\" } },\n new User { Username = \"admin03\", Password = \"pwd03\", UserExt = new UserExt { Remark = \"用户备注03\" } },\n }\n}); //级联添加测试数据\n//INSERT INTO \"usergroup\"(\"groupname\") VALUES('group01') RETURNING \"id\"\n//INSERT INTO \"user\"(\"username\", \"password\", \"groupid\") VALUES('admin01', 'pwd01', 1), ('admin02', 'pwd02', 1), ('admin03', 'pwd03', 1) RETURNING \"id\" as \"Id\", \"username\" as \"Username\", \"password\" as \"Password\", \"groupid\" as \"GroupId\"\n//INSERT INTO \"userext\"(\"userid\", \"remark\") VALUES(3, '用户备注01'), (4, '用户备注02'), (5, '用户备注03')\n\nvar groups = repo.Select\n .IncludeMany(a => a.Users,\n then => then.Include(b => b.UserExt))\n .ToList();\nrepo.Delete(groups); //级联删除，递归向下遍历 group OneToOne/OneToMany/ManyToMany 导航属性\n//DELETE FROM \"userext\" WHERE (\"userid\" IN (3,4,5))\n//DELETE FROM \"user\" WHERE (\"id\" IN (3,4,5))\n//DELETE FROM \"usergroup\" WHERE (\"id\" = 1)\n\n根据设置的导航属性，递归删除 OneToOne/OneToMany/ManyToMany 对应数据，并返回已删除的数据。此功能不依赖数据库外键
\n
var repo = fsql.GetRepository<UserGroup>();\nvar ret = repo.DeleteCascadeByDatabase(a => a.Id == 1);\n//SELECT a.\"id\", a.\"username\", a.\"password\", a.\"groupid\" FROM \"user\" a WHERE (a.\"groupid\" = 1)\n//SELECT a.\"userid\", a.\"remark\" FROM \"userext\" a WHERE (a.\"userid\" IN (3,4,5))\n//DELETE FROM \"userext\" WHERE (\"userid\" IN (3,4,5))\n//DELETE FROM \"user\" WHERE (\"id\" IN (3,4,5))\n//DELETE FROM \"usergroup\" WHERE (\"id\" = 1)\n\n//ret Count = 7 System.Collections.Generic.List<object>\n// [0] {UserExt} object {UserExt}\n// [1] {UserExt} object {UserExt}\n// [2] {UserExt} object {UserExt}\n// [3] {User} object {User}\n// [4] {User} object {User}\n// [5] {User} object {User}\n// [6] {UserGroup} object {UserGroup}\n\npublic class UserGroup\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public string GroupName { get; set; }\n\n [Navigate(nameof(User.GroupId))]\n public List<User> Users { get; set; }\n}\npublic class User\n{\n [Column(IsIdentity = true)]\n public int Id { get; set; }\n public string Username { get; set; }\n public string Password { get; set; }\n public int GroupId { get; set; }\n\n [Navigate(nameof(Id))]\n public UserExt UserExt { get; set; }\n}\npublic class UserExt\n{\n [Column(IsPrimary = true)]\n public int UserId { get; set; }\n public string Remark { get; set; }\n\n [Navigate(nameof(UserId))]\n public User User { get; set; }\n}需求版本：v3.2.666+
\nGroupBy + WithTempQuery(嵌套查询) + FromQuery + UnionAll 组合使用，会让查询功能更加强大、灵活。
\n注意：FromQuery 多个 WithTempQuery 匿名类型时，确保不是同一个类型（可使用任意属性区分） #1620
\nfsql.Select<User1>()\n .Where(a => a.Id < 1000)\n .WithTempQuery(a => new\n {\n item = a,\n rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()\n })\n .Where(a => a.rownum == 1)\n .ToList();\n\n提示：支持多表嵌套查询，fsql.Select<User1, UserGroup1>()
\n
SELECT *\nFROM (\n SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum]\n FROM [User1] a\n WHERE a.[Id] < 1000\n) a\nWHERE (a.[rownum] = 1)如果数据库不支持开窗函数，可以使用分组嵌套查询解决：
\nfsql.Select<User1>()\n .Where(a => a.Id < 1000)\n .GroupBy(a => a.Nickname)\n .WithTempQuery(g => new { min = g.Min(g.Value.Id) })\n .From<User1>()\n .InnerJoin((a, b) => a.min == b.Id)\n .ToList((a, b) => b);SELECT b.[Id], b.[Nickname]\nFROM (\n SELECT min(a.[Id]) [min]\n FROM [User1] a\n WHERE a.[Id] < 1000\n GROUP BY a.[Nickname] ) a\nINNER JOIN [User1] b ON a.[min] = b.[Id]WithTempQuery + From<T2> 或 FromQuery(ISelect<T2>) 可实现无限联表
\nfsql.Select<User1>()\n .Where(a => a.Id < 1000)\n .WithTempQuery(a => new\n {\n item = a,\n rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()\n })\n //.From<UserExt>() //普通联表\n .FromQuery(fsql.Select<UserExt>().Where(b => b.Id > 0)) //子查询联表\n //.FromQuery(fsql.Select<UserExt, UserGroup, xxx>() //子多表查询联表\n // .WithTempQuery((a,b,c) => new { ... }))\n .InnerJoin((a, b) => a.item.Id == b.UserId)\n .Where((a, b) => a.rownum == 1)\n .ToList((a, b) => new\n {\n user = a.item,\n rownum = a.rownum,\n userext = b\n });SELECT ...\nFROM (\n SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum]\n FROM [User1] a\n WHERE a.[Id] < 1000 ) a\nINNER JOIN (\n SELECT a.[UserId], a.[Remark]\n FROM [UserExt] a\n WHERE (a.[Id] > 0) ) b ON a.[Id] = b.[UserId]\nWHERE (a.[rownum] = 1)fsql.Select<User1>()\n .WithTempQuery(a => new\n {\n user = a,\n rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()\n })\n .Where(a => a.rownum == 1)\n .FromQuery(fsql.Select<UserExt>().Where(b => b.UserId > 0)\n .GroupBy(b => new { b.UserId, b.Remark })\n .WithTempQuery(b => new { b.Key, sum1 = b.Sum(b.Value.UserId) }))\n .InnerJoin((a, b) => a.user.Id == b.Key.UserId)\n .Where((a, b) => a.user.Nickname == \"name03\" || a.user.Nickname == \"name02\")\n .ToList((a, b) => new\n {\n user = a.user,\n rownum = a.rownum,\n groupby = b\n });SELECT ...\nFROM (\n SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum]\n FROM [User1] a ) a\nINNER JOIN (\n SELECT a.[UserId], a.[Remark], sum(a.[UserId]) [sum1]\n FROM [UserExt] a\n WHERE (a.[UserId] > 0)\n GROUP BY a.[UserId], a.[Remark] ) b ON a.[Id] = b.[UserId]\nWHERE (a.[rownum] = 1) AND ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))假设跨数据库服务器，或者数据表被缓存过，WithMemory 便可以实现数据表与内存关联查询。
\nvar list = new List<User1>();\nlist.Add(new User1 { Id = Guid.NewGuid() });\nlist.Add(new User1 { Id = Guid.NewGuid() });\nlist.Add(new User1 { Id = Guid.NewGuid() });\n\nvar listSql2 = fsql.Select<UserGroup>()\n .FromQuery(fsql.Select<User1>().WithMemory(list))\n .InnerJoin((a, b) => a.Id == b.GroupId)\n .ToSql();SELECT ...\nFROM [UserGroup] a\nINNER JOIN (\n SELECT ...\n UNION ALL\n SELECT ...\n UNION ALL\n SELECT ...\n) b ON a.[Id] = b.[GroupId]自动分表后，如果有分页的需求 或者分组聚合的需求可以参考以下代码
\nvar result = fsql.Select<Statistics>()\n .Where(a => a.createtime.BetweenEnd(startTime, endTime)) //时间字段定位表\n .WithTempQuery(a => new { item = a })\n .GroupBy(a => a.item.shareId)\n .Count(out var total)\n .Page(dto.page, dto.limit)\n .ToSql(g => new {\n Sid = a.Key,\n Sum1 = g.Sum(g.Value.item.field1),\n Sum2 = g.Sum(g.Value.item.field2),\n });SELECT a.`shareId` as1, sum( a.`field1` ) as3, sum( a.`field2` ) as5\nFROM (\n SELECT ...\n FROM (\n SELECT ...\n FROM `Statistics_2023` a\n WHERE (a.`createtime` >= '2022-01-01 00:00:00' AND a.`createtime` < '2023-01-14 00:00:00')\n ) ftb\n UNION ALL\n SELECT ...\n FROM (\n SELECT ...\n FROM `Statistics_2022` a\n WHERE (a.`createtime` >= '2022-01-01 00:00:00' AND a.`createtime` < '2023-01-14 00:00:00')\n ) ftb\n) a\nGROUP BY a.`shareId`\nLIMIT 0,30var query2 = fsql.Select<UnitLog, LoadPlan, Instruction>()\n .InnerJoin((a, b, c) => a.LoadNo == b.LoadNo && a.UnitTransactionType == \"TO\")\n .InnerJoin((a, b, c) => b.InstructionNo == c.InstructionNo)\n .WithTempQuery((a, b, c) => new\n {\n a.LoadNo,\n a.SeqNoLog,\n c.DeliveryInstractionStatus,\n c.UpTime,\n RN = SqlExt.RowNumber().Over().PartitionBy(a.UnitId).OrderByDescending(a.SeqNoLog).ToValue()\n });\nvar query3 = fsql.Select<Unit>();\n\nfsql.Select<UnitLog>()\n .FromQuery(query2, query3)\n .InnerJoin((a,b,c) => a.SeqNoLog == b.SeqNoLog)\n .InnerJoin((a,b,c) => a.UnitId == c.UnitId)\n .Where((a,b,c) => b.RN < 2)\n .ToSql((a,b,c) => new MB51_View\n {\n //CkassIfCation = a.CkassIfCation,\n PGI = b.DeliveryInstractionStatus,\n PGITime = b.UpTime,\n IsDelayPGI = true,\n RunNo = c.RunNo\n });SELECT a.[CkassIfCation] as1, b.[DeliveryInstractionStatus] as2, b.[UpTime] as3, 1 as4, c.[RunNo] as5\nFROM [UnitLog] a\nINNER JOIN (SELECT a.[LoadNo], a.[SeqNoLog], c.[DeliveryInstractionStatus], c.[UpTime], row_number() over( partition by a.[UnitId] order by a.[SeqNoLog] desc) [RN]\n FROM [UnitLog] a\n INNER JOIN [LoadPlan] b ON a.[LoadNo] = b.[LoadNo] AND a.[UnitTransactionType] = N'TO'\n INNER JOIN [Instruction] c ON b.[InstructionNo] = c.[InstructionNo] ) b ON a.[SeqNoLog] = b.[SeqNoLog]\nINNER JOIN [Unit] c ON a.[UnitId] = c.[UnitId]\nWHERE (b.[RN] < 2)var startDate = DateTime.Parse(\"2024-11-1\");\nvar endDate = DateTime.Parse(\"2024-12-1\");\nfsql.Select<object>()\n .WithMemory(\n Enumerable.Range(0, (int)endDate.Subtract(startDate).TotalDays)\n .Select(a => new { Date = startDate.AddDays(a).ToString(\"yyyy-MM-dd\") })\n .ToList()\n )\n .FromQuery(\n fsql.Select<T1, T2>().InnerJoin((a,b) => ...)\n .Where((a,b) => a.CreateDate.BetweenEnd(startDate, endDate)\n .GroupBy((a,b) => a.CreateDate.Date.ToString(\"yyyy-MM-dd\"))\n .WithTempQuery(g => new { Date = g.Key, Type1Total = g.Sum(g.Value.Item2.Qty1) }),\n fsql.Select<T3>()\n .Where(a => a.CreateDate.BetweenEnd(startDate, endDate)\n .GroupBy(a => a.CreateDate.Date.ToString(\"yyyy-MM-dd\"))\n .WithTempQuery(g => new { Date = g.Key, Type2Total = g.Sum(g.Value.Qty2) }),\n //... 最多支持 16 个 ISelect 合并\n )\n .LeftJoin(t => t.t2.Date = t.t1.Date)\n .LeftJoin(t => t.t3.Date = t.t1.Date)\n .OrderByDescending(t => t.t1.Date)\n .ToList(t => new\n {\n t.t1.Date,\n Sum1 = t.t2.Type1Total,\n Sum2 t.t3.Type2Total\n });开启参数化查询功能后，使用 WithParameters 共享参数化，可避免产生相同的参数名称：
\nvar dbpars = new List<DbParameter>();\n\nvar id1 = 1;\nvar id2 = 2;\nvar sql = fsql.Select<User1>()\n .WithParameters(dbpars)\n .Where(a => a.Id == id1)\n\n .FromQuery(\n fsql.Select<User1>()\n .WithParameters(dbpars)\n .Where(a => a.Id == id2)\n )\n .InnerJoin((a,b) => a.Id == b.Id)\n .ToSql();SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\nFROM (\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User1\" a\n WHERE (a.\"Id\" = @exp_0)\n) a\nINNER JOIN (\n SELECT a.\"Id\", a.\"GroupId\", a.\"Username\"\n FROM \"User1\" a\n WHERE (a.\"Id\" = @exp_1) ) b ON b.\"Id\" = a.\"Id\"使用Autofac基于特性标签，实现跨方法的异步事务处理
\ndotnet add package FreeSql\ndotnet add package FreeSql.DbContext\ndotnet add package FreeSql.Provider.MySqlConnector手动创建一个MySql/MariaDB数据库,名为ovov_freesql_repository
{\n \"Default\": \"Data Source=127.0.0.1;Port=3306;User ID=root;Password=root;Initial Catalog=ovov_freesql_repository;Charset=utf8;SslMode=none;Max pool size=10\"\n}public void ConfigureServices(IServiceCollection services)\n{\n IConfigurationSection Default = Configuration.GetSection(\"Default\");\n var fsql = new FreeSqlBuilder()\n .UseConnectionString(DataType.MySql, Default.Value)\n .UseAutoSyncStructure(true)\n .UseNameConvert(NameConvertType.PascalCaseToUnderscoreWithLower)\n .UseMonitorCommand(cmd => Trace.WriteLine(cmd.CommandText))\n .Build();\n services.AddSingleton<IFreeSql>(fsql);\n services.AddScoped<UnitOfWorkManager>();\n services.AddFreeRepository(null, typeof(Startup).Assembly);\n}csproj
\n<PackageReference Include=\"Autofac.Extensions.DependencyInjection\" Version=\"6.0.0\" />\n<PackageReference Include=\"Autofac.Extras.DynamicProxy\" Version=\"5.0.0\" />\n<PackageReference Include=\"Castle.Core.AsyncInterceptor\" Version=\"1.7.0\" />或
\ndotnet add package Autofac.Extensions.DependencyInjection\ndotnet add package Autofac.Extras.DynamicProxy\ndotnet add package Castle.Core.AsyncInterceptor创建一个标识事务的特性标签
\n[AttributeUsage(AttributeTargets.Method, Inherited = true)]\npublic class TransactionalAttribute : Attribute\n{\n /// <summary>\n /// 事务传播方式\n /// </summary>\n public Propagation Propagation { get; set; } = Propagation.Required;\n\n /// <summary>\n /// 事务隔离级别\n /// </summary>\n public IsolationLevel? IsolationLevel { get; set; }\n\n public TransactionalAttribute(){}\n\n public TransactionalAttribute(Propagation propagation, IsolationLevel isolationLevel)\n {\n Propagation = propagation;\n IsolationLevel = isolationLevel;\n }\n}Program.CS 替换默认的DI CreateHostBuilder方法
\n Host.CreateDefaultBuilder(args).UseServiceProviderFactory(new AutofacServiceProviderFactory())Startup.cs配置服务
\npublic void ConfigureContainer(ContainerBuilder builder)\n{\n builder.RegisterModule(new AutofacModule());\n}\n\n.NET6 这样注册
\n
builder.Host\n .UseServiceProviderFactory(new AutofacServiceProviderFactory())\n .ConfigureContainer<ContainerBuilder>((webBuilder, containerBuilder) =>\n {\n containerBuilder.RegisterModule(new AutofacModule());\n });这里给BlogService方法注入UnitOfWorkInterceptor拦截处理。直接注入类。
\npublic class AutofacModule : Autofac.Module\n{\n protected override void Load(ContainerBuilder builder)\n {\n builder.RegisterType<UnitOfWorkInterceptor>();\n builder.RegisterType<UnitOfWorkAsyncInterceptor>();\n\n builder.RegisterType<BlogService>()\n .InterceptedBy(typeof(UnitOfWorkInterceptor))\n .EnableClassInterceptors();\n\n} public class UnitOfWorkInterceptor : IInterceptor\n {\n private readonly UnitOfWorkAsyncInterceptor asyncInterceptor;\n\n public UnitOfWorkInterceptor(UnitOfWorkAsyncInterceptor interceptor)\n {\n asyncInterceptor = interceptor;\n }\n\n public void Intercept(IInvocation invocation)\n {\n asyncInterceptor.ToInterceptor().Intercept(invocation);\n }\n }\n\n public class UnitOfWorkAsyncInterceptor : IAsyncInterceptor\n {\n private readonly UnitOfWorkManager _unitOfWorkManager;\n private readonly ILogger<UnitOfWorkAsyncInterceptor> _logger;\n IUnitOfWork _unitOfWork;\n\n public UnitOfWorkAsyncInterceptor(UnitOfWorkManager unitOfWorkManager, ILogger<UnitOfWorkAsyncInterceptor> logger)\n {\n _unitOfWorkManager = unitOfWorkManager;\n _logger = logger;\n }\n\n private bool TryBegin(IInvocation invocation)\n {\n var method = invocation.MethodInvocationTarget ?? invocation.Method;\n var attribute = method.GetCustomAttributes(typeof(TransactionalAttribute), false).FirstOrDefault();\n if (attribute is TransactionalAttribute transaction)\n {\n _unitOfWork = _unitOfWorkManager.Begin(transaction.Propagation, transaction.IsolationLevel);\n return true;\n }\n\n return false;\n }\n\n /// <summary>\n /// 拦截同步执行的方法\n /// </summary>\n /// <param name=\"invocation\"></param>\n public void InterceptSynchronous(IInvocation invocation)\n {\n if (TryBegin(invocation))\n {\n try\n {\n invocation.Proceed();\n _unitOfWork.Commit();\n }\n catch\n {\n _unitOfWork.Rollback();\n throw;\n }\n finally\n {\n _unitOfWork.Dispose();\n }\n }\n else\n {\n invocation.Proceed();\n }\n }\n\n /// <summary>\n /// 拦截返回结果为Task的方法\n /// </summary>\n /// <param name=\"invocation\"></param>\n public void InterceptAsynchronous(IInvocation invocation)\n {\n invocation.ReturnValue = InternalInterceptAsynchronous(invocation);\n }\n\n private async Task InternalInterceptAsynchronous(IInvocation invocation)\n {\n if (TryBegin(invocation))\n {\n try\n {\n invocation.Proceed();\n if (invocation.ReturnValue != null)\n {\n await (Task)invocation.ReturnValue;\n }\n _unitOfWork.Commit();\n }\n catch (Exception)\n {\n _unitOfWork.Rollback();\n throw;\n }\n finally\n {\n _unitOfWork.Dispose();\n }\n }\n else\n {\n invocation.Proceed();\n if (invocation.ReturnValue != null)\n {\n await (Task)invocation.ReturnValue;\n }\n }\n }\n\n\n /// <summary>\n /// 拦截返回结果为Task<TResult>的方法\n /// </summary>\n /// <param name=\"invocation\"></param>\n /// <typeparam name=\"TResult\"></typeparam>\n public void InterceptAsynchronous<TResult>(IInvocation invocation)\n {\n invocation.ReturnValue = InternalInterceptAsynchronous<TResult>(invocation);\n }\n\n private async Task<TResult> InternalInterceptAsynchronous<TResult>(IInvocation invocation)\n {\n TResult result;\n if (TryBegin(invocation))\n {\n try\n {\n invocation.Proceed();\n result = await (Task<TResult>)invocation.ReturnValue;\n _unitOfWork.Commit();\n }\n catch (System.Exception)\n {\n _unitOfWork.Rollback();\n throw;\n }\n finally\n {\n _unitOfWork.Dispose();\n }\n }\n else\n {\n invocation.Proceed();\n result = await (Task<TResult>)invocation.ReturnValue;\n }\n return result;\n }\n }当Service层没有接口，则必须使用virtual虚方法。
\n public class BlogService\n {\n /// <summary>\n /// 当出现异常时，不会插入数据\n /// </summary>\n /// <param name=\"createBlogDto\"></param>\n [Transactional]\n public virtual void CreateBlogTransactional(CreateBlogDto createBlogDto)\n {\n Blog blog = _mapper.Map<Blog>(createBlogDto);\n blog.CreateTime = DateTime.Now;\n _blogRepository.Insert(blog);\n\n List<Tag> tags = new List<Tag>();\n createBlogDto.Tags.ForEach(r =>\n {\n tags.Add(new Tag { TagName = r });\n });\n if (createBlogDto.Title == \"abc\")\n {\n throw new Exception(\"test exception\");\n }\n _tagRepository.Insert(tags);\n }\n }当传入的参数，title为abc时，会出现异常，throw new Exception(\"test exception\");,前面插入的数据并没有成功，会自动回滚。
public class ServiceModule : Autofac.Module\n{\n protected override void Load(ContainerBuilder builder)\n {\n builder.RegisterType<UnitOfWorkInterceptor>();\n builder.RegisterType<UnitOfWorkAsyncInterceptor>();\n\n List<Type> interceptorServiceTypes = new List<Type>()\n {\n typeof(UnitOfWorkInterceptor)\n };\n //service所在dll，LinCms.Application为程序集名称，也可以通过typeof(程序集中的某个类即可).Assembly获取\n Assembly servicesDllFile = Assembly.Load(\"LinCms.Application\");\n\n builder.RegisterAssemblyTypes(servicesDllFile)\n .Where(a => a.Name.EndsWith(\"Service\") && !a.IsAbstract && !a.IsInterface && a.IsPublic)\n .AsImplementedInterfaces()\n .InstancePerLifetimeScope()\n .PropertiesAutowired()// 属性注入\n .InterceptedBy(interceptorServiceTypes.ToArray())\n .EnableInterfaceInterceptors();\n }\n}当我们使用Autofac批量注册服务后，可以直接使用Service层的接口，不需要再使用注入。
\npublic interface IBlogService\n{\n Task CreateBlogTransactionalAsync(CreateBlogDto createBlogDto);\n}\n\npublic class BlogService:IBlogService\n{\n private readonly IBlogRepository _blogRepository;\n private readonly ITagRepository _tagRepository;\n private readonly IMapper _mapper;\n\n public BlogService(IBlogRepository blogRepository, ITagRepository tagRepository, IMapper mapper)\n {\n _blogRepository = blogRepository ?? throw new ArgumentNullException(nameof(blogRepository));\n _tagRepository = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));\n _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));\n }\n [Transactional]\n public virtual async Task CreateBlogTransactionalAsync(CreateBlogDto createBlogDto)\n {\n Blog blog = _mapper.Map<Blog>(createBlogDto);\n blog.CreateTime = DateTime.Now;\n await _blogRepository.InsertAsync(blog);\n\n List<Tag> tags = new List<Tag>();\n createBlogDto.Tags.ForEach(r =>\n {\n tags.Add(new Tag { TagName = r });\n });\n if (createBlogDto.Title == \"abc\")\n {\n throw new Exception(\"test exception CreateBlogTransactionalAsync\");\n }\n await _tagRepository.InsertAsync(tags);\n }\n}[Route(\"api/[controller]\")]\n[ApiController]\npublic class BlogController : ControllerBase\n{\n private readonly IBlogService _blogService;\n public BlogController(IBlogService blogService)\n {\n _blogService=blogService;\n }\n\n [HttpPost(\"CreateBlogTransactionalAsync\")]\n public async Task CreateBlogTransactionalAsync([FromBody] CreateBlogDto createBlogDto)\n {\n await _blogService.CreateBlogTransactionalAsync(createBlogDto);\n }\n}| 数据库名称 | 提供者 | 系列风格 |\n|
\n", "date_published": "2022-07-09T09:12:12.000Z", "date_modified": "2025-03-19T14:57:42.000Z", "authors": [], "tags": [] }, { "title": "ODBC", "url": "https://freesql.net/guide/freesql-provider-odbc.html", "id": "https://freesql.net/guide/freesql-provider-odbc.html", "summary": "FreeSql.Provider.Odbc 实现 ODBC 访问数据库，ODBC 属于比较原始的技术，更新慢，各大数据库厂支持得标准不一，不到万不得已最好别用 odbc，坑比较多。 FreeSql.Provider.Odbc 做了多种数据库的专用实现：SqlServer、PostgreSQL、Oracle、MySql、达梦、人大金仓，和一种通用实现。 ...", "content_html": "FreeSql.Provider.Odbc 实现 ODBC 访问数据库，ODBC 属于比较原始的技术，更新慢，各大数据库厂支持得标准不一，不到万不得已最好别用 odbc，坑比较多。
\nFreeSql.Provider.Odbc 做了多种数据库的专用实现：SqlServer、PostgreSQL、Oracle、MySql、达梦、人大金仓，和一种通用实现。
\n和原来的 FreeSql.Provider.SqlServer 等 ado.net 相比，只支持较少的基础类型，其他功能几乎都有，包括 CodeFirst 自动迁移。
\n国产数据库大多数都兼容 SqlServer、PostgreSQL、Oracle、MySql 这四种数据库，所以它们也可以用来访问国产数据库。
\n通用实现为了让用户自己适配更多的数据库，比如连接 mssql 2000、db2 等数据库，牺牲了一些功能：
\n使用者只需求重写类 FreeSql.Odbc.Default.OdbcAdapter 就可以自定义访问不同的数据库。
\n我们默认做了一套 sqlserver 的语法和映射适配，代码在 Default/OdbcAdapter.cs，请查看代码了解。
\nclass Mssql2000Adapter : FreeSql.Odbc.Default.OdbcAdapter\n{\n public override string InsertAfterGetIdentitySql => \"SELECT SCOPE_IDENTITY()\";\n //可以重写更多的设置\n}\n\nfsql.SetOdbcAdapter(new Mssql2000Adapter());适配好新的 OdbcAdapter 后，请在 FreeSqlBuilder.Build 之后调用 IFreeSql.SetOdbcAdapter 方法生效。
\n", "date_published": "2022-07-09T09:12:12.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "FreeSql 实现审计日志", "url": "https://freesql.net/extra/freesql-auditlog.html", "id": "https://freesql.net/extra/freesql-auditlog.html", "summary": "FreeSql 实现审计日志 有两种情况，如果都是针对实体操作，确实很好做这个功能。 IFreeSql 更新/删除，都可以不传实体进行操作，所以这个 old_values, new_values 实现起来比较麻烦（可能需要查询一次？性能？）。另外还有批量操作。 1、fsql.Aop.CurdAfter 事件是 CRUD 之后触发，提供以下参数 2、Fr...", "content_html": "\n有两种情况，如果都是针对实体操作，确实很好做这个功能。
\nIFreeSql 更新/删除，都可以不传实体进行操作，所以这个 old_values, new_values 实现起来比较麻烦（可能需要查询一次？性能？）。另外还有批量操作。
\n/// <summary>\n/// 标识符，可将 CurdBefore 与 CurdAfter 进行匹配\n/// </summary>\npublic Guid Identifier { get; protected set; }\nprotected Stopwatch Stopwatch { get; }\n/// <summary>\n/// 操作类型\n/// </summary>\npublic CurdType CurdType { get; } //Select, Delete, Update, Insert, InsertOrUpdate\n/// <summary>\n/// 实体类型\n/// </summary>\npublic Type EntityType { get; }\n/// <summary>\n/// 实体类型的元数据\n/// </summary>\npublic TableInfo Table { get; }\n/// <summary>\n/// 执行的 SQL\n/// </summary>\npublic string Sql { get; }\n/// <summary>\n/// 参数化命令\n/// </summary>\npublic DbParameter[] DbParms { get; }\n\n/// <summary>\n/// 发生的错误\n/// </summary>\npublic Exception Exception { get; }\n/// <summary>\n/// 执行SQL命令，返回的结果\n/// </summary>\npublic object ExecuteResult { get; }\n/// <summary>\n/// 耗时（单位：Ticks）\n/// </summary>\npublic long ElapsedTicks => this.Stopwatch.ElapsedTicks;\n/// <summary>\n/// 耗时（单位：毫秒）\n/// </summary>\npublic long ElapsedMilliseconds => this.Stopwatch.ElapsedMilliseconds;全局设置：
\nfsql.SetDbContextOptions(opt => {\n opt.OnEntityChange = report => {\n Console.WriteLine(report);\n };\n});单独设置 DbContext 或者 UnitOfWork：
\nvar ctx = fsql.CreateDbContext();\nctx.Options.OnEntityChange = report => {\n Console.WriteLine(report);\n};\n\nvar uow = fsql.CreateUnitOfWork();\nuow.OnEntityChange = report => {\n Console.WriteLine(report);\n};参数 report 是一个 List 集合，集合元素的类型定义如下：
\npublic class ChangeInfo\n{\n public object Object { get; set; }\n public EntityChangeType Type { get; set; }\n /// <summary>\n /// Type = Update 的时候，获取更新之前的对象\n /// </summary>\n public object BeforeObject { get; set; }\n /// <summary>\n /// 实体类型\n /// </summary>\n public Type EntityType { get; set; }\n}\npublic enum EntityChangeType { Insert, Update, Delete, SqlRaw }| 变化类型 | 说明 |\n|
\n", "date_published": "2022-06-24T16:45:08.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "Docker+ FreeSql", "url": "https://freesql.net/extra/freesql-docker.html", "id": "https://freesql.net/extra/freesql-docker.html", "summary": "Docker+ FreeSql .net5+Docker+ Encryption(ssl/tls) handshake failed .net5 网站使用Sqlserver数据库部署在docker容器内运行报主库链接失败 环境 数据库：Sqlserver2014 网站程序：.Net5 Docker版本：Docker version 19.03.13, ...", "content_html": "\n.net5 网站使用Sqlserver数据库部署在docker容器内运行报主库链接失败
\n数据库：Sqlserver2014\n网站程序：.Net5\nDocker版本：Docker version 19.03.13,\n.net5环境镜像源：mcr.microsoft.com/dotnet/aspnet:5.0-buster-slim\nCentos版本：CentOS Linux release 7.9.2009 (Core)
\nusing (SqlConnection connection = new SqlConnection(\"Data Source=xxxxx;User Id=sa;Password=xxxxxx;Initial Catalog=xxxxxxxx;Pooling=true;Min Pool Size=1;\"))\n{\n connection.Open();\n connection.Close();\n connection.Dispose();\n}A connection was successfully established with the server, but then an error occurred during the pre-login handshake. (provider: SSL Provider, error: 31 - Encryption(ssl/tls) handshake failed)
\n在dockerfile里面加上这么两句
\nRUN sed -i 's/MinProtocol = TLSv1.2/MinProtocol = TLSv1/g' /etc/ssl/openssl.cnf\nRUN sed -i 's/MinProtocol = TLSv1.2/MinProtocol = TLSv1/g' /usr/lib/ssl/openssl.cnf将TLSv1.2设为TLSv1，只能是设为TLSv1而不是设为TLSv1.0
\n当一个 ISelect 构造到一定复杂程序之后，比如：
\npublic void Test()\n{\n var select1 = fsql.Select<AdmRoute>().Include(a => a.Parent)\n .WhereIf(!string.IsNullOrEmpty(key), a => a.Name.Contains(key) || a.Extdata.Contains(key) || a.Remark.Contains(key) || a.TenantId.Contains(key) || a.Parent.Name.Contains(key) || a.Parent.Extdata.Contains(key) || a.Parent.Remark.Contains(key) || a.Parent.TenantId.Contains(key))\n .WhereIf(Parent_Id?.Any() == true, a => Parent_Id.Contains(a.ParentId))\n .WhereIf(mn_Roles_Id?.Any() == true, a => a.Roles.AsSelect().Any(b => mn_Roles_Id.Contains(b.Id)));\n\n var select2 = select1;\n select1.Where(a => a.Status == 0);\n //此时 select2 也附加了 a.Status == 0 条件\n}利用语法糖解决：
\npublic void Test()\n{\n ISelect<AdmRoute> GetSelect() => fsql.Select<AdmRoute>().Include(a => a.Parent)\n .WhereIf(!string.IsNullOrEmpty(key), a => a.Name.Contains(key) || a.Extdata.Contains(key) || a.Remark.Contains(key) || a.TenantId.Contains(key) || a.Parent.Name.Contains(key) || a.Parent.Extdata.Contains(key) || a.Parent.Remark.Contains(key) || a.Parent.TenantId.Contains(key))\n .WhereIf(Parent_Id?.Any() == true, a => Parent_Id.Contains(a.ParentId))\n .WhereIf(mn_Roles_Id?.Any() == true, a => a.Roles.AsSelect().Any(b => mn_Roles_Id.Contains(b.Id)));\n\n var select1 = GetSelect();\n var select2 = GetSelect();\n select1.Where(a => a.Status == 0);\n //此时 select2 不会附加 a.Status == 0 条件\n}科普：
\ncsharp 7.0 支持本地函数，方法内再定义临时方法，这个特性向大家推荐，在很多时候都非常有效。
\n方法内还可以定义方法，那就称它：本地函数/嵌套方法。
\nSELECT\na.\"Time\",\nv1 = sum(case when a.\"Id\" == 1 then 1 else 0 end),\nv2 = sum(case when a.\"Id\" == 2 then 1 else 0 end),\nv3 = sum(case when a.\"Id\" == 3 then 1 else 0 end)\nFROM \"table\" a\nWHERE a.\"Id\" IN (1,2,3)\nGROUP BY a.\"Time\"如上 v1,v2,v3 是动态聚合值，如果 where IN (1,2,3,4) 那就会产生 v1-v4
\n正常情况下，静态的 lambda 查询没办法处理这种动态列查询。
\n", "date_published": "2022-06-24T16:45:08.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "In多列查询，表达式自定义实现", "url": "https://freesql.net/extra/issues-in-valuetype.html", "id": "https://freesql.net/extra/issues-in-valuetype.html", "summary": "In多列查询，表达式自定义实现 FreeSql 基础库为了不依赖 System.ValueType.dll，所以将以下代码抽离了出来。 Oracle 产生如下SQL： 非 ORACLE 产生如下 SQL： v3.2.650 使用 .Where(a => list.Any(b => b.Item1 == a. Id && b.Item2 == a. ct...", "content_html": "\nFreeSql 基础库为了不依赖 System.ValueType.dll，所以将以下代码抽离了出来。
\n//元组集合\nvar lst = new List<(Guid, DateTime)>();\nlst.Add((Guid.NewGuid(), DateTime.Now));\nlst.Add((Guid.NewGuid(), DateTime.Now));\n\nvar t2 = fsql.Select<T>()\n .Where(a => lst.Contains(a.Id, a.ct1))\n .ToList();Oracle 产生如下SQL：
\nSELECT .. FROM ..\nWHERE (a.\"Id\", a.\"ct1\") in (\n('685ee1f6-bdf6-4719-a291-c709b8a1378f','2019-12-07 23:55:27'),\n('5ecd838a-06a0-4c81-be43-1e77633b7404', '2019-12-07 23:55:27'))非 ORACLE 产生如下 SQL：
\nSELECT .. FROM ..\nWHERE (a.\"Id\" = '685ee1f6-bdf6-4719-a291-c709b8a1378f' AND a.\"ct1\" = '2019-12-07 23:55:27' OR\na.\"Id\" = '5ecd838a-06a0-4c81-be43-1e77633b7404' AND a.\"ct1\" = '2019-12-07 23:55:27')\n\nv3.2.650 使用 .Where(a => list.Any(b => b.Item1 == a. Id && b.Item2 == a. ct1))
\n
代码实现：
\nusing FreeSql.DataAnnotations;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading;\n\n[ExpressionCall]\npublic static class MyFreeSqlExpressionCall\n{\n public static ThreadLocal<ExpressionCallContext> expContext = new ThreadLocal<ExpressionCallContext>();\n /// <summary>\n /// C#：从元组集合中查找 exp1, exp2 是否存在<para></para>\n /// SQL： <para></para>\n /// exp1 = that[0].Item1 and exp2 = that[0].Item2 OR <para></para>\n /// exp1 = that[1].Item1 and exp2 = that[1].Item2 OR <para></para>\n /// ... <para></para>\n /// 注意：当 that 为 null 或 empty 时，返回 1=0 <para></para>\n /// Oracle： (Id, Name) IN ((1, \"name1\"), (2, \"name2\"))\n /// </summary>\n /// <typeparam name=\"T1\"></typeparam>\n /// <typeparam name=\"T2\"></typeparam>\n /// <param name=\"that\"></param>\n /// <param name=\"exp1\"></param>\n /// <param name=\"exp2\"></param>\n /// <returns></returns>\n public static bool Contains<T1, T2>([RawValue] this IEnumerable<(T1, T2)> that, T1 exp1, T2 exp2)\n {\n if (expContext.IsValueCreated == false || expContext.Value == null || expContext.Value.ParsedContent == null)\n return that?.Any(a => a.Item1.Equals(exp1) && a.Item2.Equals(exp2)) == true;\n if (that?.Any() != true)\n {\n expContext.Value.Result = \"1=0\";\n return false;\n }\n var sb = new StringBuilder();\n var idx = 0;\n\n switch (expContext.Value.DataType )\n {\n case FreeSql.DataType.Oracle:\n case FreeSql.DataType.OdbcOracle:\n sb.Append(\"(\")\n .Append(expContext.Value.ParsedContent[\"exp1\"]).Append(\", \")\n .Append(expContext.Value.ParsedContent[\"exp2\"])\n .Append(\") IN (\");\n foreach (var item in that)\n {\n if (idx++ > 0) sb.Append(\", \");\n sb.Append(\"(\")\n .Append(expContext.Value.FormatSql(FreeSql.Internal.Utils.GetDataReaderValue(typeof(T1), item.Item1))).Append(\", \")\n .Append(expContext.Value.FormatSql(FreeSql.Internal.Utils.GetDataReaderValue(typeof(T2), item.Item2)))\n .Append(\")\");\n }\n sb.Append(\")\");\n\n expContext.Value.Result = sb.ToString();\n return false;\n }\n foreach (var item in that)\n {\n if (idx++ > 0) sb.Append(\" OR \\r\\n\");\n sb\n .Append(expContext.Value.ParsedContent[\"exp1\"]).Append(\" = \").Append(expContext.Value.FormatSql(FreeSql.Internal.Utils.GetDataReaderValue(typeof(T1), item.Item1)))\n .Append(\" AND \")\n .Append(expContext.Value.ParsedContent[\"exp2\"]).Append(\" = \").Append(expContext.Value.FormatSql(FreeSql.Internal.Utils.GetDataReaderValue(typeof(T2), item.Item2)));\n }\n expContext.Value.Result = sb.ToString();\n return true;\n }\n}二种解决办法：
\n1、[Column(DbType = \"DATETIME\")]
\n2、统一处理的话写个AOP
\nfsql.Aop.ConfigEntityProperty += (s, e) =>\n{\n if (e.Property.PropertyType == typeof(DateTime) || e.Property.PropertyType == typeof(DateTime?))\n e.ModifyResult.DbType = \"DATETIME\";\n};FreeSql.Provider.MySqlConnector是FreeSql基于社区提供的最新的MySqlConnector驱动的实现，兼容性、性能都比FreeSql.Provider.MySql好，且支持多种数据库，如：MySQL, MariaDB, Percona, Amazon Aurora, Azure Database for MySQL, Google Cloud SQL for MySQL, OceanBase, Doris, Tidb
并且支持BulkCopy，推荐使用
\n如果你使用 FreeSql.Provider.MySql 发生了以下错误，请替换到 FreeSql.Provider.MySqlConnector：
默认情况 c# 枚举会映射为 MySql Enum 类型，如果想映射为 int 在 FreeSqlBuilder Build 之后执行以下 Aop 统一处理：
\nfsql.Aop.ConfigEntityProperty += (s, e) => {\n if (e.Property.PropertyType.IsEnum)\n e.ModifyResult.MapType = typeof(int);\n};public class Department\n{\n [Column(IsPrimary = true, IsIdentity = true)]\n public long Id { get; set; }\n public string Name { get; set; }\n}\nList<Department> departments = new List<Department>()\n{\n new Department() { Name =\"部门1\"},\n new Department() { Name =\"部门2\"},\n new Department() { Name =\"部门3\"}\n};\nfsql.Insert(departments)\n .InsertIdentity() //这行\n .ExecuteMySqlBulkCopy();List<Department> departments = new List<Department>()\n{\n new Department() { Id=1, Name =\"部门1\"},\n new Department() { Id=2, Name =\"部门2\"},\n new Department() { Id=3, Name =\"部门3\"}\n};\nfsql.Insert(departments)\n .ExecuteMySqlBulkCopy();fsql.Update<T>.SetSource(items)\n .ExecuteSqlBulkCopy(); //临时表 + MERGE INTO\n\nfsql.InsertOrUpdate<T>.SetSource(items)\n .ExecuteSqlBulkCopy(); //临时表 + MERGE INTOFreeSql 对 Oracle 支持非常友好，是 c#.net ORM 不二之选，提供了 Ado.net/Odbc/Oledb 三种实现包，他们都支持 .NETCore2.1+、.NET4.0+ 等最新或较低的 .NETFramework 版本。
\n若想以 Ado.net 驱动访问数据库，请安装：
\n\n\ndotnet add package FreeSql.Provider.Oracle
\n
若想以 ODBC 驱动访问数据库，请安装：
\n\n\ndotnet add package FreeSql.Provider.Odbc
\n
若想以 Oledb 驱动访问数据库，请安装：
\n\n\n", "date_published": "2022-06-24T16:45:08.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "PostgreSQL", "url": "https://freesql.net/guide/freesql-provider-postgresql.html", "id": "https://freesql.net/guide/freesql-provider-postgresql.html", "summary": "nuget 安装：FreeSql.Provider.PostgreSQL 数组、字典 PostgreSQL 数据类型丰富，支持 int[]、string[] 数组类型，Dictionarydotnet add package FreeSql.Provider.OracleOledb
\n
nuget 安装：FreeSql.Provider.PostgreSQL
\nPostgreSQL 数据类型丰富，支持 int[]、string[] 数组类型，Dictionary<string, string> 字典类型。
\nclass model\n{\n public int id { get; set; }\n public int[] tagIds { get; set; } //映射数组\n public string[] tagNames { get; set; }\n\n public Dictionary<string, string> dict { get; set; } //映射 hstore\n}\n\n// 支持索引查询\nfsql.Select<model>().Where(a => a.tagIds.Contains(100)).ToList();\nfsql.Select<model>().Where(a => a.dict.ContainsKey(\"key1\")).ToList();参考资料：《PostgreSQL Array 数组类型与 FreeSql 打出一套【组合拳】》
\nPostgreSQL JSON 类型的查询性能不输 mongodb，适合做动态结构的数据存储场景。
\nFreeSql.Provider.PostgreSQL 默认使用 Newtonsoft.Json.Linq 映射 jsonb 类型，如下三种均可：
\nclass model\n{\n public JToken jsonb1 { get; set; }\n public JObject jsonb2 { get; set; }\n public JArray jsonb3 { get; set; }\n}\n\n// 支持索引查询\nfsql.Select<model>().Where(a => a.jsonb1.ContainsKey(\"key1\")).ToList();\n//SQL: WHERE coalesce(a.jsonb1, '{}') ? 'key1'\n\nfsql.Select<model>().Where(a => a.jsonb2[\"key1\"].ContainsKey(\"key2\")).ToList();\n//SQL: WHERE coalesce(a.jsonb2->key1, '{}') ? 'key2'\n\nfsql.Select<model>().Where(a => a.jsonb2.Contains(JToken.Parse(\"{key1:'xxx'}\")).ToList();\n//SQL: WHERE coalesce(a.jsonb2, '{}') @> '{\"key1\":'xxx'}'::jsonb\n\nfsql.Select<model>().Where(a => a.jsonb2[\"key1\"][\"key2\"].ToString() == \"xxx\").ToList();\n//SQL: WHERE (a.jsonb2->key1->key2)::text = 'xxx'\n\nfsql.Select<model>().Where(a => int.Parse(a.jsonb2[\"key1\"][\"key2\"].ToString()) > 100).ToList();\n//SQL: WHERE (a.jsonb2->key1->key2)::text::int4 > 100| lambda 表达式树函数 | PostgreSQL | 功能说明 |\n|
\n", "date_published": "2022-06-24T16:45:08.000Z", "date_modified": "2025-03-28T04:00:05.000Z", "authors": [], "tags": [] }, { "title": "基于FreeSql扩展文档", "url": "https://freesql.net/extra/", "id": "https://freesql.net/extra/", "summary": "基于FreeSql扩展文档 更多文档 CentOS8 ARM 下连接 SQL Server 2008 R2（Hypervisor） 一对多关系，分表只取关联的第一条记录，如何获取", "content_html": "\n多库切换，动态切库，动态注册数据库
\n该方法适用于固定数据库，固定配置项
\n1、定义两个标识类：
\nclass MySqlFlag {}\nclass SqlServerFlag {}2、在 Startup.cs 中单例注入
\npublic void ConfigureServices(IServiceCollection services)\n{\n Func<IServiceProvider, IFreeSql<MySqlFlag>> fsql1 = r =>\n {\n var fsql1 = new FreeSqlBuilder().UseConnectionString(DataType.MySql, \"str1\")\n .Build<MySqlFlag>();\n return fsql1;\n };\n Func<IServiceProvider, IFreeSql<SqlServerFlag>> fsql2 = r =>\n {\n var fsql2 = new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, \"str1\")\n .Build<SqlServerFlag>();\n return fsql2;\n };\n\n services.AddSingleton<IFreeSql<MySqlFlag>>(fsql1);\n services.AddSingleton<IFreeSql<SqlServerFlag>>(fsql2);\n}3、在 Controller 中使用
\n[Route(\"api/[controller]\")]\n[ApiController]\npublic class ValuesController : ControllerBase\n{\n public ValuesController(IFreeSql<MySqlFlag> mysql, IFreeSql<SqlServerFlag> sqlserver)\n {\n }\n}为 FreeSql 提供跨数据库访问，分布式事务TCC、SAGA解决方案，支持 .NET Core 2.1+, .NET Framework 4.0+.
\n开源地址：https://github.com/2881099/FreeSql.Cloud
\n\n\ndotnet add package FreeSql.Cloud
\n
or
\n\n\nInstall-Package FreeSql.Cloud
\n
public enum DbEnum { db1, db2, db3 }\n\nvar fsql = new FreeSqlCloud<DbEnum>(\"myapp\"); //提示：泛型可以传入 string\nfsql.DistributeTrace = log => Console.WriteLine(log.Split('\\n')[0].Trim());\n\nfsql.Register(DbEnum.db1, () => new FreeSqlBuilder()\n .UseConnectionString(DataType.Sqlite, @\"Data Source=db1.db\")\n .Build());\n\nfsql.Register(DbEnum.db2, () => new FreeSqlBuilder()\n .UseConnectionString(DataType.Sqlite, @\"Data Source=db2.db\")\n .Build());\n\nfsql.Register(DbEnum.db3, () => new FreeSqlBuilder()\n .UseConnectionString(DataType.Sqlite, @\"Data Source=db3.db\")\n .Build());\n\nFreeSqlCloud 必须定义成单例模式
\n
\n\nnew FreeSqlCloud<DbEnum>() 多连接管理
\n
\n\nnew FreeSqlCloud<DbEnum>(\"myapp\") 开启 TCC/SAGA 事务生效
\n
FreeSqlCloud 的访问方式和 IFreeSql 一样：
\nfsql.Select<T>();\nfsql.Insert<T>();\nfsql.Update<T>();\nfsql.Delete<T>();\n\n//...切换数据库：
\nfsql.Change(DbEnum.db3).Select<T>();\n//以后所有 fsql.Select/Insert/Update/Delete 操作是 db3自动定向数据库配置：
\n//对 fsql.CRUD 方法名 + 实体类型 进行拦截，自动定向到对应的数据库，达到自动 Change 切换数据库目的\nfsql.EntitySteering = (_, e) =>\n{\n switch (e.MethodName)\n {\n case \"Select\":\n if (e.EntityType == typeof(T))\n {\n //查询 T 自动定向 db3\n e.DBKey = DbEnum.db3;\n }\n else if (e.DBKey == DbEnum.db1)\n {\n //此处像不像读写分离？\n var dbkeyIndex = new Random().Next(0, e.AvailableDBKeys.Length);\n e.DBKey = e.AvailableDBKeys[dbkeyIndex]; //重新定向到其他 db\n }\n break;\n case \"Insert\":\n case \"Update\":\n case \"Delete\":\n case \"InsertOrUpdate\":\n break;\n }\n};多个 IFreeSql 实例，如何注入使用？ · Issue #44 · dotnetcore/FreeSql (github.com)
\n", "date_published": "2022-06-23T16:16:24.000Z", "date_modified": "2022-09-21T01:47:09.000Z", "authors": [], "tags": [] }, { "title": "支持我们", "url": "https://freesql.net/reference/service-support.html", "id": "https://freesql.net/reference/service-support.html", "summary": "支持我们 FreeSql 采用 MIT 最宽松的开源协议，永久免费开源。任何公司或个人，都可以使用在任何商业项目中。 QQ 技术群：561616019(在线)、4336577(满员)、8578575(满员)、52508226(满员) 反馈问题请前往 https://github.com/dotnetcore/FreeSql/issues 💕 自愿捐赠...", "content_html": "\nFreeSql 采用 MIT 最宽松的开源协议，永久免费开源。任何公司或个人，都可以使用在任何商业项目中。
\nQQ 技术群：561616019(在线)、4336577(满员)、8578575(满员)、52508226(满员)
\n反馈问题请前往 https://github.com/dotnetcore/FreeSql/issues
\n\n\nDonate the author to have a cup of coffee
\n
![](\"/barcode_2x1.png\")
\nL*y 58 元、花花 88 元、麦兜很乖 50 元、网络来者 2000 元、John 99.99 元、alex 666 元、bacongao 36 元、无名 100 元、Eternity 188 元、无名 10 元、⌒.Helper~..oO 66 元、习惯与被习惯 100 元、无名 100 元、蔡易喋 88.88 元、中讯科技 1000 元、Good Good Work 24 元、炽焰 6.6 元、Nothing 100 元、兰州天擎赵 500 元、哈利路亚 300 元、\n无名 100 元、蛰伏 99.99 元、TCYM 66.66 元、MOTA 5 元、LDZXG 30 元、Near 30 元、建爽 66 元、无名 200 元、LambertWu 100 元、无名 18.88 元、乌龙 50 元、无名 100 元、陳怼怼 66.66 元、陳怼怼 66.66 元、丁淮 100 元、李伟坚-Excel 催化剂 100 元、白狐 6.66 元、她微笑的脸 y 30 元、Eternity²º²¹ 588 元、夜归柴门 88 元、蔡易喋 666.66 元、\n礼 10 元、litrpa 88 元、Alax CHOW 200 元、Daily 66 元、kt 66 元、蓝 100 元、*菜 10 元、生命如歌 1000 元、山鸡 88元、平凡 100元、大树 1000元、软软的毛毛虫 66.66元、问卷星 2000元、与你无关 5000元、看门大爷 1000元，*来 88.88元，*博 500元，*南 88元，*园 500元，WPF机器视觉活动全体成员 2000元
\n| 服务项目 | 描述 | 价格(RMB) | 付款方式 |\n|
\n", "date_published": "2022-05-25T15:18:32.000Z", "date_modified": "2024-09-03T11:29:23.000Z", "authors": [], "tags": [] }, { "title": "Sqlite", "url": "https://freesql.net/guide/freesql-provider-sqlitecore.html", "id": "https://freesql.net/guide/freesql-provider-sqlitecore.html", "summary": "Sqlite FreeSql.Provider.SqliteCore是FreeSql基于微软提供的最新的Microsoft.Data.Sqlite.Core驱动的实现。 需要另外安装对应的bundle_xxx实现加密。 支持的版本 .NET Standard 2.0（支持.NET Framework4.6.1+/支持.NET Core 2.0+） ne...", "content_html": "\nFreeSql.Provider.SqliteCore是FreeSql基于微软提供的最新的Microsoft.Data.Sqlite.Core驱动的实现。\n需要另外安装对应的bundle_xxx实现加密。
安装FreeSql.Provider.SqliteCore包。
dotnet add package FreeSql.Provider.SqliteCore\ndotnet add package SQLitePCLRaw.bundle_e_sqlite3SQLitePCLRaw.bundle_e_sqlite3 不支持加密，但此方式是官方实现的SQlite版本，以下二选一：
| 捆绑 | 描述 |\n|
\n", "date_published": "2022-03-25T06:41:57.000Z", "date_modified": "2025-01-16T10:00:00.000Z", "authors": [], "tags": [] }, { "title": "UowManager 事务 ✨", "url": "https://freesql.net/guide/unitofwork-manager.html", "id": "https://freesql.net/guide/unitofwork-manager.html", "summary": "UowManager 事务 ✨ 本篇文章内容引导，如何在 asp.net core 项目中使用特性(注解) 的方式管理事务。 UnitOfWorkManager 只可以管理 Repository 仓储对象的事务 支持六种传播方式(propagation)，跨方法的事务非常方便，支持同步异步： Required：如果当前没有事务，就新建一个事务，如果已存...", "content_html": "\n本篇文章内容引导，如何在 asp.net core 项目中使用特性(注解) 的方式管理事务。
\n\n\nUnitOfWorkManager 只可以管理 Repository 仓储对象的事务
\n
支持六种传播方式(propagation)，跨方法的事务非常方便，支持同步异步：
\n最终呈现的事务代码如下：
\npublic class SongService\n{\n readonly IBaseRepository<Song> _songRepository;\n readonly IBaseRepository<Detail> _detailRepository;\n\n public SongService(IBaseRepository<Song> songRepository, IBaseRepository<Detail> detailRepository)\n {\n _songRepository = songRepository;\n _detailRepository = detailRepository;\n }\n\n [Transactional(Propagation.Required)]\n async public Task Test1()\n {\n //所有注入的仓储对象，都是一个事务\n await _songRepository.InsertAsync(xxx1);\n await _detailRepository.DeleteAsync(xxx2);\n this.Test2();\n }\n}//依赖注入\nservices.AddFreeRepository(typeof(Startup).Assembly);\nservices.AddScoped<IFreeSql>(r => r.GetService<UnitOfWorkManager>().Orm);\nservices.AddScoped<UnitOfWorkManager>(r => new UnitOfWorkManager(fsql));\n//以这种方式注入的 IFreeSql 会跟随 UowManager 切换事务，原始 fsql 对象为 static 单例\n\n//中间件\npublic void Configure(IApplicationBuilder app)\n{\n app.Use(async (context, next) =>\n {\n TransactionalAttribute.SetServiceProvider(context.RequestServices);\n await next();\n });\n}\n\n肉夹馍：https://github.com/inversionhourglass/Rougamo
\n
\n\ndotnet add package Rougamo.Fody
\n
[AttributeUsage(AttributeTargets.Method)]\npublic class TransactionalAttribute : Rougamo.MoAttribute\n{\n public Propagation Propagation { get; set; } = Propagation.Required;\n public IsolationLevel IsolationLevel { get => m_IsolationLevel.Value; set => m_IsolationLevel = value; }\n IsolationLevel? m_IsolationLevel;\n\n static AsyncLocal<IServiceProvider> m_ServiceProvider = new AsyncLocal<IServiceProvider>();\n public static void SetServiceProvider(IServiceProvider serviceProvider) => m_ServiceProvider.Value = serviceProvider;\n\n IUnitOfWork _uow;\n public override void OnEntry(MethodContext context)\n {\n var uowManager = m_ServiceProvider.Value.GetService<UnitOfWorkManager>();\n _uow = uowManager.Begin(this.Propagation, this.m_IsolationLevel);\n }\n public override void OnExit(MethodContext context)\n {\n\tif (typeof(Task).IsAssignableFrom(context.ReturnType) && context.ReturnValue != null && context.ReturnValue is Task)\n ((Task)context.ReturnValue).ContinueWith(t => _OnExit());\n else _OnExit();\n\n void _OnExit()\n {\n try\n {\n if (context.Exception == null) _uow.Commit();\n else _uow.Rollback();\n }\n finally\n {\n _uow.Dispose();\n }\n }\n }\n}| UnitOfWorkManager 成员 | 说明 |\n|
\n", "date_published": "2021-08-21T05:59:59.000Z", "date_modified": "2025-07-11T10:21:27.000Z", "authors": [], "tags": [] }, { "title": "IFreeSql 和 DbContext", "url": "https://freesql.net/guide/ifreesql-context.html", "id": "https://freesql.net/guide/ifreesql-context.html", "summary": "IFreeSql 和 DbContext 两者并存 FreeSql 支持 IFreeSql 和 DbContext 两种形式，使用方法差异也有些大，其中 DbContext 跟 EFCore 使用方式基本一致，使用简单、依赖注入方便。 而 IFreeSql 支持更多细粒度的操作。在 DbContext 中，要删除多个行记录，必须先查询实体后，再使用 R...", "content_html": "\nFreeSql 支持 IFreeSql 和 DbContext 两种形式，使用方法差异也有些大，其中 DbContext 跟 EFCore 使用方式基本一致，使用简单、依赖注入方便。
\n而 IFreeSql 支持更多细粒度的操作。在 DbContext 中，要删除多个行记录，必须先查询实体后，再使用 RemoveRange() 删除这些实体，当数据量非常大的时候，便会消耗大量时间和性能。而 IFreeSql 中，支持嵌入部分 SQL ，支持细粒度的行记录操作。在 IFreeSql 中批量删除、修改记录，可以使用类似 SQL 的模式：
await _freesql.Update<Roles>()\n .Set(x => x.IsDeleted, 1)\n .Where(x => x.TenantId == tenantId )\n .ExecuteAffrowsAsync();\n\nupdate roles set is_deleted=1 where where tenant_id=1所以往往将 IFreesql 和 DbContext 并存，在使用时，根据场景使用这两种方式操作数据库。
\nIFreeSql 的创建需要定义为单例模式，示例如下：
\nstatic IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.MySql, connectionString)\n .UseAutoSyncStructure(true) //自动同步实体结构到数据库\n .Build(); //请务必定义成 Singleton 单例模式而 Freesql 也支持了类似 EFCore 的 DbContext 模式。通过引入 FreeSql.DbContext 库，可以使用特性、Fluent api 等配置实体映射、导航属性等，生成类似于 EFCore 的 DbContext 类型，然后通过依赖注入实例化使用。
通过定义 DbContext ，我们可以根据 EFCore 的使用习惯，快速掌握 FreeSql 的使用，甚至可以直接将 EFCore DbContext 转为 Freesql DbContext，因为 Freesql DbContext 支持了 95% 的 EFCore Fluent api 。
\n下面说说如何利用 FreeSql 更加方便地迁移数据库以及定义 DbContext。
\n安装 FreeSql 工具：
\ndotnet tool install -g FreeSql.Generator接着还原数据库表为实体：
\nFreeSql.Generator -NameOptions 1,1,0,1 -NameSpace AuthCenter.Database.Entities -DB \"MySql,data source=123.123.123.123;port=3306;user id=root;password=root;initial catalog=datab;charset=utf8;sslmode=none;max pool size=2\" -FileName \"{name}.cs\"还原的实体示例：
\n[JsonObject(MemberSerialization.OptIn), Table(Name = \"roles\", DisableSyncStructure = true)]\npublic partial class Roles\n{\n\n [JsonProperty, Column(Name = \"id\", DbType = \"bigint unsigned\", IsPrimary = true)]\n public ulong Id { get; set; }\n\n /// <summary>\n /// 创建时间\n /// </summary>\n [JsonProperty, Column(Name = \"creation_time\", DbType = \"bigint unsigned\")]\n public ulong CreationTime { get; set; }\n}在 FreeSql 中，实体特性优先于 Fluent api，同时 FreeSql 也兼容 EFCore 的实体特性。
\n由于 FreeSql.Generator 工具很方便，我们不需要另外使用 Fluent api 去定义复杂的逻辑结构。
接着定义 DbContext：
\nusing FreeSql;\n\nnamespace My.Context\n{\n public partial class AuthcenterContext : DbContext\n {\n private readonly IFreeSql iFreesql;\n public AuthcenterContext()\n {\n }\n\n public AuthcenterContext(IFreeSql freeSql)\n {\n iFreesql = freeSql;\n }\n\n public virtual DbSet<Roles> Roles { get; set; }\n protected override void OnConfiguring(DbContextOptionsBuilder builder)\n {\n // iFreesql.xxxx\n // 使用 iFreesql 调用 Fluent api\n builder.UseFreeSql(iFreesql);\n }\n\n protected override void OnModelCreating(ICodeFirst codefirst)\n {\n\n }\n }\n}\n\n通过这种方法，IFreeSql 和 DbContext 中的实体及其实体特性、Fluent api 等都保持一致。
\n
接着，在依赖注入中，将 IFreeSql 和 DbContext 都注入。
\npublic void ConfigureServices(IServiceCollection services)\n{\n IFreeSql fsql = new FreeSql.FreeSqlBuilder()\n .UseConnectionString(FreeSql.DataType.MySql, @\"data source=123.123.123.123;port=3306;user id=root;password=root;initial catalog=authcenter;charset=utf8\")\n .Build();\n services.AddSingleton<IFreeSql>(fsql);\n services.AddFreeDbContext<AuthcenterContext>(options => options.UseFreeSql(fsql));\n}我们在类型中通过依赖注入获取到这两种服务：
\nprivate readonly IFreeSql _freesql;\nprivate readonly MyContext _context;\n\npublic Test(IFreeSql freeSql, MyContext context)\n{\n _freesql = freeSql;\n _context = context;\n}然后就可以快乐地使用 Freesql 了。
\n", "date_published": "2021-07-14T05:16:31.000Z", "date_modified": "2022-09-04T08:51:00.000Z", "authors": [], "tags": [] }, { "title": "WithSql", "url": "https://freesql.net/guide/withsql.html", "id": "https://freesql.net/guide/withsql.html", "summary": "WithSql WithSql 自定义 SQL 定义实体类 不同的查询方式。 返回DataTable 返回List