您的位置:首页 - 教程 - .NET - 正文
数据层的设计

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.这个属于下个系列内容。
      主要用来搭配模块化做业务垂直分库用.
  重点是看设计思路,代码只是给一个演示,一般照搬是编译不过的.
      文章系列的结尾会放出一个完整的设计代码和一个简单的示例.
 


评论: