关于Farseer.net轻量级ORM开源框架 V1.0 概念版本开发的消息

V0.2版的开源距离今天（05年03月）已有近3年的时间。可以说这个版本已经有点落伍的感觉了，呵呵。

V0.2版至今一直处于BUG的修复及一些细小功能的增加，所以版本号上一直没有变化。

其实在这1、2年中，我一直在想着Farseer.Net 的未来发展状况。有尝试用EF的核心、也有想过用NHibernate的核心。仅仅是在这些核心的基础下做二次开发，以个人编码的经验从客户端调用角度进行“优化”，但总是感觉缺少点什么？没错，就是缺少研发精神，缺少属于Farseer.Net独特的一面，有种寄人（第三方框架）篱下的感觉。所以决定还是完全采用自己的编码吧。当然在一些处理手法上，也会尝试去学习他们的优点。

V1.0目标

本次V1.0的升级，是一个质的改变，（尽可能不改变客户端调用）

1. 完全重写内核代码（FS.Core）；
2. 以面向接口的设计模式进行编写。
3. 实现批量SQL的传输（相对V0.2，是每一条SQL就与数据库交互的）。
4. 实现延迟加载。
5. 内置内存数据库。（有时候为了做一些小尝试，没必要去专门创建一个数据库，或者无法联网的情况下）
6. 考虑到可能有些人只用到本框架ORM部份，因此非必要的代码，独立为一个类库，按实现需要附加。
7. 分离表、存储过程、视图。
8. Farseer.Net未提供到的一些SQL高级运用，支持自定义SQL。
9. 更易于扩展新的SQL的方法。（比如V0.2中，GroupBy/Join是未支持的。需要支持的话，对于V0.2来说，是比较困难的（维护））。
10. 提供与V0.2方式一样的数据访问以外，增加数据仓库的方式。第三条说到的批量SQL，是将执行中的SQL，加到组队列中（SQL被暂存到每个队列中，来等待被执行）

这10条中的每一条要实现都是比较困难的，暂时计划是2015年4月初有一个比较完整的版本出来。

不了解Farseer.Net 的朋友，可以看看V0.2的教程。其实目前优秀的ORM框架不胜其数，Farseer.Net开源仅是为了让大家学习了解一般的ORM框架的实现。从中希望大家对里在面代码不科学地方，多提出来。让大家一同进步。

开源地址：GitHub

下面，放上目前框架中片断代码，有兴趣的朋友，可以到GitHub处下载。目前框架完全托管在GitHub中。并且我将每天进行不间断的更新。

代码片断

 using System;
 using FS.Configs;
 using FS.Core.Data;

 namespace FS.Core.Context
 {
     /// <summary>
     /// 表上下文
     /// </summary>
     public class TableContext : IDisposable
     {
         /// <summary>
         /// 通过数据库配置，连接数据库
         /// </summary>
         /// <param name="dbIndex">数据库选项</param>
         /// <param name="tableName">表名称</param>
         protected internal TableContext(int dbIndex = , string tableName = null) : this(DbFactory.CreateConnString(dbIndex), DbConfigs.ConfigInfo.DbList[dbIndex].DataType, DbConfigs.ConfigInfo.DbList[dbIndex].CommandTimeout, tableName) { }

         /// <summary>
         /// 通过自定义数据链接符，连接数据库
         /// </summary>
         /// <param name="connectionString">数据库连接字符串</param>
         /// <param name="dbType">数据库类型</param>
         /// <param name="commandTimeout">SQL执行超时时间</param>
         /// <param name="tableName">表名称</param>
         protected internal TableContext(string connectionString, DataBaseType dbType = DataBaseType.SqlServer, int commandTimeout = , string tableName = null) : this(new DbExecutor(connectionString, dbType, commandTimeout), tableName) { }

         /// <summary>
         /// 事务
         /// </summary>
         /// <param name="database">数据库执行</param>
         /// <param name="tableName">表名称</param>
         protected internal TableContext(DbExecutor database, string tableName = null)
         {
             Database = database;
             TableName = tableName;
             IsMergeCommand = true;
         }

         /// <summary>
         /// 数据库
         /// </summary>
         internal protected DbExecutor Database { get; private set; }

         /// <summary>
         /// 合并执行命令
         /// </summary>
         internal protected bool IsMergeCommand { get; set; }

         /// <summary>
         /// 表名
         /// </summary>
         internal protected string TableName { get; protected set; }

         /// <summary>
         /// 保存修改
         /// IsMergeCommand=true时：只提交一次SQL到数据库
         /// </summary>
         public int SaveChanges()
         {
             return -;
         }

         /// <summary>
         /// 释放资源
         /// </summary>
         public void Dispose()
         {
             Database.Dispose();
             Database = null;
         }
     }
 }

 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using FS.Core.Infrastructure;

 namespace FS.Core.Context
 {
     public class TableSet<TEntity> : IDisposable where TEntity : class, new()
     {
         /// <summary>
         /// 数据库上下文
         /// </summary>
         private TableContext<TEntity> _dbContext;

         /// <summary>
         /// 禁止外部实例化
         /// </summary>
         private TableSet() { }

         internal TableSet(TableContext<TEntity> dbContext) : this()
         {
             _dbContext = dbContext;
             QueryProvider = DbFactory.CreateQuery(_dbContext);
         }

         /// <summary>
         /// 数据库查询支持
         /// </summary>
         private IQuery QueryProvider { get; set; }

         /// <summary>
         ///     字段选择器
         /// </summary>
         /// <param name="select">字段选择器</param>
         public TableSet<TEntity> Select<T>(Expression<Func<TEntity, T>> select)
         {
             //QueryProvider.QueryQueue.ExpSelect = QueryProvider.QueryQueue.ExpSelect == null ? QueryProvider.QueryQueue.ExpSelect = select : Expression.Add(QueryProvider.QueryQueue.ExpSelect, select);
             return this;
         }

         /// <summary>
         ///     查询条件
         /// </summary>
         /// <param name="where">查询条件</param>
         public TableSet<TEntity> Where(Expression<Func<TEntity, bool>> where)
         {
             //QueryProvider.QueryQueue.ExpWhere = QueryProvider.QueryQueue.ExpWhere == null ? QueryProvider.QueryQueue.ExpWhere = where : Expression.Add(QueryProvider.QueryQueue.ExpWhere, where);
             return this;
         }

         public TableSet<TEntity> Desc<TKey>(Expression<Func<TEntity, TKey>> desc)
         {
             //QueryProvider.QueryQueue.ExpOrderBy = QueryProvider.QueryQueue.ExpOrderBy == null ? QueryProvider.QueryQueue.ExpOrderBy = desc : Expression.Add(QueryProvider.QueryQueue.ExpOrderBy, desc);
             return this;
         }

         public TableSet<TEntity> Asc<TKey>(Expression<Func<TEntity, TKey>> asc)
         {
             //QueryProvider.QueryQueue.ExpOrderBy = QueryProvider.QueryQueue.ExpOrderBy == null ? QueryProvider.QueryQueue.ExpOrderBy = asc : Expression.Add(QueryProvider.QueryQueue.ExpOrderBy, asc);
             return this;
         }
         public List<TEntity> ToList()
         {
             return QueryProvider.QueryQueue.List.Query<TEntity>();
         }

         public TEntity ToInfo()
         {
             return QueryProvider.QueryQueue.Info.Query<TEntity>();
         }

         public TEntity Update(TEntity entity)
         {
             QueryProvider.QueryQueue.Update.Query(entity);
             return entity;
         }

         public int Delete()
         {
             return QueryProvider.QueryQueue.Delete.Query<TEntity>();
         }

         public TEntity Insert(TEntity entity)
         {
             QueryProvider.QueryQueue.Insert.Query(entity);
             return entity;
         }

         public void Dispose()
         {
             throw new NotImplementedException();
         }
     }
 }

 using System.Collections.Generic;
 using FS.Core.Context;
 using FS.Core.Infrastructure;

 namespace FS.Core.Client.SqlServer
 {
     public class SqlServerQuery : IQuery
     {
         /// <summary>
         /// 组列表
         /// </summary>
         private List<IQueryQueue> GroupQueryQueueList { get; set; }

         public SqlServerQuery(TableContext tableContext)
         {
             TableContext = tableContext;
             Init();
         }

         public TableContext TableContext { get; private set; }
         public IQueryQueue QueryQueue { get; set; }

         public void Execute()
         {
             GroupQueryQueueList.Add(QueryQueue);
             Init();
         }

         public void Init()
         {
             QueryQueue = new SqlServerQueryQueue(this);
             if (GroupQueryQueueList == null) { GroupQueryQueueList = new List<IQueryQueue>(); }
         }
     }
 }

 using System.Linq.Expressions;
 using System.Text;
 using FS.Core.Client.SqlServer.Query;
 using FS.Core.Infrastructure;
 using FS.Core.Infrastructure.Query;

 namespace FS.Core.Client.SqlServer
 {
     public class SqlServerQueryQueue : IQueryQueue
     {
         private readonly IQuery _queryProvider;
         public Expression ExpOrderBy { get; set; }
         public Expression ExpSelect { get; set; }
         public Expression ExpWhere { get; set; }
         public StringBuilder Sql { get; set; }
         public SqlServerQueryQueue(IQuery queryProvider)
         {
             _queryProvider = queryProvider;
         }

         private IQueryQueueList _list;
         public IQueryQueueList List { get { return _list ?? (_list = new SqlServerQueryList(_queryProvider)); } }

         private IQueryQueueInfo _info;
         public IQueryQueueInfo Info { get { return _info ?? (_info = new SqlServerQueryInfo(_queryProvider)); } }

         private IQueryQueueInsert _insert;
         public IQueryQueueInsert Insert { get { return _insert ?? (_insert = new SqlServerQueryInsert(_queryProvider)); } }

         private IQueryQueueUpdate _update;
         public IQueryQueueUpdate Update { get { return _update ?? (_update = new SqlServerQueryUpdate(_queryProvider)); } }

         private IQueryQueueDelete _delete;
         public IQueryQueueDelete Delete { get { return _delete ?? (_delete = new SqlServerQueryDelete(_queryProvider)); } }

         public void Dispose()
         {
             Sql.Clear();
             ExpOrderBy = null;
             ExpSelect = null;
             ExpWhere = null;
             Sql = null;
             _list = null;
             _info = null;
             _insert = null;
             _update = null;
             _delete = null;
         }
     }
 }

可能当你看到以上代码时，已经是陈旧了。关注最新代码，请到GitHub中。

客户端调用

             using (var context = new TableContext<UserPO>())
             {
                 var info = context.TableSet.Where(o => o.ID > ).Desc(o => new { o.ID, o.LoginCount }).Asc(o => o.GenderType).ToInfo();
                 info.PassWord = "";

                 context.TableSet.Update(info);
                 context.TableSet.Insert(info);

                 var lst = context.TableSet.Where(o => o.ID > ).Desc(o => new { o.ID, o.LoginCount }).Asc(o => o.GenderType).ToList();

                 context.SaveChanges();
             }

TableContext<UserPO>.Data.Select(o => o.ID).Where(o => o.ID > ).ToList();

基地交流

QQ群：116228666 (Farseer.net开源框架交流) 请注明：Farseer.Net