开放原子开发者工作坊

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 = 0, 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 = 30, 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 -1;
        }

        /// <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 > 0).Desc(o => new { o.ID, o.LoginCount }).Asc(o => o.GenderType).ToInfo();
                info.PassWord = "123456";

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


                var lst = context.TableSet.Where(o => o.ID > 0).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 > 0).ToList(); 

 

基地交流

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