FoxOne---一个快速高效的BS框架--数据访问（Dao）

FoxOne---一个快速高效的BS框架--(1)

FoxOne---一个快速高效的BS框架--(2)

FoxOne---一个快速高效的BS框架--(3)

FoxOne---一个快速高效的BS框架--(4)

FoxOne---一个快速高效的BS框架--WEB控件属性编辑器

FoxOne---一个快速高效的BS框架--数据访问（Dao）

数据访问组件并非本人原创，本人是在前人的代码的基础之上稍加改良。

一切都从一个Blog类开始：

先简单介绍一下上述类中各Attribute的意义

 1.Table("BL_Blog")是表明该实体对应的数据表为BL_Blog，如果表名与实体名一致，则可以不用声明；

 2.[PrimaryKey]特征表明该属性为主健；

 3.[Column(DataType="varchar",Length="300")]特征声明当前属性在创建数据库字段时对应的类型和长度；

 4.[Column(Update=false)]声明当前属性在更新时不用更新该属性；

下面我们就开始在代码中使用定义好的Blog类

------------------------------------------------------------------------------

根据实体创建表结构的代码为：

FoxOne.Data.Dao.Get().CreateTable<Blog>();

插入Blog数据的代码为：

                FoxOne.Data.Dao.Get().Insert(new Blog()
                {
                    Id = Guid.NewGuid().ToString(),
                    BrowseCount = 0,
                    Content = "world",
                    Title = "hello",
                    CreateTime = DateTime.Now,
                    CreatorId = Security.Sec.User.Id,
                    LastUpdateTime = DateTime.Now
                });

根据ID更新Blog数据的代码为：

                FoxOne.Data.Dao.Get().Update<Blog>(new Blog()
                {
                    Id = id,
                    LastUpdateTime = DateTime.Now,
                    Title = "hello1"
                });

根据当前用户ID批量更新Blog的代码为：

                FoxOne.Data.Dao.Get().BatchUpdate<Blog>(new { CreatorId = Security.Sec.User.Id }, new 
                {
                    LastUpdateTime = DateTime.Now,
                    Title = "hello1"
                });

 删除单条Blog数据：

FoxOne.Data.Dao.Get().Delete<Blog>(id);

批量删除Blog数据的代码为：

FoxOne.Data.Dao.Get().BatchDelete<Blog>(new { CreatorId=Security.Sec.User.Id});

获取单条Blog数据的代码为：

var blog = FoxOne.Data.Dao.Get().Get<Blog>(id)

 获取全部Blog数据的代码为：

var blogs = FoxOne.Data.Dao.Get().Select<Blog>();

 获取当前登陆用户创建的所有Blog数据的代码为：

var blogs = FoxOne.Data.Dao.Get().Select<Blog>(new { CreatorId = Security.Sec.User.Id });

代码中出现的Security.Sec.User是当前登陆用户的IUser对象，里面有Id,Name,Roles,Department等丰富的上下文信息可以使用。

当然传的参数也能是数组，生成的语句也变相应的变成IN

var blogs = FoxOne.Data.Dao.Get().Select<Blog>(new { BrowseCount = new int[] { 10, 20, 30 } });

自定义SQL语句查询批量Blog数据的代码为：

1.首先在配置文件中增加自定义的SQL语句

  <command key="foxone.business.blog.selectByCondition">
    <![CDATA[
        SELECT * FROM BL_Blog WHERE BrowseCount>100 AND CreatorId=#CreatorId#     
    ]]>
  </command>

2.在代码中使用定义好的语句

var blogs = FoxOne.Data.Dao.Get().QueryEntities<Blog>("foxone.business.blog.selectByCondition", new { CreatorId = Security.Sec.User.Id });

 Dao有自动从环境变量中求解值的功能，所以上面的语句又可以简化为

  <command key="foxone.business.blog.selectByCondition">
    <![CDATA[
        SELECT * FROM BL_Blog WHERE BrowseCount>100 AND CreatorId=#Env:User.Id#     
    ]]>
  </command>

 这样的代码中调用此SQL时就不用再传递CreatorId

var blogs = FoxOne.Data.Dao.Get().QueryEntities<Blog>("foxone.business.blog.selectByCondition");

 上述SQL中出现的Env环境变量是通过Unity注册进去的

ObjectHelper.RegisterType<ISqlParameters, EnvParameters>("Env");

 EnvParameters的代码如下：

    public class EnvParameters : ISqlParameters
    {
        public const string Prefix = "Env:";
        private static readonly int PrefixLength = Prefix.Length;
        public object Resolve(string name)
        {
            object value;
            return TryResolve(name, out value) ? value : null;
        }

        public bool TryResolve(string name, out object value)
        {
            if (name.ToUpper().StartsWith(Prefix.ToUpper()))
            {
                string varName = name.Substring(PrefixLength);
                return Env.TryResolve(varName, out value);
            }
            value = null;
            return false;
        }
    }

如果需要扩展更加丰富的环境变量支持，只需要实现如下接口：

namespace FoxOne.Data
{
    public interface ISqlParameters
    {
        object Resolve(string name);

        bool TryResolve(string name, out object value);
    }
}

 此外DAO支持动态SQL语句：

  <command key="foxone.business.blog.selectByCondition">
    <![CDATA[
        SELECT * FROM BL_Blog WHERE 1=1
        {? AND Title LIKE ‘%$Title$%‘  }
        {? AND CreatorId=#CreatorId#   }
        {? AND BrowseCount>#Count# }
    ]]>
  </command>

 所谓的动态SQL，就是根据你在代码中传的参数来动态接拼SQL语句

当代码中这样调用时：

var blogs = FoxOne.Data.Dao.Get().QueryEntities<Blog>("foxone.business.blog.selectByCondition");

 则执行的SQL语句为

SELECT * FROM BL_Blog WHERE 1=1

而当代码中这样调用时：

var blogs = FoxOne.Data.Dao.Get().QueryEntities<Blog>("foxone.business.blog.selectByCondition", new { Title="今天"});

 则执行的SQL语句为：

SELECT * FROM BL_Blog WHERE 1=1 AND Title LIKE ‘%今天%‘

 除此之外还可以按页获取数据

                var blogs = FoxOne.Data.Dao.Get().PageQueryEntities<Blog>(
                    "foxone.business.blog.selectByCondition", 
                    1, 
                    10, 
                    "CreateTime DESC", 
                    new { Title = "今天" });

 所有DAO自动生成的SQL都会自动兼容不同的数据库产品，自定义的SQL则可以存在不同后缀名的config文件中，Blog.Oracle.Config文件中的SQL都是给Oracle环境下使用的，Blog.MySQL.config文件中的SQL都是在MYSQL环境下使用的。

 最后DAO还有查询其它类型的结果的方法，如下：

        /// <summary>
        /// 查询多条数据，并以IDataReader返回
        /// </summary>
        /// <param name="sql">select sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以IDataReader返回结果集</returns>
        public abstract IDataReader QueryReader(string sql, object parameters = null);

        /// <summary>
        /// 查询多条数据，并以DataSet返回
        /// </summary>
        /// <param name="sql">select sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以DataSet返回结果集</returns>
        public abstract DataSet QueryDataSet(string sql, object parameters = null);

        /// <summary>
        /// 查询多条数据，并以IDictionary为元素的IList返回
        /// </summary>
        /// <param name="sql">select sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以IDictionary为元素的IList返回结果集，数据不存在则返回空IList</returns>
        public abstract IList<IDictionary<string, object>> QueryDictionaries(string sql, object parameters = null);
        
        /// <summary>
        /// 查询单条数据，并以IDictionary返回
        /// </summary>
        /// <param name="sql">查询单条数据的select sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以IDictionary返回单条数据，数据不存在则返回Null</returns>
        public abstract IDictionary<string, object> QueryDictionary(string sql, object parameters = null);

        /// <summary>
        /// 查询单条数据，并以实体类返回
        /// </summary>
        /// <typeparam name="T">实体类类型</typeparam>
        /// <param name="sql">查询单条数据的select sql语句（字段名必须与实体类属性名一致）</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以实体类返回单条数据，数据不存在则返回Null</returns>
        public abstract T QueryEntity<T>(string sql, object parameters = null) where T : class, new();

        /// <summary>
        /// 查询单条数据，并以实体类返回
        /// </summary>
        /// <typeparam name="T">实体类类型</typeparam>
        /// <param name="type">实体类接口</param>
        /// <param name="sql">查询单条数据的select sql语句（字段名必须与实体类属性名一致）</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以实体类返回单条数据，数据不存在则返回Null</returns>
        public abstract T QueryEntity<T>(Type type, string sql, object parameters = null);

        /// <summary>
        /// 执行select sql语句，检查是否有数据返回
        /// </summary>
        /// <param name="sql">select sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>True有数据 false没有数据</returns>
        public abstract bool Exists(string sql, object parameters = null);

        /// <summary>
        /// 查询单条数据的单个字段
        /// </summary>
        /// <typeparam name="T">单个字段的返回类型</typeparam>
        /// <param name="sql">查询单个字段的sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以指定的类型返回制定字段。在查询出来字段值为空的情况时，如果指定以string或其他类型返回，则返回null，如果以int等数值型类型返回，则返回0</returns>
        public abstract T QueryScalar<T>(string sql, object parameters = null);

        /// <summary>
        /// 查询多条数据的单个字段
        /// </summary>
        /// <typeparam name="T">单个字段的返回类型</typeparam>
        /// <param name="sql">查询多条数据单个字段的sql语句</param>
        /// <param name="parameters">普通Object或者IDictionary，分别通过属性名和Key与sql中的参数名匹配</param>
        /// <returns>以制定元素的IList返回多条数据的单个字段，数据不存在在返回空IList</returns>
        public abstract IList<T> QueryScalarList<T>(string sql, object parameters = null);