我想组建新的Entity框架

    这个想法已经有很长一段时间了，并且目前已经有一个雏形的版本了，我暂定它为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。