博客园_faib的技术专栏

Fireasy.Data系列——数据库架构的整合查询

2012-04-21T16:28:00Z

在Ado.Net中，DbConnection类的GetSchema方法用于获取数据库提供者的相关架构信息，比如数据类型、表、列等等，然而每种数据库架构的元数据结构都是不一样的。Fireasy.Data提供了一个扩展服务接口，以将四类数据库的架构信息整合在一起，统一定义了最大公有的架构元数据，并在此基础上提供Linq查询的支持。

一、架构元数据的接口

由于要使用统一的查询，因此需要定义一个标识接口，然后使不同的架构元数据类来实现它。

    /// <summary>
    /// 数据库架构元数据结构。
    /// </summary>
    public interface ISchemaMetadata
    {
    }

二、架构集合的枚举

首先定义要支持的架构的类别，基本上每一种数据库都支持以下的这些集合名称。

    /// <summary>
    /// 数据库架构集合的类别。
    /// </summary>
    public enum SchemaCategory
    {
        /// <summary>
        /// 所有定义的列的有关信息。
        /// </summary>
        Columns,
        /// <summary>
        /// 所支持的数据类型的有关信息。
        /// </summary>
        DataTypes,
        /// <summary>
        /// 所有定义的外键的有关信息。
        /// </summary>
        ForeignKeys,
        /// <summary>
        /// 作为索引的列的有关信息。
        /// </summary>
        Indexes,
        /// <summary>
        /// 所有定义的索引相关列的有关信息。
        /// </summary>
        IndexColumns,
        /// <summary>
        /// 所有架构集合的有关信息。
        /// </summary>
        MetaDataCollections,
        /// <summary>
        /// 所有定义的存储过程的有关信息。
        /// </summary>
        Procedures,
        /// <summary>
        /// 存储过程中所有参数的有关信息。
        /// </summary>
        ProcedureParameters,
        /// <summary>
        /// 数据库公开所保留的关键字的有关信息。
        /// </summary>
        ReservedWords,
        /// <summary>
        /// 所支持的限制的有关信息。
        /// </summary>
        Restrictions,
        /// <summary>
        /// 所有定义的表的有关信息。
        /// </summary>
        Tables,
        /// <summary>
        /// 数据库所定义的用户的有关信息。
        /// </summary>
        Users,
        /// <summary>
        /// 所有定义的视图的有关信息。
        /// </summary>
        Views,
        /// <summary>
        /// 视图所定义的列的有关信息。
        /// </summary>
        ViewColumns
    }

三、架构元数据类

有了以上两个后，就可以定义具体的架构元数据类了，比如Table：

    /// <summary>
    /// 数据库表信息。
    /// </summary>
    [SchemaCategory(SchemaCategory.Tables)]
    public sealed class Table : ISchemaMetadata
    {
        /// <summary>
        /// 获取分录名称。
        /// </summary>
        [SchemaQueryableAttribute(0, ProviderType.MsSql)]
        [SchemaQueryableAttribute(0, ProviderType.SQLite)]
        [SchemaQueryableAttribute(0, ProviderType.MySql)]
        public string TableCatalog { get; internal set; }

        /// <summary>
        /// 获取架构名称。
        /// </summary>
        [SchemaQueryableAttribute(1, ProviderType.MsSql)]
        [SchemaQueryableAttribute(0, ProviderType.Oracle)]
        [SchemaQueryableAttribute(1, ProviderType.MySql)]
        public string TableSchema { get; internal set; }

        /// <summary>
        /// 获取表名称。
        /// </summary>
        [SchemaQueryableAttribute(2, ProviderType.MsSql)]
        [SchemaQueryableAttribute(1, ProviderType.Oracle)]
        [SchemaQueryableAttribute(2, ProviderType.SQLite)]
        [SchemaQueryableAttribute(2, ProviderType.MySql)]
        public string TableName { get; internal set; }

        /// <summary>
        /// 获取表类型。
        /// </summary>
        [SchemaQueryableAttribute(3, ProviderType.MsSql)]
        [SchemaQueryableAttribute(3, ProviderType.SQLite)]
        [SchemaQueryableAttribute(3, ProviderType.MySql)]
        public string TableType { get; internal set; }

        /// <summary>
        /// 获取表的描述。
        /// </summary>
        public string Description { get; internal set; }
    }

在以上的代码中，分别用到了两个特性，SchemaCategoryAttribute标识了该类所属的架构类别，使用特性的目的，在于避免使用字符串，这个将在后面介绍。

另一个特性SchemaQueryableAttribute特性则是定义了元数据属性在查询限制数组中的索引位置，因为每一种数据库类型对于同一个属性所限制的位置是不同的，因此需要为每一种数据库类别定义一个特性。

四、架构扩展服务类

首先定义一个抽象类，对底层的处理进行封装，然后开放每一类架构的信息获取方法出来，不同的数据库类型再进行重写，以使信息之间一一对应。

    /// <summary>
    /// 一个抽象类，提供获取数据库架构的方法。
    /// </summary>
    public abstract class BaseSchema : ISchemaProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 获取指定类型的数据库架构信息。
        /// </summary>
        /// <typeparam name="T">架构信息的类型。</typeparam>
        /// <param name="predicate">用于测试架构信息是否满足条件的函数。</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetSchemas<T>(Expression<Func<T, bool>> predicate = null) where T : ISchemaMetadata
        {
            var category = GetSchemaCategory<T>();
            var restrictionValues = SchemaQueryTranslator.GetRestriction(ServiceContext.Database.Provider.ProviderType, typeof(T), predicate);
            DataTable table;

            using (var connection = ServiceContext.Database.CreateConnection())
            {
                var collectionName = GetSchemaCategoryName(category);
                try
                {
                    connection.TryOpen();
                    table = connection.GetSchema(collectionName, InitRestrictionValues(connection, category, restrictionValues));
                }
                catch (Exception ex)
                {
                    throw new SchemaNotSupportedtException(collectionName, ex);
                }
                finally
                {
                    connection.TryClose();
                }
            }
            return ReturnSchemaElements<T>(category, table);
        }

        /// <summary>
        /// 获取指定类型的数据库架构信息。
        /// </summary>
        /// <param name="collectionName">架构信息类别名称。</param>
        /// <param name="restrictionValues">列限制数组。</param>
        /// <returns></returns>
        public virtual DataTable GetSchema(string collectionName, string[] restrictionValues)
        {
            DataTable table;
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                connection.TryOpen();
                table = connection.GetSchema(collectionName, restrictionValues);
                connection.TryClose();
            }
            return table;
        }
    }

在以上的代码中，第一步：使用GetSchemaCategoryName方法获得Ado.Net中所支持集合名称，如Tables、Columns。

        /// 获取架构的名称。
        /// </summary>
        /// <param name="category">架构信息类别。</param>
        /// <returns></returns>
        protected virtual string GetSchemaCategoryName(SchemaCategory category)
        {
            return category.ToString();
        }

如果集合名称不是使用枚举的名称，则在具体的子类中重写这个方法指定就可以了。

第二步，使用SchemaQueryTranslator类对传入的Linq查询表达式进行解析，得到原生的restrictionValues，这个数组作为connection.GetSchema方法的第二个参数传入。

第三步，对查询得到的DataTable进行解析，返回我们需要的IEnumerable<T>序列：

        private IEnumerable<T> ReturnSchemaElements<T>(SchemaCategory category, DataTable table)
        {
            IEnumerable @enum = null;
            switch (category)
            {
                case SchemaCategory.Columns:
                    @enum = GetColumns(table, null);
                    break;
                case SchemaCategory.DataTypes:
                    @enum = GetDataTypes(table, null);
                    break;
                case SchemaCategory.ForeignKeys:
                    @enum = GetForeignKeys(table, null);
                    break;
                case SchemaCategory.IndexColumns:
                    @enum = GetIndexColumns(table, null);
                    break;
                case SchemaCategory.Indexes:
                    @enum = GetIndexs(table, null);
                    break;
                case SchemaCategory.MetaDataCollections:
                    @enum = GetMetaDataCollections(table, null);
                    break;
                case SchemaCategory.ProcedureParameters:
                    @enum = GetProcedureParameters(table, null);
                    break;
                case SchemaCategory.Procedures:
                    @enum = GetProcedures(table, null);
                    break;
                case SchemaCategory.ReservedWords:
                    @enum = GetReservedWords(table, null);
                    break;
                case SchemaCategory.Restrictions:
                    @enum = GetRestrictions(table, null);
                    break;
                case SchemaCategory.Tables:
                    @enum = GetTables(table, null);
                    break;
                case SchemaCategory.Users:
                    @enum = GetUsers(table, null);
                    break;
                case SchemaCategory.ViewColumns:
                    @enum = GetViewColumns(table, null);
                    break;
                case SchemaCategory.Views:
                    @enum = GetViews(table, null);
                    break;
            }

            if (@enum != null)
            {
                foreach (var item in @enum)
                {
                    yield return (T)item;
                }
            }
        }

每一个初始架构信息的方法都定义成了虚方法了，因此在子类中还可以进行信息的转换，就象在OracleSchema中，我们可以对Table的信息进行丰富，增加了获取表描述信息的提取：

        /// <summary>
        /// 获取 <see cref="Table"/> 元数据序列。
        /// </summary>
        /// <param name="table">架构信息的表。</param>
        /// <param name="action">用于填充元数据的方法。</param>
        /// <returns></returns>
        protected override IEnumerable<Table> GetTables(DataTable table, Action<Table, DataRow> action)
        {
            foreach (DataRow row in table.Rows)
            {
                var item = new Table
                    {
                        TableSchema = row["OWNER"].ToString(),
                        TableName = row["TABLE_NAME"].ToString(),
                        TableType = row["TYPE"].ToString()
                    };
                item.Description = OracleSchemaHelper.GetTableDescription(ServiceContext.Database, item.TableSchema, item.TableSchema);

                if (action != null)
                {
                    action(item, row);
                }
                yield return item;
            }
        }

五、架构查询的表达式解析类

其实本篇的重点在于此类，它对传入查询的表达式进行解析，并返回一个限制数组，如果你对表达式有所了解，相信一看就明白其中的原理了。

    internal sealed class SchemaQueryTranslator : Common.Linq.Expressions.ExpressionVisitor
    {
        private Dictionary<int, string> m_dic;
        private int m_index = -1;
        private int m_maxIndex;
        private readonly Type m_metadataType;
        private readonly ProviderType m_providerType;

        public SchemaQueryTranslator(ProviderType providerType, Type metadataType)
        {
            m_providerType = providerType;
            m_metadataType = metadataType;
            InitDictionary();
        }

        /// <summary>
        /// 对表达式进行解析，并返回限制数组。
        /// </summary>
        /// <param name="providerType">数据提供者类别。</param>
        /// <param name="metadataType">架构元数组类型。</param>
        /// <param name="expression">查询表达式。</param>
        /// <returns></returns>
        public static string[] GetRestriction(ProviderType providerType, Type metadataType, Expression expression)
        {
            var translator = new SchemaQueryTranslator(providerType, metadataType);
            return translator.GetRestrictionValues(expression);
        }

        private string[] GetRestrictionValues(Expression expression)
        {
            if (expression != null)
            {
                Visit(expression);
            }
            return TrimEmptyArray();
        }

        /// <summary>
        /// 初始化字典，找出架构元数据类中定义了 <see cref="SchemaQueryableAttribute"/> 特性的所有属性。
        /// </summary>
        private void InitDictionary()
        {
            m_dic = new Dictionary<int, string>();
            var properties = m_metadataType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (var property in properties)
            {
                var attribute = property.GetCustomAttributes<SchemaQueryableAttribute>().FirstOrDefault(s => s.ProviderType == m_providerType);
                if (attribute == null)
                {
                    continue;
                }
                //使用索引作为键值
                m_dic.Add(attribute.Index, null);
            }
        }

        /// <summary>
        /// 访问表达式树。
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        protected override Expression Visit(Expression expression)
        {
            switch (expression.NodeType)
            {
                case ExpressionType.MemberAccess:
                    return VisitMember((MemberExpression)expression);
                case ExpressionType.Equal:
                    return VisitBinary((BinaryExpression)expression);
                case ExpressionType.Constant:
                    return VisitConstant((ConstantExpression)expression);
            }
            return base.Visit(expression);
        }

        /// <summary>
        /// 访问二元运算表达式。
        /// </summary>
        /// <param name="binaryExp"></param>
        /// <returns></returns>
        protected override Expression VisitBinary(BinaryExpression binaryExp)
        {
            //属性在运算符的右边
            var memberExp = binaryExp.Right as MemberExpression;
            if (memberExp != null &&
                memberExp.Member.DeclaringType == m_metadataType)
            {
                Visit(binaryExp.Right);
                Visit(binaryExp.Left);
            }
            else
            {
                Visit(binaryExp.Left);
                Visit(binaryExp.Right);
            }
            //复位
            m_index = -1;
            return binaryExp;
        }

        protected override Expression VisitMember(MemberExpression memberExp)
        {
            //如果属性是架构元数据类的成员
            if (memberExp.Member.DeclaringType == m_metadataType)
            {
                var attribute = memberExp.Member.GetCustomAttributes<SchemaQueryableAttribute>().FirstOrDefault(s => s.ProviderType == m_providerType);
                if (attribute == null)
                {
                    throw new SchemaQueryNotSupportedException(memberExp.Member.Name);
                }
                //记录下当前的索引，以及目前的最大索引
                m_index = attribute.Index;
                m_maxIndex = Math.Max(m_maxIndex, m_index + 1);
                return memberExp;
            }
            else
            {
                //值或引用
                var exp = (Expression)memberExp;
                if (memberExp.Type.IsValueType)
                {
                    exp = Expression.Convert(memberExp, typeof(object));
                }
                var lambda = Expression.Lambda<Func<object>>(exp);
                var fn = lambda.Compile();
                //转换为常量表达式
                return Visit(Expression.Constant(fn(), memberExp.Type));
            }
        }

        protected override Expression VisitConstant(ConstantExpression constExp)
        {
            if (m_index == -1)
            {
                return constExp;
            }
            //没有复位的情况下，记录值
            m_dic[m_index] = constExp.Value.ToString();
            return constExp;
        }

        /// <summary>
        /// 删除空的数据元素
        /// </summary>
        /// <returns></returns>
        private string[] TrimEmptyArray()
        {
            //最大范围
            var array = new string[m_maxIndex];
            for (var i = 0; i < m_maxIndex; i++)
            {
                if (m_dic.ContainsKey(i))
                {
                    array[i] = m_dic[i];
                }
            }
            return array;
        }
    }

六、测试

没有条件的架构查询：

        [Test]
        public void GetTables()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var schema = database.Provider.GetService<ISchemaProvider>();
                        foreach (var table in schema.GetSchemas<Table>())
                        {
                            PrintSchema(table);
                        }
                        Console.WriteLine();
                    })));
        }

使用表达式的架构查询：

        [Test]
        public void GetTablesQuery()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var schema = database.Provider.GetService<ISchemaProvider>();
                        foreach (var table in schema.GetSchemas<Table>(s => s.TableName == "products"))
                        {
                            PrintSchema(table);
                        }
                        Console.WriteLine();
                    })));
        }

当然，虽然在一定程度上解决了架构查询的问题，但是仍然在于一些缺陷，主要表达在数据库之间一些微妙的差别，比如oracle的大小写敏感问题，以及它是使用owner，而sqlserver使用schema，因此还有改进的空间。

本文链接

Fireasy.Data系列——数据库提供者的插件服务簇

2012-04-18T16:54:00Z

前面已经介绍了，IProvider提供了一种插件式的服务接口，能够将一些扩展的功能附加在提供者中，因为IProvider由IDatabase所引用，因此，只要有IDatabase，就能够获得所有的扩展功能，那么本篇将介绍一下这些扩展服务如何与IProvider一起工作。

首先看一下IProvider接口的定义：

    /// <summary>
    /// 为不同的数据库类型提供创建工厂及插件服务。
    /// </summary>
    public interface IProvider
    {
        /// <summary>
        /// 获取提供者类型。
        /// </summary>
        ProviderType ProviderType { get; }

        /// <summary>
        /// 获取数据库提供者工厂。
        /// </summary>
        DbProviderFactory DbProviderFactory { get; }

        /// <summary>
        /// 获取相应的插件服务。
        /// </summary>
        /// <typeparam name="T">插件类型。</typeparam>
        /// <returns></returns>
        T GetService<T>() where T : IProviderService;
        /// <summary>
        /// 附加一个插件服务。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="service"></param>
        /// <param name="overlay"></param>
        void RegisterService<T>(T service, bool overlay = false) where T : IProviderService;
        /// <summary>
        /// 初始化所有插件服务。
        /// </summary>
        /// <param name="action"></param>
        void Initialize(Action<IProviderService> action);
        /// <summary>
        /// 获取所有插件服务。
        /// </summary>
        /// <returns></returns>
        IEnumerable<IProviderService> GetServices();

        /// <summary>
        /// 获取当前连接的参数。
        /// </summary>
        /// <returns></returns>
        ConnectionParameter GetConnectionParameter(ConnectionString connectionString);

    }

本文着重关心的是IProviderServices的相关实现细节，因此其他内容不再赘述。

接下来定义一个实现类，当然也是一个抽象类，具体还要由相应的数据库提供者来实现。

    /// <summary>
    /// 基本的数据库提供者。
    /// </summary>
    public abstract class BaseProvider : IProvider
    {
        private readonly Dictionary<string, IProviderService> m_plugs = new Dictionary<string, IProviderService>();

        /// <summary>
        /// 表示 <see cref="DbProviderFactory"/> 对象。
        /// </summary>
        protected DbProviderFactory Factory;
        private Action<IProviderService> m_action;

        /// <summary>
        /// 初始化 <see cref="BaseProvider"/> 类的新实例。
        /// </summary>
        protected BaseProvider()
        {
        }

        /// <summary>
        /// 使用提供者名称初始化 <see cref="BaseProvider"/> 类的新实例。
        /// </summary>
        /// <param name="providerName"></param>
        protected BaseProvider(string providerName)
        {
            Factory = DbProviderFactories.GetFactory(providerName);
        }

        /// <summary>
        /// 获取数据提供者类型。
        /// </summary>
        public abstract ProviderType ProviderType { get; }

        /// <summary>
        /// 获取数据库提供者工厂。
        /// </summary>
        public virtual DbProviderFactory DbProviderFactory
        {
            get
            {
                if (Factory == null)
                {
                    throw new Exception("DbProviderFactory 为空，请检查 providerName 或相关的程序集是否存在。");
                }
                return Factory;
            }
        }

        /// <summary>
        /// 获取相应的插件。
        /// </summary>
        /// <typeparam name="T">插件类型。</typeparam>
        /// <returns></returns>
        public virtual T GetService<T>() where T : IProviderService
        {
            var key = typeof(T).GUID.ToString();
            if (m_plugs.ContainsKey(key))
            {
                return (T)m_plugs[key];
            }
            return default(T);
        }

        /// <summary>
        /// 附加一个插件。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="provider"></param>
        /// <param name="overwite"></param>
        public void RegisterService<T>(T provider, bool overwite = false) where T : IProviderService
        {
            var implType = provider.GetType().GetDirectImplementInterface(typeof(IProviderService));
            var key = implType.GUID.ToString();
            if (!m_plugs.ContainsKey(key))
            {
                m_plugs.Add(key, provider);
                if (m_action != null)
                {
                    m_action(provider);
                }
            }
            else if (overwite)
            {
                m_plugs[key] = provider;
                if (m_action != null)
                {
                    m_action(provider);
                }
            }
        }

        void IProvider.Initialize(Action<IProviderService> action)
        {
            if (action == null)
            {
                return;
            }
            m_action = action;
            foreach (var kvp in m_plugs)
            {
                action(kvp.Value);
            }
        }

        /// <summary>
        /// 获取所有插件服务。
        /// </summary>
        /// <returns></returns>
        IEnumerable<IProviderService> IProvider.GetServices()
        {
            return m_plugs.Select(kvp => kvp.Value);
        }

        /// <summary>
        /// 获取当前连接的参数。
        /// </summary>
        /// <returns></returns>
        public abstract ConnectionParameter GetConnectionParameter(ConnectionString connectionString);
    }

着重在于RegisterService方法，为什么要用GetDirectImplementInterface方法呢？该方法用于从类型type中获得直接继承自IProviderServices接口的接口，呵呵，这个有点不清晰吧，就用前篇提到的IBatcherProvider接口为例来说吧，IBatcherProvider继承自IProviderServices，将我们用RegisterService方法注册一个IBatcherProvider的实现类时，实际上是获得了IBatcherProvider的类型，这主要是为了方便GetService方法的使用，我们想通过IProvider获得某种扩展服务的实例时，并不需要知道具体的实现类，而是使用GetService<IBatcherProvider>()这样的方式来获取。

在不同数据库提供者的实现中，分别注册进不同的扩展服务：

    /// <summary>
    /// MsSql数据库提供者。
    /// </summary>
    public sealed class MsSqlProvider : BaseProvider
    {
        /// <summary>
        /// 提供 <see cref="MsSqlProvider"/> 的静态实例。
        /// </summary>
        public readonly static MsSqlProvider Instance = new MsSqlProvider();

        /// <summary>
        /// 初始化 <see cref="MsSqlProvider"/> 类的新实例。
        /// </summary>
        public MsSqlProvider()
            : base ("System.Data.SqlClient")
        {
            RegisterService(new MsSqlBatcher());
            RegisterService(new MsSqlSyntax());
            RegisterService(new MsSqlSchema());
            RegisterService(new MsSqlBackup());
        }
    }

然而，IProviderServices接口有一个上下文对象，该上下文是通过Initialize方法附加到扩展服务中的。在Database的构造函数中，我们可以看到：

        /// <summary>
        /// 初始化 <see cref="Database"/> 类的新实例。
        /// </summary>
        /// <param name="connectionString">数据库连接字符串。</param>
        /// <param name="provider">数据库提供者。</param>
        public Database (ConnectionString connectionString, IProvider provider)
            : this ()
        {
            Checker.ArgumentNull(provider, "provider");
            Provider = provider;
            ConnectionString = connectionString;
            var providerContext = new ServiceContext { Database = this };
            Provider.Initialize(p => p.ServiceContext = providerContext);
        }

通过委托的方式进行了初始化，当然前提是，这部份扩展服务是在提供者的构造里注册的，如果后期注册的，则在RegisterService里由m_action进行调用处理了。

这样，我们可以使用GetService来获取不同的扩展服务了：

var batcher = database.Provider.GetService<IBatcherProvider>();
var syntax = database.Provider.GetService<ISyntaxProvider>();
var schema = database.Provider.GetService<ISchemaProvider>();
var backup = database.Provider.GetService<IBackupProvider>();

本文链接

Fireasy.Data系列——几种数据库的大数据批量插入

2012-04-18T15:39:00Z

在之前只知道SqlServer支持数据批量插入，殊不知道Oracle、SQLite和MySql也是支持的，不过Oracle需要使用Orace.DataAccess驱动，今天就贴出几种数据库的批量插入解决方法。

首先说一下，IProvider里有一个用于实现批量插入的插件服务接口IBatcherProvider，此接口在前一篇文章中已经提到过了。

    /// <summary>
    /// 提供数据批量处理的方法。
    /// </summary>
    public interface IBatcherProvider : IProviderService
    {
        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        void Insert(DataTable dataTable, int batchSize = 10000);
    }

一、SqlServer数据批量插入

SqlServer的批量插入很简单，使用SqlBulkCopy就可以，以下是该类的实现：

    /// <summary>
    /// 为 System.Data.SqlClient 提供的用于批量操作的方法。
    /// </summary>
    public sealed class MsSqlBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = (SqlConnection)ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    //给表名加上前后导符
                    var tableName = DbUtility.FormatByQuote(ServiceContext.Database.Provider.GetService<ISyntaxProvider>(), dataTable.TableName);
                    using (var bulk = new SqlBulkCopy(connection, SqlBulkCopyOptions.KeepIdentity, null)
                        {
                            DestinationTableName = tableName,
                            BatchSize = batchSize
                        })
                    {
                        //循环所有列，为bulk添加映射
                        dataTable.EachColumn(c => bulk.ColumnMappings.Add(c.ColumnName, c.ColumnName), c => !c.AutoIncrement);
                        bulk.WriteToServer(dataTable);
                        bulk.Close();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }
    }

SqlBulkCopy的ColumnMappings中列的名称受大小写敏感限制，因此在构造DataTable的时候应请注意列名要与表一致。

以上没有使用事务，使用事务在性能上会有一定的影响，如果要使用事务，可以设置SqlBulkCopyOptions.UseInternalTransaction。

二、Oracle数据批量插入

System.Data.OracleClient不支持批量插入，因此只能使用Oracle.DataAccess组件来作为提供者。

    /// <summary>
    /// Oracle.Data.Access 组件提供的用于批量操作的方法。
    /// </summary>
    public sealed class OracleAccessBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    using (var command = ServiceContext.Database.Provider.DbProviderFactory.CreateCommand())
                    {
                        if (command == null)
                        {
                            throw new BatcherException(new ArgumentException("command"));
                        }
                        command.Connection = connection;
                        command.CommandText = GenerateInserSql(ServiceContext.Database, command, dataTable);
                        command.ExecuteNonQuery();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }

        /// <summary>
        /// 生成插入数据的sql语句。
        /// </summary>
        /// <param name="database"></param>
        /// <param name="command"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        private string GenerateInserSql(IDatabase database, DbCommand command, DataTable table)
        {
            var names = new StringBuilder();
            var values = new StringBuilder();
            //将一个DataTable的数据转换为数组的数组
            var data = table.ToArray();

            //设置ArrayBindCount属性
            command.GetType().GetProperty("ArrayBindCount").SetValue(command, table.Rows.Count, null);

            var syntax = database.Provider.GetService<ISyntaxProvider>();
            for (var i = 0; i < table.Columns.Count; i++)
            {
                var column = table.Columns[i];

                var parameter = database.Provider.DbProviderFactory.CreateParameter();
                if (parameter == null)
                {
                    continue;
                }
                parameter.ParameterName = column.ColumnName;
                parameter.Direction = ParameterDirection.Input;
                parameter.DbType = column.DataType.GetDbType();
                parameter.Value = data[i];

                if (names.Length > 0)
                {
                    names.Append(",");
                    values.Append(",");
                }
                names.AppendFormat("{0}", DbUtility.FormatByQuote(syntax, column.ColumnName));
                values.AppendFormat("{0}{1}", syntax.ParameterPrefix, column.ColumnName);

                command.Parameters.Add(parameter);
            }
            return string.Format("INSERT INTO {0}({1}) VALUES ({2})", DbUtility.FormatByQuote(syntax, table.TableName), names, values);
        }
    }

以上最重要的一步，就是将DataTable转为数组的数组表示，即object[][]，前数组的上标是列的个数，后数组是行的个数，因此循环Columns将后数组作为Parameter的值，也就是说，参数的值是一个数组。而insert语句与一般的插入语句没有什么不一样。

三、SQLite数据批量插入

SQLite的批量插入只需开启事务就可以了，这个具体的原理不得而知。

    public sealed class SQLiteBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                DbTransaction transcation = null;
                try
                {
                    connection.TryOpen();
                    transcation = connection.BeginTransaction();
                    using (var command = ServiceContext.Database.Provider.DbProviderFactory.CreateCommand())
                    {
                        if (command == null)
                        {
                            throw new BatcherException(new ArgumentException("command"));
                        }
                        command.Connection = connection;

                        command.CommandText = GenerateInserSql(ServiceContext.Database, dataTable);
                        if (command.CommandText == string.Empty)
                        {
                            return;
                        }

                        var flag = new AssertFlag();
                        dataTable.EachRow(row =>
                            {
                                var first = flag.AssertTrue();
                                ProcessCommandParameters(dataTable, command, row, first);
                                command.ExecuteNonQuery();
                            });
                    }
                    transcation.Commit();
                }
                catch (Exception exp)
                {
                    if (transcation != null)
                    {
                        transcation.Rollback();
                    }
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }

        private void ProcessCommandParameters(DataTable dataTable, DbCommand command, DataRow row, bool first)
        {
            for (var c = 0; c < dataTable.Columns.Count; c++)
            {
                DbParameter parameter;
                //首次创建参数，是为了使用缓存
                if (first)
                {
                    parameter = ServiceContext.Database.Provider.DbProviderFactory.CreateParameter();
                    parameter.ParameterName = dataTable.Columns[c].ColumnName;
                    command.Parameters.Add(parameter);
                }
                else
                {
                    parameter = command.Parameters[c];
                }
                parameter.Value = row[c];
            }
        }

        /// <summary>
        /// 生成插入数据的sql语句。
        /// </summary>
        /// <param name="database"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        private string GenerateInserSql(IDatabase database, DataTable table)
        {
            var syntax = database.Provider.GetService<ISyntaxProvider>();
            var names = new StringBuilder();
            var values = new StringBuilder();
            var flag = new AssertFlag();
            table.EachColumn(column =>
                {
                    if (!flag.AssertTrue())
                    {
                        names.Append(",");
                        values.Append(",");
                    }
                    names.Append(DbUtility.FormatByQuote(syntax, column.ColumnName));
                    values.AppendFormat("{0}{1}", syntax.ParameterPrefix, column.ColumnName);
                });
            return string.Format("INSERT INTO {0}({1}) VALUES ({2})", DbUtility.FormatByQuote(syntax, table.TableName), names, values);
        }
    }

四、MySql数据批量插入

    /// <summary>
    /// 为 MySql.Data 组件提供的用于批量操作的方法。
    /// </summary>
    public sealed class MySqlBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    using (var command = ServiceContext.Database.Provider.DbProviderFactory.CreateCommand())
                    {
                        if (command == null)
                        {
                            throw new BatcherException(new ArgumentException("command"));
                        }
                        command.Connection = connection;

                        command.CommandText = GenerateInserSql(ServiceContext.Database, command, dataTable);
                        if (command.CommandText == string.Empty)
                        {
                            return;
                        }
                        command.ExecuteNonQuery();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }

        /// <summary>
        /// 生成插入数据的sql语句。
        /// </summary>
        /// <param name="database"></param>
        /// <param name="command"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        private string GenerateInserSql(IDatabase database, DbCommand command, DataTable table)
        {
            var names = new StringBuilder();
            var values = new StringBuilder();
            var types = new List<DbType>();
            var count = table.Columns.Count;
            var syntax = database.Provider.GetService<ISyntaxProvider>();
            table.EachColumn(c =>
                {
                    if (names.Length > 0)
                    {
                        names.Append(",");
                    }
                    names.AppendFormat("{0}", DbUtility.FormatByQuote(syntax, c.ColumnName));
                    types.Add(c.DataType.GetDbType());
                });

            var i = 0;
            foreach (DataRow row in table.Rows)
            {
                if (i > 0)
                {
                    values.Append(",");
                }
                values.Append("(");
                for (var j = 0; j < count; j++)
                {
                    if (j > 0)
                    {
                        values.Append(", ");
                    }
                    var isStrType = IsStringType(types[j]);
                    var parameter = CreateParameter(database.Provider, isStrType, types[j], row[j], syntax.ParameterPrefix, i, j);
                    if (parameter != null)
                    {
                        values.Append(parameter.ParameterName);
                        command.Parameters.Add(parameter);
                    }
                    else if (isStrType)
                    {
                        values.AppendFormat("'{0}'", row[j]);
                    }
                    else
                    {
                        values.Append(row[j]);
                    }
                }
                values.Append(")");
                i++;
            }
            return string.Format("INSERT INTO {0}({1}) VALUES {2}", DbUtility.FormatByQuote(syntax, table.TableName), names, values);
        }

        /// <summary>
        /// 判断是否为字符串类别。
        /// </summary>
        /// <param name="dbType"></param>
        /// <returns></returns>
        private bool IsStringType(DbType dbType)
        {
            return dbType == DbType.AnsiString || dbType == DbType.AnsiStringFixedLength || dbType == DbType.String || dbType == DbType.StringFixedLength;
        }

        /// <summary>
        /// 创建参数。
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="isStrType"></param>
        /// <param name="dbType"></param>
        /// <param name="value"></param>
        /// <param name="parPrefix"></param>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <returns></returns>
        private DbParameter CreateParameter(IProvider provider, bool isStrType, DbType dbType, object value, char parPrefix, int row, int col)
        {
            //如果生成全部的参数，则速度会很慢，因此，只有数据类型为字符串(包含'号)和日期型时才添加参数
            if ((isStrType && value.ToString().IndexOf('\'') != -1) || dbType == DbType.DateTime)
            {
                var name = string.Format("{0}p_{1}_{2}", parPrefix, row, col);
                var parameter = provider.DbProviderFactory.CreateParameter();
                parameter.ParameterName = name;
                parameter.Direction = ParameterDirection.Input;
                parameter.DbType = dbType;
                parameter.Value = value;
                return parameter;
            }
            return null;
        }
    }

MySql的批量插入，是将值全部写在语句的values里，例如，insert batcher(id, name) values(1, '1', 2, '2', 3, '3', ........ 10, '10')。

五、测试

接下来写一个测试用例来看一下使用批量插入的效果。

        [Test]
        public void TestBatchInsert()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var table = new DataTable("Batcher");
                        table.Columns.Add("Id", typeof(int));
                        table.Columns.Add("Name1", typeof(string));
                        table.Columns.Add("Name2", typeof(string));
                        table.Columns.Add("Name3", typeof(string));
                        table.Columns.Add("Name4", typeof(string));

                        //构造100000条数据
                        for (var i = 0; i < 100000; i++)
                        {
                            table.Rows.Add(i, i.ToString(), i.ToString(), i.ToString(), i.ToString());
                        }

                        //获取 IBatcherProvider
                        var batcher = database.Provider.GetService<IBatcherProvider>();
                        if (batcher == null)
                        {
                            Console.WriteLine("不支持批量插入。");
                        }
                        else
                        {
                            batcher.Insert(table);
                        }

                        //输出batcher表的数据量
                        var sql = new SqlCommand("SELECT COUNT(1) FROM Batcher");
                        Console.WriteLine("当前共有 {0} 条数据", database.ExecuteScalar(sql));

                    })));
        }

以下表中列出了四种数据库生成10万条数据各耗用的时间

数据库	耗用时间
MsSql	00:00:02.9376300
Oracle	00:00:01.5155959
SQLite	00:00:01.6275634
MySql	00:00:05.4166891

本文链接

Fireasy.Data系列——底层结构

2012-04-18T13:49:00Z

Fireasy.Data的一个主要接口是IDatabase，这个与网上流传的SqlHelper差不多是完成一样的操作。不过，在IDatabase中只提供了几个高内聚的方法，你不必去传递那些DbCommand和DbParameter。不同的数据库类型，都提供实现IProvider接口的类，来指定DbProviderFactory，以及各种的IProviderService组合来实现更多的功能。

下面先来看一下有关IDatabase及周围的一些接口组合：

1、IDatabase接口

在Fireasy.Data中，IDatabase是最底层的接口，它提供了以下几个属性和方法：

ConnectionString：数据库的连接字符串对象。

Provider：为IDatabase提供的不同数据库的实现，也是一个重要的接口，这个将在后面进行介绍。

BeginTransaction：开始数据库事务，加上了事务锁，如果IDatabase之前已经开始了事务，再将调用该方法是将返回false。

CommitTransaction：提交数据库事务，如果是与BeginTransaction方法匹配的，则可以提交，否则返回false。

RollbackTransaction：回滚数据库事务，如果是与BeginTransaction方法匹配的，则可以回滚，否则返回false。

ExecuteDataTable：执行一个查询语句，将结果以DataTable返回。

ExecuteEnumerable：执行一个查询语句，将结果以T序列返回，可以指定你的IDataRowMapper来进行转换，默认是使用DefaultRowMapper。

ExecuteNonQuery：执行一个查询语句，返回影响的行数。

ExecuteReader：执行一个查询语句，以IDataReader返回结果。

ExecuteScalar：执行一个查询语句，返回第一行的第一列。

FillDataSet：执行一个查询语句，将结果填充到DataSet。

Update：将一个DataTable的改动保存到数据库。

2、IProvider接口

IProvider针对不同的数据库类型，提供其实现类，它的一个主要属性是DbProviderFactory。一般数据库的驱动都基于Ado.Net，因此它们就必须提供自己的DbProviderFactory。DbProviderFactory用于创建DbConnection、DbCommand、DbParameter等实例。

另外，IProvider还提供了一组方法，方便将一些扩展的接口以插件的方式注入到Provider中。目前提供的插件服务接口有IBackupProvider、IBatcherProvider、ISyntaxProvider、IGeneratorProvider、ISchemaProvider、ICommandWatcher和ITranslateProvider。

RegisterService：注册一个插件服务实例。这些实例必须是实现IProviderService接口。

GetServices：获取所有的已注册的插件实例。

GetService：获取指定类型的插件服务实例。

3、IBackupProvider接口

该接口为数据库提供者提供数据库的备份与恢复操作，目前只是一个雏形，只有MsSql实现了该接口。

Backup：备份指定的数据库到指定的文件。

Restore：从指定的文件恢复数据库。

4、IBatcherProvider接口

该接口为数据库提供者提供数据的批量插入支持。大部份数据库，如MsSql、MySql、Oracle、SQLite都提供了批量插入数据的方法，因此只要实现该接口方法就可以批量插入数据了。在Fireasy中，已经为四种数据库类型实现了批量插入的方法。以后会逐一介绍。

Insert：将一整个DataTable里的数据一次性或分批写入到数据库。

5、ISyntaxProvider接口

该接口为数据库提供者提供SQL语法解析的支持。众所周知，一个Length函数在不同的数据库中写法都可能不相同，因此ISyntaxProvider提供了对字符串、日期、数学运算三组语法的解析，还有存储参数前缀、字段前导后导符，分页方法、数据类型转换等多种方法。

StringSyntax：字符串函数的解析类，里面的方法不再介绍了。

DateTimeSyntax：日期函数的解析类，里面的方法不再介绍了。

MathSyntax：数学运算函数的解析类，里面的方法不再介绍了。

IdentitySelect：获取最近创建的自动编号的查询文本。

Segment：对Sql语法使用IDataSegment进行分段处理，返回添加了分段语法的后的sql。

Convert：将字段转换为指定的数据类型，如cast(name, nvarchar)。

Column：生成相应类型的数据类型关键字，如MsSql里将DbType.String生成nvarchar。

Coalesce：如果源表达式为 null，则依次判断给定的一组参数，直至某参数非 null 时返回，这个就象是C#里的 var db = str1 ?? str2 ?? str3。

6、ISchemaProvider接口

该接口为数据库提供者提供数据库架构的查询，可以返回如表、字段这些信息的元数据。

GetSchemas<T>：获取指定T类型的架构信息，T是实现自ISchemaMetadata，如Table、Column、Procedure等。可以使用表达式对架构进行查询，如GetSchemas<Table>(s => s.TableName == “Product”)。

GetSchemas：这个与DbConnection里的方法一样，返回一个DataTable。

7、ICommandWatcher接口

该接口应该与数据库提供者无关，它只是切入IDatabase内部，在执行Sql的时候使用该接口进行外部通知。

Notify：通知外部程序，所执行的Sql以及耗用的时间。

8、ITranslateProvider接口

该接口为数据库提供者提供实体Linq查询的解析，你可以书写一些Linq查询，然后交给该接口进行解析，最终得到数据库能够执行的Sql。考虑到这部份的复杂性，将单独开几篇文章进行介绍。

Fireasy.Data最底层的接口主要就是围绕IDatabase和IProvider组织的，如果以后需要对IDatabase的功能进行扩充，我们只需要定义一个新的接口继承自IProviderService，然后在相应的Provider内进行注册，当然还提供了Provider的配置，可以方便的进行组合。

Fireasy.Data底层的介绍就是这些，不知道你对Fireasy.Data有没有一个大概的认识了，不妨了说说你的想法。

本文链接

Fireasy.Data系列——概述

2011-11-10T16:25:00Z

在上一篇中我曾提到过要组建实体框架，不管我的出发点是好还是坏，我总算把它做出了一个雏形，并且已经能够加入到项目中使用了，当然还有许多的事情要处理，也需要更多的实例验证，才能不断的完善。

相比以前的FaibClass.Data，它已经显得更强大了，但是还没有实现实体的继承关系。

Fireasy系列组件是在.net framework 4.0环境下编写的，但是没有使用太多的4.0特性，Fireasy.Data.Entity还包括两个依赖组件：Fireasy.Common和Fireasy.Data。

今天首先开个序，详细的功能我会慢慢的介绍，下面先晒一下Fireasy.Data.Entity的特性：

1、依赖属性

采用依赖属性的方式进行定义，属性分为普通属性和特殊属性，普通属性是数据库字段所对应的属性，特殊属性包括引用实体属性、实体集属性、引用属性、枚举文本属性和同步属性（暂未实现）。这跟EF里的叫法差不多，不过遗憾的是EF不支持枚举的定义。

依赖属性定义为静态成员，并且放入缓存中进行管理，实体属性的读取或赋值与WPF里类似，也是使用GetValue和SetValue两个方法。

属性修改时提供了通知事件，以后还要加入属性的验证特性。

2、按需更新

在对一个实体对象进行修改的时候，只把更改过的属性值写进去，这样能够避免不必要的操作。并且，如果实体对象所关联的实体或实体集被修改，也会将相应的改变更新到数据库。如果将一个特殊属性设为null，也会删除该属性原来的对象。

实体更新的深度只限有两层，这主要是考虑到执行效率，不断的逐层更新也是可以的，但这样效率将大大降低。比如，一个实体对象的更新，可以同时更新它的引用实体A和实体集S，但是引用实体A的引用实体B是无法更新到的。

3、延迟加载

对引用实体和实体集属性，可设定三种行为进行加载，如果用在WCF或WS中，如果始终加载或延迟加载，都将造成所有数据的一次性加载，此时可以将加载过程关闭，而采用手动方式在需要的时候再获取。

4、删除标记

提供了假删除的支持，在属性定义的时候可以标记该属性是否是删除标记，在之后的所有查询将过滤标记为true的实体，在执行删除时，可以决定是彻底删除呢还是假删除。

5、环境变量

可以将一个实体映射到不同的数据表，比如按年度进行划分，2010年使用 TB_USER_2010，2011年使用TB_USER_2011等，以解决大数据存储的问题。也可以由具体的环境，比如用户、部门等变量来组合映射。

6、实体树

提供了实体树的插入、移动、删除、查找等功能，只要定义相关的映射信息，即可快速实现树型结构的管理。实体树采用内码的方式进行管理，如0001，00010001。

7、LINQ查询

本框架也提供了LINQ查询的支持，目前支持sqlserver、oracle、sqlite和mysql等几种常用数据库语法的解析。

8、环境事务

与TransactionScope类似，为一代码段提供事务控制。

好象就以上这些东东，详细的使用方法将会在以后一一进行介绍。

本文链接

我想组建新的Entity框架

2011-10-01T09:38:00Z

这个想法已经有很长一段时间了，并且目前已经有一个雏形的版本了，我暂定它为Fireasy.Data.Entity。

我先说一说我的想法，实体的映射将采用依赖属性的方式进行定义，这样可以避免使用反射进行实体的初始化，而且也比较实现其他代码的切入。

在这个框架里，还是提供了引用实体和实体集的概念，它们也可以通过lazy加载进来，另外，还设计一个支持枚举的属性和一个同步属性。

另外，根据实际项目的需要，还会将同一个实体根据不同的规则映射多个不同的数据表，以提供数据分布式和隔离式存储。还会提供一个树结构的映射及相应的持久化类，以达到快速应用。

实体的继承特性将在下一期进行考虑。

以下是实体类的代码示例：

    [EntityMapping("PRODUCTS")]
    public class Product : EntityObject
    {
        public readonly static IProperty _ProductId = PropertyUnity.RegisterProperty("ProductId",
            typeof(int), typeof(Product),
            new PropertyMapInfo
            {
                FieldName = "PRODUCTID",
                GenerateType = IdentityGenerateType.AutoIncrement,
                IsPrimaryKey = true,
                IsNullable = false
            });

        public readonly static IProperty _ProductName = PropertyUnity.RegisterProperty("ProductName",
            typeof(string), typeof(Product),
            new PropertyMapInfo
            {
                FieldName = "PRODUCTNAME",
                IsNullable = false
            });

        public readonly static IProperty _SupplierID = PropertyUnity.RegisterProperty("SupplierID",
            typeof(int?), typeof(Product),
            new PropertyMapInfo { FieldName = "SUPPLIERID" });

        public readonly static IProperty _CategoryID = PropertyUnity.RegisterProperty("CategoryID",
            typeof(int?), typeof(Product),
            new PropertyMapInfo { FieldName = "CATEGORYID" });

        public readonly static IProperty _QuantityPerUnit = PropertyUnity.RegisterProperty("QuantityPerUnit",
            typeof(string), typeof(Product),
            new PropertyMapInfo { FieldName = "QUANTITYPERUNIT" });

        public readonly static IProperty _UnitPrice = PropertyUnity.RegisterProperty("UnitPrice",
            typeof(decimal?), typeof(Product),
            new PropertyMapInfo { FieldName = "UNITPRICE" });

        public readonly static IProperty _UnitsInStock = PropertyUnity.RegisterProperty("UnitsInStock",
            typeof(short?), typeof(Product),
            new PropertyMapInfo { FieldName = "UNITSINSTOCK" });

        public readonly static IProperty _UnitsOnOrder = PropertyUnity.RegisterProperty("UnitsOnOrder",
            typeof(short?), typeof(Product),
            new PropertyMapInfo { FieldName = "REORDERLEVEL" });

        public readonly static IProperty _ReorderLevel = PropertyUnity.RegisterProperty("ReorderLevel",
            typeof(short?), typeof(Product),
            new PropertyMapInfo { FieldName = "REORDERLEVEL" });

        public readonly static IProperty _Discontinued = PropertyUnity.RegisterProperty("Discontinued",
            typeof(bool?), typeof(Product),
            new PropertyMapInfo { FieldName = "DISCONTINUED", DefaultValue = true });

        public readonly static IProperty _OrderDetails = PropertyUnity.RegisterSpecialProperty("OrderDetails",
            typeof(EntitySet<OrderDetails>), typeof(Product));

        public readonly static IProperty _DelFlag = PropertyUnity.RegisterProperty("DelFlag",
            typeof(bool?), typeof(Product), new PropertyMapInfo { FieldName = "DEL_FLAG", IsFakeDeleteFlag = true });

        public int ProductId
        {
            get { return (int)GetValue(_ProductId); }
            set { SetValue(_ProductId, value); }
        }

        public string ProductName
        {
            get { return (string)GetValue(_ProductName); }
            set { SetValue(_ProductName, value); }
        }

        public int? SupplierID
        {
            get { return (int)GetValue(_SupplierID); }
            set { SetValue(_SupplierID, value); }
        }

        public int? CategoryID
        {
            get { return (int)GetValue(_CategoryID); }
            set { SetValue(_CategoryID, value); }
        }

        public string QuantityPerUnit
        {
            get { return (string)GetValue(_QuantityPerUnit); }
            set { SetValue(_QuantityPerUnit, value); }
        }

        public decimal? UnitPrice
        {
            get { return (decimal)GetValue(_UnitPrice); }
            set { SetValue(_UnitPrice, value); }
        }

        public short? UnitsInStock
        {
            get { return (Int16)GetValue(_UnitsInStock); }
            set { SetValue(_UnitsInStock, value); }
        }

        public short? UnitsOnOrder
        {
            get { return (Int16)GetValue(_UnitsOnOrder); }
            set { SetValue(_UnitsOnOrder, value); }
        }

        public short? ReorderLevel
        {
            get { return (Int16)GetValue(_ReorderLevel); }
            set { SetValue(_ReorderLevel, value); }
        }

        public bool? Discontinued
        {
            get { return (bool)GetValue(_Discontinued); }
            set { SetValue(_Discontinued, value); }
        }

        public EntitySet<OrderDetails> OrderDetails
        {
            get { return (EntitySet<OrderDetails>)GetValue(_OrderDetails); }
            set { SetValue(_OrderDetails, value); }
        }

        public bool? DelFlag
        {
            get { return (bool)GetValue(_DelFlag); }
            set { SetValue(_DelFlag, value); }
        }

    }

与EF相似地，实体间的关系采用Assembly特性进行定义：

[assembly: Relationship("Product:OrderDetails", typeof(Product), typeof(OrderDetails), "ProductId=>ProductId")]
[assembly: Relationship("Orders:OrderDetails", typeof(Orders), typeof(OrderDetails), "OrderID=>OrderId")]
[assembly: Relationship("Customer:Orders", typeof(Customers), typeof(Orders), "CustomerID=>CustomerID")]

框架也提供对Linq查询的支持，目前支持mssql、oracle、mysql和sqlite几种数据库。

目前的测试结果显示，数据加载的速度比EF稍稍快了一点点，现在需要请大虾帮忙验证这种方式的可行性。也请有兴趣的朋友一起加入讨论，多给我提些意见。QQ群号：6406277。

本文链接

轻量的Json序列化

2011-10-01T00:01:00Z

framework里提供了DataContractJsonSerializer这样一个类，可以实现对象与json间的序列化和反序列化，可参考博文 http://www.cnblogs.com/chenqingwei/archive/2010/06/09/1754522.html。而为了方便，本人做了一个扩展方法，可以将任意的object序列化为json，不提供反序列化。

这是一个很简单的扩展方法，代码如下：

        /// <summary>
        /// 将对象序列化为 Json 文本流。
        /// </summary>
        /// <param name="source">要转换的对象。</param>
        /// <param name="inclusive">选择要包含的属性数组。</param>
        /// <param name="exclusive">选择要排除的属性数组。</param>
        /// <returns></returns>
        public static string ToJson(this object source, string[] inclusive = null, string[] exclusive = null)
        {
            if (source == null)
            {
                return "null";
            }

            var type = source.GetType();
            switch (Type.GetTypeCode(type))
            {
                //数值型
                case TypeCode.Byte:
                case TypeCode.Decimal:
                case TypeCode.Double:
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.SByte:
                case TypeCode.Single:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                    return source.ToString();
                case TypeCode.Object:
                    break;
                case TypeCode.Boolean:
                    return (bool)source ? "true" : "false";
                case TypeCode.DBNull:
                    return "null";
                default:
                    return "\"" + source + "\"";
            }

            var sb = new StringBuilder();
            var flag = new AssertFlag(true);
            //DataSet
            if (source is DataSet)
            {
                var ds = source as DataSet;
                sb.Append("[ ");
                foreach (var table in ds.Tables)
                {
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.Append(table.ToJson());
                }
                sb.Append(" ]");
            }
            //DataTable
            else if (source is DataTable)
            {
                var tb = source as DataTable;
                sb.Append("[ ");
                foreach (var row in tb.Rows)
                {
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.Append(row.ToJson());
                }
                sb.Append(" ]");
            }
            //DataRow
            else if (source is DataRow)
            {
                var row = source as DataRow;
                sb.Append("{");
                foreach (DataColumn column in row.Table.Columns)
                {
                    if (PropertyNotToJson(column.ColumnName, inclusive, exclusive))
                    {
                        continue;
                    }
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.AppendFormat("\"{0}\" : {1}", column.ColumnName, row[column].ToJson());
                }
                sb.Append("}");
            }
            //Array
            else if (type.IsArray)
            {
                var array = source as Array;
                sb.Append("[ ");
                for (var i = 0; i < array.Length; i++)
                {
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.Append(array.GetValue(i).ToJson());
                }
                sb.Append(" ]");
            }
            //IEnumerable
            else if (source is IEnumerable)
            {
                var enu = (source as IEnumerable).GetEnumerator();
                sb.Append("[ ");
                while (enu.MoveNext())
                {
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.Append(enu.Current.ToJson());
                }
                sb.Append(" ]");
            }
            else if (type != typeof(object))
            {
                sb.Append("{");
                var pps = from s in type.GetProperties(BindingFlags.Public | BindingFlags.Instance) where s.CanRead select s;
                foreach (var pro in pps)
                {
                    if (PropertyNotToJson(pro.Name, inclusive, exclusive))
                    {
                        continue;
                    }
                    var value = pro.GetValue(source, null);
                    if (!flag.AssertTrue())
                    {
                        sb.Append(", ");
                    }
                    sb.AppendFormat("\"{0}\" : {1}", pro.Name, value.ToJson());
                }
                sb.Append("}");
            }
            return sb.ToString();
        }

        /// <summary>
        /// 属性不被序列化。
        /// </summary>
        /// <param name="propertyName">属性名称。</param>
        /// <param name="inclusive">选择要包含的属性数组。</param>
        /// <param name="exclusive">选择要排除的属性数组。</param>
        /// <returns></returns>
        private static bool PropertyNotToJson(string propertyName, IEnumerable<string> inclusive = null, IEnumerable<string> exclusive = null)
        {
            return ((inclusive != null && !inclusive.Contains(propertyName)) ||
                (exclusive != null && exclusive.Contains(propertyName)));
        }

本文链接

ReSharper 不为人知的罪恶选项

2011-09-07T05:59:00Z

ReSharper是一个强大的VS扩展工具，但由于它是英文版的，因此在使用过程当中不免被它折磨几次(可能是由于本人英文不是很好)，以下是鄙人的一些经历：

1、F12转到定义
安装ReSharper后首次使用F12时，它会弹出一个对话框，是什么样子不记得了，大概意思是让你选择使用何种方式转到定义。因于是第一次使用，我并不知道它每项的能够获得的效果，所以我蒙过去了。按下F12时，mygod，它要连接下载 XXX.pdb 文件，能够看到元数据就不用说了，它竟然没有任何的注释，远远没有VS的好用。于是乎，我在ReSharper选项里翻爬，最终找到了它的设置方法。

2、修改js时，按回车出来 foo foo!
这个问题很无耐，如果js是外部的，你在回车时，它就给你加上了foo foo!显得非常的不方便；但如果文件是包含在项目里的，则没有这个问题。我将所有的Javascript扩展器都禁用了，它还是存在，那会不会是ReSharper造成的呢，于是乎，又ReSharper选项里翻爬了一阵，最终也找到了解决办法。

3、修改js时，按一个(出来两个)，按一个"出来两个"
这个问题也很无耐，很显然是和VS自身的冲突了，鉴于以上的经验，初步认定是ReSharper这个恶魔搞的鬼。以下是该问题的解决办法。

本文链接

AxTools.VS10x.CodeMap注册机

2011-07-20T06:04:00Z

你懂的，直接上文件

下载

本文链接

3个月时间完成工作流项目

2011-06-27T16:02:00Z

今天终于将公司的工作流项目划上圆满句号了，由于急于转向其他产品的开发，并未全面的进行运转测试。

该项目主要参考了FireWorkflow为，在此基础上，引入了域的配置、工作流分类、业务数据表定义、工作流服务、外务协调器、日志、通知、代理，外围提供了表单设计器、流程设计器、表单相关控件。

一、模型

该模型主要由开始节点、结束节点、活动、路由、转移构成，对FireWorkflow改进的地方有：

1、手工活动

分配策略：全部、任意

完成策略：全部、任意、按完成数量、按完成百分比

超时策略：默认、完成、提前提醒

选项：允许临时指定参与者、允许委派、允许跳过、允许收回、允许拒收

关键指标定义：目标表达式、状态表达式、趋势表达式

2、路由

分支网关：并行、独占选择、多重选择

合并网关：同步、简单聚合、多重聚合

触发类型：自动、手工

3、转移

条件：使用Sql标准语法作为条件表达式

转入策略：全部、任意、最终、按进入数量、按进入百分比

其他：动作名称

二、业务数据表定义

支持在线自定义业务数据结构，也可以由工作流分类引入即定的数据结构（对于同一个分类，数据结构不改变，业务性强）；

支持明细表的定义；

支持公式的定义，可使用sum、max等聚合函数对明细表统计。

三、工作流域

可以将一个业务系统内的不同业务分离为多个域，每个域配置相应的引擎实现部份。

四、工作流服务

主要用于监视域中运行的具有时限的任务，可以将工作流服务宿主到web中。

五、工作流分类

将不同的业务进行分类，对于业务性相对固定的工作流（如公文、物资采购），其数据表是不变的，因此可以为该分类配置一个数据结构定义文件，而其他简单的业务（如请假、费用报销）则没有该文件，可以在线定义数据结构。

六、外务协调器

主要用于获取业务系统中的组织机构、角色、群组、用户、代理用户等信息，以及当前登录用户的信息。

本文链接