博客园_faib的技术专栏

Fireasy.Data.Entity 实体框架介绍——索引

2011-11-10T16:25:00Z

一、概述

二、实体关系映射

三、持久化方法(一)

四、持久化方法(二)

五、使用环境变量

六、LINQ查询(一)

七、LINQ查询(二)

八、实体树的管理

一、概述

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

相比以前的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中。

五、工作流分类

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

六、外务协调器

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

本文链接

历时半年，发布最完整的代码生成器CodeBuilder最新版本

2010-12-22T16:15:00Z

经过反反复复的修改，今天终于发布了1.1.10.1222版本。以前一个版本相比，新版本中新增了四个模板插件：XSL、T4、NVelocity、CodeSmith，从而将目前比较流行的几大模板纳入了CodeBuilder，由于时间关系，每个模板下仅给出了一两个例子。同时，在数据源方面，新增了ERWin和数据提供者插件，ERWin支持的是7.2版本，数据提供者实现了MySql和SQLite两种数据库。

在整体的使用性方面，本版本也进行了许多人性化的改进，并且此次提供了帮助文件（原来的版本没时间写帮助啊）。

感谢感谢你一直对CodeBuilder的支持，如果你有更好的建议，你可以发邮件给我，我将非常期待与你交流，这样才能推出更好的版本。

下载 CodeBuilder 1.1.10.1222

下载 CodeBuilder 1.1.10.1312

本文链接

有关CodeBuilder中基础模板的说明

2010-01-27T17:04:00Z

CodeBuilder中的Template.FbBase是一个基于xml语法的基础模板，主要由defkeys、functions、parts、sections构成。代码Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--><?xmlversion="1...

CodeBuilder之Tool接口

2010-01-10T16:08:00Z

代码Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->usingSystem;usingSystem.Collections.Generic;usingSystem.Drawing;usingSystem.Windows.Forms;usingFaibC...

博客园_faib的技术专栏

Fireasy.Data.Entity 实体框架介绍——索引

我想组建新的Entity框架

轻量的Json序列化

ReSharper 不为人知的罪恶选项

AxTools.VS10x.CodeMap注册机

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

历时半年，发布最完整的代码生成器CodeBuilder最新版本

最新版本的CodeBuilder 1.0.0.1446

有关CodeBuilder中基础模板的说明

CodeBuilder之Tool接口