CRL快速开发框架升级到3.1

CRL是一款面向对象的轻量级ORM框架,本着快速开发,使用简便的原则,设计为

1. 无需关心数据库结构,CRL自动维护创建,即写即用(CRL内部有表结构检查机制,保证表结构一致性)
2. 无需第三方工具生成代理类,标准对象结构即可
3. 基于Linq.Expression语法解析,完全对象化操作
4. 支持join,group等语法和函数扩展方法
5. 多种结果类型返回,对象,自定义对象,泛类型,字典等
6. 多种数据库,多库支持
7. 可封装继承的结构,充分使用面向对象的特性

在3.0大版本,增加了上手示例CRLShoppingDemo 供参考,同时自带的开发文档也在同步更新

最新版由于方法和结构有所更改,升级到3.1

到目前为止,常用查询语法和函数方法已经解析完成,支持功能表现在:

• Join 多表关联查询
• Sum,Count,Max,Min函数统计
• 单表Group,Distinct
• 查询字段筛选,支持别名
• 可为空属性类型Nullable
• 支持虚拟字段
• 基本逻辑判断语法和扩展函数方法
• 多表字段排序
• 多种结果类型返回
• 任意查询分页

3.1主要优化内容

1. 优化查询语法,统一了结果返回方法
2. 增强了表结构检查,后台线程会强制检查对像与表结构一致性

更新1:语法查询优化

语法查询优化表现在以下几个方面

• 字段间二元运算 
  query.Select(b => new {aa = b.Id * b.Number })//选择字段时二元运算 
  query.Where(b => b.Id < b.Id * b.Number)//条件选择时二元运算
• 表达式不区分左右
  query.Where(b => 10 > b.Id);和query.Where(b => b.Id < 10 ); 等效
• 一元运算支持 
  query.Where(b => !b.IsTop)//等效为 isTop!=1 目前只处理了BOOL类型 
  query.Where(b => !b.ProductName.Contains("122"))//BOOL类型的扩展方法同样支持
• 关联查询支持以上所有特性
  query.Join<Code.Member>((a, b) => a.UserId == b.Id && a.Id == c).Select((a, b) => new { a.BarCode, Year2 = b.Year * b.Id }); 
  关联查询支持关联表排序 query.OrderBy<Code.Member>(b => b.Name, true)
• 多列排序,只需调用OrderBy方法多次
  query.OrderBy(b => b.Id, true);//按ID倒序
  query.OrderBy(b => b.Name, false)//按Name正序
  结果等效为 order by Id desc,Name asc

查询方法修改

• 使用LambdaQuery完整查询调用Page方法就可以分页了,通过ToList和ToDynamic方法返回指定类型结果
• 当设置了关联,Group语法,也会按关联,Group语法解析
• 当调用了Select方法筛选字段,则需要根据实际情况返回结果类型
• 返回结果可以有以下几种类型
  • List<dynamic> ToDynamic() 按筛选值返回动态类型
  • List<TResult> ToList<TResult>() 按筛选值返回指定类型
  • List<T> ToList() 直接返回当前类型
  • Dictionary<TKey, TValue> ToDictionary<TKey, TValue>() 按筛选值返回字典(不支持分页)

示例

代码1(实现Group查询)

//Group查询
            var query = Code.ProductDataManage.Instance.GetLambdaQuery();
            query.Select(b => new { b.BarCode, total = b.BarCode.COUNT() });
            query.Where(b => b.Id > );
            query.GroupBy(b => new { b.BarCode });
            query.OrderBy(b => b.BarCode.COUNT(), true);//Group需要设置排序
            query.Page(,);//如果要分页,设定分页参数就行了
            var list = query.ToDynamic();
            int total = query.RowCount;

输出

select  t1.BarCode,COUNT(t1.BarCode) as total  from [ProductData] t1  with(nolock)    where (t1.Id>@parame0) group by t1.BarCode  order by  COUNT(t1.BarCode) desc
[parame0]:[]

代码2(实现关联查询)

//关联查询
            var query = Code.ProductDataManage.Instance.GetLambdaQuery();
            query.Where(b => b.Id > );
            query.Join<Code.Member>((a, b) => a.UserId == b.Id).Select((a, b) => new { a.BarCode, b.Name });
            query.Page(,);//如果要分页,设定分页参数就行了
            var list = query.ToDynamic();
            int total = query.RowCount;

输出

select  t1.BarCode,t2.Name  from [ProductData] t1  with(nolock)   Inner join Member t2   with(nolock) on (t1.UserId=t2.Id)  where (t1.Id>@parame0)
[parame0]:[]

代码3(实现关联再Group)

//关联再Group查询
            var query = Code.ProductDataManage.Instance.GetLambdaQuery();
            query.Where(b => b.Id > );
            query.Join<Code.Member>((a, b) => a.UserId == b.Id).GroupBy((a, b) => new { a.BarCode, b.Name }).Select((a, b) => new { a.BarCode, b.Name });
            query.OrderBy(b=>b.BarCode);
            query.Page(,);//如果要分页,设定分页参数就行了
            var list = query.ToDynamic();
            int total = query.RowCount;

输出

select  t1.BarCode,t2.Name  from [ProductData] t1  with(nolock)   Inner join Member t2   with(nolock) on (t1.UserId=t2.Id)  where (t1.Id>@parame0) group by t1.BarCode,t2.Name  order by  t1.BarCode desc
[parame0]:[]

代码4(实现多次关联)

//多表关联查询
            var query = Code.ProductDataManage.Instance.GetLambdaQuery();
            query.Where(b => b.Id > );
            query.Join<Code.Member>((a, b) => a.UserId == b.Id).Select((a, b) => new { a.ProductName, b.Name });//筛选返回的字段
            query.Join<Code.Order>((a, b) => a.UserId == b.UserId).Select((a, b) => new { orderid = b.OrderId });//筛选返回的字段
            query.OrderBy(b=>b.BarCode);
            query.Page(,);//如果要分页,设定分页参数就行了
            var list = query.ToDynamic();
            int total = query.RowCount;

输出

select  t1.ProductName,t2.Name,t3.OrderId as orderid  from [ProductData] t1  with(nolock)   Inner join Member t2   with(nolock) on (t1.UserId=t2.Id)  Inner join OrderProduct t3   with(nolock) on (t1.UserId=t3.UserId)  where (t1.Id>@parame0)  order by  t1.BarCode desc
[parame0]:[]

• 对于一个查询,只需调用query.Page()方法就能轻易实现分页
• 如果需要把动态类型结果转换成定义好的对象,只需调用query.ToList<ClassName>()方法
• 业务类中不再提供使用完整LambdaQuery作为参数的方法返回数据,而直接使用LambdaQuery的子方法返回数据,如上所示

关于分页

• 设定分页参数后,CRL会生成对应数据库分页语法,如MSSQL采用ROWNUM分页
• 分页默认是编译为存储过程,如果数据库不支持自动编译,由以语句的形式查询
• 默认分页和Group分页为两种处理方式

更新2:表结构强制检查

关于数据表创建缓存依赖

1. CRL会自动创建对象对应的表结构,并初始
2. CRL判断该不该创建对象对应的数据表,是由表缓存文件来判断,缓存文件路径/config/TableCache.config
3. 系统运行时检查目录内有没有缓存,有则加载,没有则创建,在CRL内部检测表创建方法内,根据此缓存来判断,不存在表缓存,则创建表并保存缓存值
4. 新增的对象,此时缓存内是没有的,则会创建数据表
5. 在缓存结构和数据表结构一致的情况下,新增对象属性时,会自动创建数据表列
6. 缓存文件和数据库实际表结构在一些情况下可能不一致,则需要手动干预

• 当数据库有表,但字段不全,也没有缓存文件,CRL创建缓存文件时会按对象完整的结构缓存,此时缓存的表结构和数据库结构就不一致
• 当缓存内有表,数据库没有表,CRL没法判断,不会自动创建表
• 当缓存内表有所有表字段结构,数据库表字段被手动删掉,此时结构不一致
• 当缓存文件被其它数据源生成的缓存文件覆盖了,可能产生结构不一致

由于以上问题,可能会导至找不到字段或表的错误,当前版本作了完善,于是在后台单独开启了一个线程,用以检查表结构,在对象被首次访问后,就会添加到结构检查队列,由后台异步进行处理

在程序运行后,每个被访问过的对象会被检查一次结构,达到结构同步的目的

源码请入群获取,密语CRL

源码结构:

CRL3.0=>

　　CRLShoppingDemo------------->在线购物示例项目

　　Core.Mvc------------------------->MVC简单封装

　　CRL------------------------------->CRL主框架

　　CRL.Package--------------------->CRL业务封装

　　RoleControl---------------------->基于CRL实现的通用权限系统

　　WebTest------------------------->开发&测试文档

历史升级导读

• 快速开发框架CRL3.0发布,附带最新的项目示例CRLShoppingDemo
• 重磅来袭,使用CRL实现大数据分库分表方案
• 缓存服务新思路,创建动态查询的缓存