CodeFirst
一直以来我们写应用的时候首先都是创建数据库
终于在orm支持codefirst之后，我们可以先建模。
通过模型去创建数据库，并且基于codefirst可以实现方便的
实现数据库迁移的工作.使用codefirst有以下几个技巧，
以EntityFramework为例,结合我这个设计做了以下改进
1.模型的识别
建立一个基类命名Entity，里面只有一个long类型的id字段。
所有需要映射到数据库的模型都继承自Entity,
public class Entity
{
public long Id { get; set; }
}
2.模型的映射
选用fluntapi作为配置（可以保持模型类的整洁，并且和具体orm无关）
新建一个配置基类继承自EntityTypeConfiguration，并且添加泛型约束，
在构造函数中配置表名(和类名一致),和id作为主键，并且设置成由程序生成。
如果是一般单表的话，配合System.ComponentModel.DataAnnotations下的特性
即可完成数据库字段长度等等限制
public class BaseEntityTypeConfig<TEntity> : EntityTypeConfiguration<TEntity>, IEntityConfiguration where TEntity : class, Entity
{
public BaseEntityTypeConfig()
{
HasKey(item => item.Id);
Property(item => item.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
ToTable(typeof(TEntity).Name);
}
}
3.模型的生成
重写DbContext的OnModelCreating方法，反射程序集所有需要映射的类型，
然后，查找对应配置，如果没有则构造出配置基类，即可完成模型的创建，
ef默认会在第一次访问的时候去创建或者校验模型，
模型的配置缓存在全局静态数据中。如果对应模型类有
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//这里 获取所有已经存在的配置
var configs = MetaDataManager.Type.Find(item =>
{
if (item.BaseType == null || !item.BaseType.IsGenericType)
return false;
if (item.BaseType.GetGenericTypeDefinition() != typeof(BaseEntityTypeConfig<>))
return false;
var genericType =
item.BaseType.GetGenericArguments()
.FirstOrDefault(data => data.IsSubclassOf(typeof(Entity)));
if (genericType == null)
return false;
return _context.Types.Contains(genericType);
}).ToDictionary(item => item.BaseType.GetGenericArguments().FirstOrDefault(data => data.IsSubclassOf(typeof(Entity))), item => item);
//如果对应的实体有配置则从配置生成，如果没有配置，那么默认给出配置
_context.Types.ForEach(item =>
{
if (IgnoreAttribute.IsDefined(item))
return;
Type type;
if (!configs.TryGetValue(item, out type))
type = typeof(BaseEntityTypeConfig<>).MakeGenericType(item);
dynamic config = Activator.CreateInstance(type);
modelBuilder.Configurations.Add(config);
});
}
Repository
关于Repository的文章很多，这里就不重复描述了。
我这里都是采用的接口编程，全部是采用构造函数来注入。
我这里需要为每个类型的CurdService注入一个默认Repository实现。
Assembly.GetExecutingAssembly().GetTypes().Where(item => item.IsSubclassOf(typeof (Entity)))
.ForEach(item =>
{
var interfaceType = typeof (IRepository<>).MakeGenericType(item);
var classType = typeof (Repository<>).MakeGenericType(item);
UnityService.RegisterType(interfaceType, classType);
});
其他一些技术
UnitOfWork(工作单元)
网上文章也很多，简单来说，把若干个数据库操作放在一起作为事务提交
得益于ef的设计，ef使用dbcontext.savechanges()方法等价于unitofwork.commit()方法
这部分的设计主要借鉴NLayerApp.
如果没有ef我建议是把每一个增删改类型的sql命令做成委托，然后左后commit的时候
使用事务提交。代码如下
List<Action<DbConnection>> works = new List<Action<DbConnection>>();
public void Excute(Action<DbConnection> work)
{
works.Add(work);
}
public void Commint()
{
using (TransactionScope ts = new TransactionScope())
{
using (var conn = new SqlConnection("{链接字符串}"))
{
works.ForEach(work => work(conn));
}
ts.Complete();
}
}
Specification(规约)
同样网上的文章也很多，我这里只是把他作为查询实体来使用.
如果使用传统ado.net的方式，直接传表达式到Repository中的话
将导致解析表达式特别复杂，而用Specification的话，相当于查询
语句中的where部分由它来接管，这样解耦和Repository和具体orm的依赖
这部分的设计主要借鉴NLayerApp
多排序
在分页中我们经常遇到多查询的情况，核心就是构造表达式，等同于构造
sql语句中orderby的部分，同时它也支持内存中的多排序
这部分设计主要借鉴Apworks中多排序的设计
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Coralcode.Framework.Models;
namespace Coralcode.Framework.Domains
{
public class SortExpression<TEntity> where TEntity : class
{
/// <summary>
/// key:属性名，value,true为升序，false为降序
/// </summary>
private readonly List<EditableKeyValuePair<Expression<Func<TEntity, dynamic>>, bool>> _sortList;
public SortExpression(List<EditableKeyValuePair<Expression<Func<TEntity, dynamic>>, bool>> sortList)
{
_sortList = sortList;
}
/// <summary>
/// 如果为空则不需要排序
/// </summary>
/// <returns></returns>
public bool IsNeedSort()
{
return _sortList.Count != 0;
}
public IQueryable<TEntity> BuildSort(IQueryable<TEntity> query)
{
if (_sortList == null || _sortList.Count == 0)
return query;
_sortList.ForEach(item =>
{
//获取表达式变量参数 item
var parameter = item.Key.Parameters[0];
//解析属性名
Expression bodyExpression = null;
if (item.Key.Body is UnaryExpression)
{
UnaryExpression unaryExpression = item.Key.Body as UnaryExpression;
bodyExpression = unaryExpression.Operand;
}
else if (item.Key.Body is MemberExpression)
{
bodyExpression = item.Key.Body;
}
else
throw new ArgumentException(@"The body of the sort predicate expression should be either UnaryExpression or MemberExpression.", "sortPredicate");
MemberExpression memberExpression = (MemberExpression)bodyExpression;
string propertyName = memberExpression.Member.Name;
//根据属性名获取属性
var property = typeof(TEntity).GetProperty(propertyName);
//创建一个访问属性的表达式 item.property
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
//创建表达式 item=>item.property
var orderByExp = Expression.Lambda(propertyAccess, parameter);
var resultExp = Expression.Call(typeof(Queryable),
item.Value ? "OrderBy":"OrderByDescending" ,
new[] { typeof(TEntity), property.PropertyType }, query.Expression, Expression.Quote(orderByExp));
query = query.Provider.CreateQuery<TEntity>(resultExp);
});
return query;
}
public IEnumerable<TEntity> BuildSort(IEnumerable<TEntity> query)
{
if (_sortList == null || _sortList.Count == 0)
return query;
_sortList.ForEach(item =>
{
//获取表达式变量参数 item
var parameter = item.Key.Parameters[0];
//解析属性名
Expression bodyExpression = null;
if (item.Key.Body is UnaryExpression)
{
UnaryExpression unaryExpression = item.Key.Body as UnaryExpression;
bodyExpression = unaryExpression.Operand;
}
else if (item.Key.Body is MemberExpression)
{
bodyExpression = item.Key.Body;
}
else
throw new ArgumentException(@"The body of the sort predicate expression should be either UnaryExpression or MemberExpression.", "sortPredicate");
MemberExpression memberExpression = (MemberExpression)bodyExpression;
string propertyName = memberExpression.Member.Name;
//根据属性名获取属性
var property = typeof(TEntity).GetProperty(propertyName);
//创建一个访问属性的表达式 item.property
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
//创建表达式 item=>item.property
var orderByExp = Expression.Lambda(propertyAccess, parameter);
//var resultExp = Expression.Call(typeof(IEnumerable),
// item.Value ? "OrderBy" : "OrderByDescending",
// new[] { typeof(TEntity), property.PropertyType }, query.Expression, Expression.Quote(orderByExp));
// query =resultExp.Method.Invoke(query,resultExp.Arguments.ToArray()) query.Provider.CreateQuery<TEntity>(resultExp);
});
return query;
}
}
}
Ps:
比较零碎，如果有什么问题可以在下面给我留言。
其中模型创建代码中有一个_context.这个属于下个系列内容。
主要用来搭配模块化做业务垂直分库用.
重点是看设计思路，代码只是给一个演示，一般照搬是编译不过的.
文章系列的结尾会放出一个完整的设计代码和一个简单的示例.