Websharp——开源.Net应用系统框架
一. 前言
Websharp的目标，是开发一个开源的基于Microsoft.Net的轻量级的应用软件系统开发框架，包含以下内容：
Ø 一个轻量级的O/R Mapping框架
Ø 一个轻量级的AOP框架
Ø 一个轻量级的ServiceLocator，主要目的是为整合不同服务端技术的客户端编程。
说来惭愧的是，这个框架从三年前就开始做了，但是因为工作的原因，具体的开发过程一直是断断续续，中间因个人对编程思想认识的变化，在结构方面也一直有点变化。在这个过程中，一直有人来Mail询问相关的情况，也有很多朋友发信来鼓励我，使我感到愧疚的是，我一直都没有很好的回复这些邮件。在国内，做开源项目真的是很难，首先要养活自己和老婆孩子，才能够挤出一点点时间来做自己的事情。
最近，因为工作的变化，使我从繁复的开发工作中脱离出来，使我有更多的时间来支配我自己，因此，又把这个工作继续了下去，经过一段时间的“虾米”生活，终于把O/R Mapping做的比较像样了。AOP和ServiceLocator部分，是以前做好的，一直都没有动过。现在我把所有的代码都公开出来，并写了一个简单的使用说明，希望能够对大家有所帮助。在这里，需要感谢的是徐芳波，在Websharp的开发过程中，也做了很多的工作，付出了很多。
本文主要说明Websharp O/R Mapping部分使用的内容。关于Websharp的设计理念，以及其他方面的内容，可以访问我的Blog：http://sunnyym.cnblogs.com/
从此处下载全部源代码
二. Websharp O/R Mapping起步
Websharp ORM是一个轻量级的O/R Mapping框架，主要特点是抛弃了Java中常见的，也是其他一些O/R Mapping产品中使用XML文件来做映射描述的方法，而使用Attribute作为描述映射的方法，简单明了，并且，对开发人员来说，只有PersistenceManager、Query、Transaction等极少数接口需要掌握，上手快，使用非常方便。
因为在某些地方使用了范型，所以目前版本的Websharp需要.Net Framework2.0。
下面的例子给出了使用Websharp进行ORM操作的基本过程。
使用Visual Studio.Net2005建立一个Windows Console项目，然后，定义如下一个类：
| [TableMap("Product", "ID")] public class Product { private int m_ID; private string m_Name; private decimal m_Price;
public Product() { } public Product(string name,decimal price) { //m_ID = id; m_Name = name; m_Price = price; }
[ColumnMap("ID", DbType.Int32)] [AutoIncrease(1)] public int ID { get { return m_ID; } set { m_ID = value; } }
[ColumnMap("Name", DbType.String)] public string Name { get { return m_Name; } set { m_Name = value; } }
[ColumnMap("Price", DbType.Decimal)] public decimal Price { get { return m_Price; } set { m_Price = value; } } } |
类中第一行[TableMap("Product", "ID")]的意思是说，这个Product类映射到数据库中的Product表，主键为属性ID。在属性ID上，[ColumnMap("ID", DbType.Int32)]的意思是说，这个属性映射到数据库中的ID字段，数据类型是Int32，[AutoIncrease(1)]表明这是一个自动增长列，增长的幅度为1。其他属性的可以据此类推。
因此，上面这个Produc类对应的数据库表的结构应该是：
| 字段名 |
数据类型 |
| ID |
int(自动增长) |
| Name |
Nvarchar(50) |
| Price |
Decimal |
下面的代码演示了Websharp是如何把Product对象新增到数据库中的。
| public static void Main (string[] args) { //设定环境 DatabaseProperty dbp = new DatabaseProperty(); dbp.DatabaseType = DatabaseType.MSSQLServer; dbp.ConnectionString = "Data Source=(local);Initial Catalog=WebsharpTest;Integrated Security=True";
//操作数据 PersistenceManager pm = PersistenceManagerFactory.Instance().Create(dbp); Product p0 = new Product("Name0", 100); pm.PersistNew(p0); Product p1 = new Product("Name1", 101); pm.PersistNew(p1); pm.Flush(); pm.Close(); } |
在代码的开始部分，先设定了数据库的一些参数，然后，通过PersistenceManagerFactory创建了一个PersistenceManager,用这个PersistenceManager就可以对对象进行操作了。在上面的代码里面，我们把两个Product对象保存到了数据库中。注意，因为Product类的ID属性是自动增长的，因此，在保存这两个对象之前，是不必对ID属性赋值的，在这两个对象被保存到数据库中后，PersistenceManager会根据数据库中的自动增长的值自动给ID赋值。
当然，为了使上面的代码能够顺利运行，我们还需要做一些配置。新建一个App.config文件，把下面的配置代码Copy进去就可以了：
| xml version="1.0" encoding="utf-8" ?> <configuration> <configSections> <section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version= 2.0.0 .0, Culture=neutral, PublicKeyToken=null" /> <section name="WebsharpExpirationPolicy" type="Websharp.ORM.Service.WebsharpCofigurationHandler,Websharp.ORM.Service" /> configSections> <cachingConfiguration defaultCacheManager="Cache Manager"> <cacheManagers> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="Cache Manager" /> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="EntityCache" /> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="SqlCache" /> cacheManagers> <backingStores> <add encryptionProviderName="" type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version= 2.0.0 .0, Culture=neutral, PublicKeyToken=null" name="Null Storage" /> backingStores> cachingConfiguration>
<WebsharpExpirationPolicy> <ExpirationPolicy ExpirationCheckInterval="60" AssemblyName="Microsoft.ApplicationBlocks.Cache" ClassName="Microsoft.ApplicationBlocks.Cache.ExpirationsImplementations.SlidingTime" /> WebsharpExpirationPolicy> configuration> |
配置文件只是用来说明缓存的使用的，基本上所有的项目需要的配置文件对于Websharp来说都不需要改变。当然，有一些细微的参数还是可以调整的，这个在后面描述。
可以看出，相对于其他一些O/R Mapping框架来说，Websharp不需要写一大堆的XML映射文件，代码简洁明了。
三. 映射方法说明
映射部分，完成对象和关系型数据库之间映射关系的表达。Websharp使用Attribute来描述映射关系，设计了以下Attribute来描述对象和关系型数据库之间的映射。
Ø TableMapAttribute
这个Attribute描述对象和数据库表的映射关系，这个类有两个属性，TableName属性指明和某个类所对应的数据库表，PrimaryKeys用来描述表的主关键字。这个类的定义如下：
| [AttributeUsage(AttributeTargets.Class)] public class TableMapAttribute : Attribute { private string tableName; private string[] primaryKeys; public TableMapAttribute(string tableName,params string[] primaryKeys) { this.tableName = tableName; this.primaryKeys = primaryKeys; } public string TableName { get{return tableName;} set{tableName = value;} }
public string[] PrimaryKeys { get{return primaryKeys;} set{primaryKeys = value;} } } |
Ø ColumnMapAttribute
这个Attribute描述对象属性和数据库中表的字段之间的映射关系，这个类有三个属性，ColumnName属性指明和某个属性所对应的字段，DbType属性指明数据库字段的数据类型，DefaultValue指明字段的默认值。这个类的定义如下：
| [AttributeUsage(AttributeTargets.Property)] public class ColumnMapAttribute : Attribute { private string columnName; private DbType dbtype; private object defaultValue; public ColumnMapAttribute(string columnName,DbType dbtype) { this.columnName = columnName; this.dbtype = dbtype; }
public ColumnMapAttribute(string columnName,DbType dbtype,object defaultValue) { this.columnName = columnName; this.dbtype = dbtype; this.defaultValue = defaultValue; }
public string ColumnName { get{return columnName;} set{columnName = value;} }
public DbType DbType { get{return dbtype;} set{dbtype = value;} }
public object DefaultValue { get{return defaultValue;} set{defaultValue = value;} } } |
Ø ReferenceObjectAttribute
ReferenceObjectAttribute指示该属性是引用的另外一个对象，因此，在执行持久化操作的时候，需要根据参数进行额外的处理。默认情况下，当持久化实体对象的时候，ReferenceObjectAttribute指示的属性，不进行操作。这个类有三个属性，ReferenceType指明所引用的对象的类型，PrimaryKey和ForeignKey用来指明两个类之间进行关联的主键和外键。这个类的定义如下：
| [AttributeUsage(AttributeTargets.Property)] public class ReferenceObjectAttribute : Attribute { private Type referenceType; private string primaryKey; private string foreignKey; public ReferenceObjectAttribute(Type referenceType,string primaryKey,string foreignKey) { this.referenceType = referenceType; this.primaryKey = primaryKey; this.foreignKey = foreignKey; }
public ReferenceObjectAttribute(){}
public Type ReferenceType { get{return referenceType;} set{referenceType = value;} }
public string PrimaryKey { get{return primaryKey;} set{primaryKey = value;} }
public string ForeignKey { get{return foreignKey;} set{foreignKey = value;} } }
|
Ø SubObjectAttribute
SubObjectAttribute指示该属性是引用的是子对象，因此，在执行持久化操作的时候，需要根据参数进行额外的处理。默认情况下，当持久化实体对象的时候，SubObjectAttribute指示的属性，不进行操作。
这个类的定义如下：
| [AttributeUsage(AttributeTargets.Property)] public class SubObjectAttribute : Attribute { private Type subObjectType; private string primaryKey; private string foreignKey; public SubObjectAttribute(Type subObjectType, string primaryKey, string foreignKey) { this.subObjectType = subObjectType; this.primaryKey = primaryKey; this.foreignKey = foreignKey; }
public SubObjectAttribute(){}
public Type SubObjectType { get { return subObjectType; } set { subObjectType = value; } }
public string PrimaryKey { get{return primaryKey;} set{primaryKey = value;} }
public string ForeignKey { get{return foreignKey;} set{foreignKey = value;} } } |
Ø AutoIncreaseAttribute
AutoIncreaseAttribute指示该属性是自动增长的。自动增长默认种子为1。需要指出的是，自动增长的属性只适用于MS SqlServer，Websharp目前不支持其他数据库的自动增长列。
这个类的定义如下：
| [AttributeUsage(AttributeTargets.Property)] public class AutoIncreaseAttribute : Attribute { private int step = 1;
public AutoIncreaseAttribute(){}
public AutoIncreaseAttribute(int step) { this.step = step; }
public int Step { get{return step;} set{step = value;} } } |
设计好映射的方法后，我们就可以来定义实体类以及同数据库之间的映射。下面是一个例子：
| //订单类别 [TableMap("OrderType","ID")] public class OrderType { private int m_ID; private string m_Name;
[ColumnMap("ID",DbType.Int32)] public int ID { get { return m_ID; } set { m_ID = value; } } [ColumnMap("Name", DbType.String)] public string Name { get { return m_Name; } set { m_Name = value; } } }
//订单 [TableMap("PurchaseOrder", "OrderID")] public class Order { private int m_OrderID; private OrderType m_OrderType; private string m_Title; private DateTime m_AddTime; private bool m_IsSigned; private List<OrderDetail> m_Details;
[ColumnMap("OrderID",DbType.Int32)] [AutoIncrease] public int OrderID { get { return m_OrderID; } set { m_OrderID = value; } } [ReferenceObject(typeof(OrderType),"ID","TypeID")] [ColumnMap("TypeID",DbType.String)] public OrderType OrderType { get { return m_OrderType; } set { m_OrderType = value; } } [ColumnMap("Title", DbType.String)] public string Title { get { return m_Title; } set { m_Title = value; } } [ColumnMap("AddTime", DbType.DateTime)] public DateTime AddTime { get { return m_AddTime; } set { m_AddTime = value; } } [ColumnMap("AddTime", DbType.Boolean)] public bool IsDigned { get { return m_IsSigned; } set { m_IsSigned = value; } } [SubObject(typeof(OrderDetail),"OrderID","OrderID")] public List<OrderDetail> Details { get { return m_Details; } set { m_Details = value; } } }
//订单明细 public class OrderDetail { private int m_DetailID; private int m_OrderID; private string m_ProductName; private int m_Amount;
[ColumnMap("ID", DbType.Int32)] [AutoIncrease] public int DetailID { get { return m_DetailID; } set { m_DetailID = value; } } [ColumnMap("OrderID", DbType.Int32)] public int OrderID { get { return m_OrderID; } set { m_OrderID = value; } } [ColumnMap("ProductName", DbType.String)] public string ProductName { get { return m_ProductName; } set { m_ProductName = value; } } [ColumnMap("Amount", DbType.Int32)] public int Amount { get { return m_Amount; } set { m_Amount = value; } } } |
Order中
| [ReferenceObject(typeof(OrderType),"ID","TypeID")] [ColumnMap("TypeID",DbType.String)] public OrderType OrderType { get { return m_OrderType; } set { m_OrderType = value; } } |
这段代码表明，OrderType这个属性，引用了OrderType这个对象，同OrderType相关联的，是OrderType的主键ID和Order的外键TypeID。
| [SubObject(typeof(OrderDetail),"OrderID","OrderID")] public List<OrderDetail> Details { get { return m_Details; } set { m_Details = value; } } |
这段代码表明，Details这个属性，由子对象OrderDetail的集合组成，其中，两个对象通过Order类的OrderID主键和OrderDetail的外键OrderID相关联。
四. 对继承的支持
Websharp框架在设计的时候，要求能够支持面向对象语言中的继承。Websharp支持三种继承模式：ONE_INHERITANCE_TREE_ONE_TABLE、ONE_INHERITANCE_PATH_ONE_TABLE和ONE_CLASS_ONE_TABLE。以如下的类结构为例：
ONE_INHERITANCE_TREE_ONE_TABLE
这种映射模式将具有相同父类的所有类都映射到一个数据库表中。数据库结构如下图：
Websharp中，只需要对每个类都指明具有相同值的TableMap特性就可以了。如下面的代码：
| [TableMap("Table1", "Property1")] public class Parent { private string property1; private string property2;
[ColumnMap("Column1", DbType.String)] public string Property1 { get { return property1; } set { property1=value; } }
[ColumnMap("Column2", DbType.String)] public string Property2 { get { return property2; } set { property2 = value; } } }
[TableMap("Table1", "Property1")] public class Child1 : Parent { private string property3;
[ColumnMap("Column3", DbType.String)] public string Property3 { get { return property3; } set { property3 = value; } } }
[TableMap("Table1", "Property1")] public class Child2 : Parent { private string property4;
[ColumnMap("Column4", DbType.String)] public string Property4 { get { return property4; } set { property4 = value; } } } |
此时，当按照如下的代码初始化一个Child1对象，
| Child 1 c 1 = new Child1(); c1.Property1 = "P11"; c1.Property2 = "P12"; c1.Property3 = "P13"; |
并保存到数据库中的时候，数据库中的记录应该是：
| Column1 |
Column2 |
Column3 |
Column4 |
| P11 |
P12 |
P13 |
NULL |
如果按照如下的代码初始化一个Child2对象：
| Child 2 c 1 = new Child2(); c2.Property1 = "P21"; c2.Property2 = "P22"; c2.Property4 = "P24"; |
并保存到数据库中的时候，数据库中的记录应该是：
| Column1 |
Column2 |
Column3 |
Column4 |
| P21 |
P22 |
NULL |
P24 |
ONE_INHERITANCE_PATH_ONE_TABLE
这种映射模式将一个继承路径映射到一个表，这种情况下的数据库的结构是：
这种情况下，实际上Parent类并不映射到实际的表，Child1和Child2类分别映射到Child1和Child2表。因此，在这种情况下，需要把Parent类的TableMap特性设置为Null，而Child1和Child2类的TableMap特性分别设置为Child1和Child2，代码如下面所示：
| [TableMap(null, "Property1")] public class Parent { private string property1; private string property2;
[ColumnMap("Column1", DbType.String)] public string Property1 { get { return property1; } set { property1=value; } }
[ColumnMap("Column2", DbType.String)] public string Property2 { get { return property2; } set { property2 = value; } } }
[TableMap("Child1", "Property1")] public class Child1 : Parent { private string property3;
[ColumnMap("Column3", DbType.String)] public string Property3 { get { return property3; } set { property3 = value; } } }
[TableMap("Child2", "Property1")] public class Child2 : Parent { private string property4;
[ColumnMap("Column4", DbType.String)] public string Property4 { get { return property4; } set { property4 = value; } } } |
此时，当按照如下的代码初始化一个Child1对象，
| Child 1 c 1 = new Child1(); c1.Property1 = "P11"; c1.Property2 = "P12"; c1.Property3 = "P13"; |
并保存到数据库中的时候，数据库中应该只在Child1表中添加下面的数据：
| Column1 |
Column2 |
Column3 |
| P11 |
P12 |
P13 |
如果保存的是一个Child2对象，那么，应该只在Child2表中添加数据。Child1表和Child2表是互相独立的，并不会互相影响。
ONE_CLASS_ONE_TABLE
这种映射模式将每个类映射到对应的一个表，对于上面的类结构，数据库的结构是：
这种映射模式，我们只需要分别对每个类设定各自映射的表就可以了。代码如下面所示：
| [TableMap("Parent", "Property1")] public class Parent { private string property1; private string property2;
[ColumnMap("Column1", DbType.String)] public string Property1 { get { return property1; } set { property1=value; } }
[ColumnMap("Column2", DbType.String)] public string Property2 { get { return property2; } set { property2 = value; } } }
[TableMap("Child1", "Property1")] public class Child1 : Parent { private string property3;
[ColumnMap("Column3", DbType.String)] public string Property3 { get { return property3; } set { property3 = value; } } }
[TableMap("Child2", "Property1")] public class Child2 : Parent { private string property4;
[ColumnMap("Column4", DbType.String)] public string Property4 { get { return property4; } set { property4 = value; } } } |
此时，当按照如下的代码初始化一个Child1对象，
| Child 1 c 1 = new Child1(); c1.Property1 = "P11"; c1.Property2 = "P12"; c1.Property3 = "P13"; |
并保存到数据库中的时候，数据库中的记录应该是：
Parent表：
| Column1 |
Column2 |
| P11 |
P12 |
Child1表：
| Column1 |
Column3 |
| P11 |
P13 |
同样的，如果保存的是一个Child2对象，那么，将在Parent表和Child2表中添加记录。
五. PersistenceManager
Websharp O/R Mapping框架的操作核心，在于PersistenceManager接口，对实体对象的操作，包括增、删、改的操作，都是通过这个接口来进行的。
PersistenceManager的定义如下：
| /** * 这个接口定义持久化操作的方法 * */ public interface PersistenceManager : IDisposable { /* * 关闭一个PersistenceManager。当一个PersistenceManager被关闭的时候，需要做如下的工作 * 1、释放它所管理的实体类，以及相关的状态。如果不释放，可能造成内存泄露 * 2、如果Flush方法没有被执行，则执行Flush方法。 * 3、释放数据库联接等资源。 * 4、从PersistenManagerfactroy中清除自己 */ void Close();
/** * 判断一个PersistenceManager是否已经关闭了。 */ bool IsClosed{get;}
/** * 获取PersistenceManager当前所处的事务 */ Transaction CurrentTransaction{ get;}
/** * 指示在默认的情况下，所有的操作是否忽略缓存。如果忽略缓存，那么，有的时候会存在一些不一致的情况，除非系统被禁止了缓存的使用 */ bool IgnoreCache{get;set;}
/** * 将一个新的实体对象转换成可持续对象，这个对象在事务结束的时候，会被Insert到数据库中 * 调用这个方法后，该对象的状态为EntityState.New * 如果一个对象的状态为EntityState.Persistent，则本方法将抛出一个EntityIsPersistentException异常 */ void PersistNew(object entity); void PersistNew(object entity,PersistOptions options);
/* * 将一个新的实体对象转换成可持续对象,并且指明要保存的属性 * */ void PersistNew(object entity, params string[] properties); void PersistNew(object entity, PersistOptions options, params string[] properties);
/** * 将一个实体对象保存到数据库中。 * 如果一个对象是Trasient的，则将其转换为EntityState.New状态。在事务结束的时候，会被Insert到数据库中 * 否则，其状态就是EntityState.Persist，就更新到数据库中。 * 如果一个Trasient对象实际上已经存在于数据库中，由于Persist方法并不检查实际的数据库，因此， * 调用这个方法，将会抛出异常。这个时候，应该使用先使用Attach方法，然后调用Persist。 * Persist方法主要用于已受管的对象的更新 */ void Persist(object entity); void Persist(object entity,PersistOptions options);
/** * 将一个实体对象保存到数据库中,并且指明要保存的属性 * */ void Persist(object entity,params string[] properties); void Persist(object entity,PersistOptions options,params string[] properties);
/** * 强制将一个实体更新到数据库中。 * 执行这个方法，将把对象的状态强制变为EntityState.Persist。 * 由于Update方法并不检查实际的数据库，因此如果一个对象实际上不存在于数据库中，那么，这个方法实际上 * 不会对数据库造成变化。 * 如果不能确认对象已经存在于数据库中，那么，应该使用先使用Attach方法。 */ void Update(object entity); void Update(object entity, PersistOptions options);
/** * 将一个实体对象更新到数据库中,并且指明要保存的属性 * */ void Update(object entity, params string[] properties); void Update(object entity, PersistOptions options, params string[] properties);
/** * 删除一个对象。 * 一个对象被删除后，其状态变成EntityState.Deleted，在事务结束的时候，会被从数据库中删除。 * 如果一个对象不是持久的，那么，这个方法将抛出异常。 * */ void Delete(object entity); void Delete(object entity,PersistOptions options);
/** * 将一个对象标记为可持续的。如果这个对象已经存在于实际的数据库中，那么，这个对象的状态就是 * EntityState.Persistent，否则，这个对象的状态就是EntityState.New。 * 注意：这个方法不会导致对数据库实际数据的更改 */ void Attach(object entity); void Attach(object entity,PersistOptions options);
/** * 重新从数据库中载入这个对象，这意味着重新给对象的各个属性赋值。 * */ void Reload(ref object entity); void Reload(ref object entity,PersistOptions options);
/** * 从缓存中把某个对象移除。 * */ void Evict (object entity); void EvictAll (object[] pcs); void EvictAll (IEnumerable pcs); void EvictAll ();
/** * 根据主键查找某个对象，如果主键是多个字段的，顺序必须同TableMapAttribute中的顺序相同,否则将有不可预测的事情发生 */ object FindByPrimaryKey(Type entityType,params object[] id); object FindByPrimaryKey(Type entityType, PersistOptions options, params object[] id); T FindByPrimaryKey T FindByPrimaryKey
/** *获取某个对象的状态。这个对象必须是受该PersistenceManager管理的，否则，抛出异常 */ EntityState GetState(object entity); ICollection GetManagedEntities();
/** * 本操作使对实体对象所作的更改立即生效。 */ bool Flush();
/// /// 该方法撤销前面所做的所有操作。 /// void Cancel(); /** * 创建Query对象。 * */ Query NewQuery(); Query NewQuery(Type entityType); Query NewQuery(Type entityType,string filter); Query NewQuery(Type entityType,string filter,QueryParameterCollection paramColletion);
Query Query Query } |
PersistenceManager接口的相应的方法的说明已经在上面列出了，也是一目了然的。额外需要说明的是，这些对对象的操纵，都是暂存在内存中，只有在调用了Flush方法后才生效，才会把对数据的改变保存到数据库中。调用Cancel方法，可以撤销这些操作。
六. 事务处理
Websharp框架提供了简单的事务处理的能力，这是通过Transaction接口来实现的。
Transaction接口的定义如下：
| public interface Transaction { void Begin(); void Commit(); void Rollback(); PersistenceManager PersistenceManager{get;} } |
这个接口定义的非常简单，就是提供了开始事务、提交或者回滚事务的方法。下面的例子说明了在Websharp里面如何使用事务：
| public void TransactionTest() { //设定环境 DatabaseProperty dbp = new DatabaseProperty(); dbp.DatabaseType = DatabaseType.MSSQLServer; dbp.ConnectionString = "Data Source=(local);Initial Catalog=WebsharpTest;Integrated Security=True";
//操作数据 PersistenceManager pm = PersistenceManagerFactory.Instance().Create(dbp); Product p0 = new Product("Name0", 100); pm.PersistNew(p0); Product p1 = new Product("Name1", 101); pm.PersistNew(p1); Transaction t = pm.CurrentTransaction; //获取当前事务对象 t.Begin(); //开始事务 pm.Flush(); t.Commit(); //提交事务 pm.Close(); } |
七. 对象查询
Websharp框架通过Query接口，提供对象查询的功能。Query接口的定义如下：
| public interface Query { Type EntityType{get;set;} string EntityTypeName{get;set;} string Filter{get;set;}
QueryParameterCollection Parameters{get;set;} string Ordering{get;set;}
bool IgnoreCache{get;set;}
ICollection QueryObjects(); DataSet QueryDataSet();
PersistenceManager PersistenceManager{get;}
bool IsClosed{get;} void Close(); //void Open(); } |
同时，Websharp提供了一个范型的版本，定义如下：
| public interface Query { new ICollection } |
使用Query的一般步骤是：
1、 从PersistenceManager获得一个Query接口
2、 设定Query接口要查询的类型、条件(Filter)和相应的参数
3、 执行QueryObjects方法，得到相应的对象集合。
下面的例子说明了使用Query的过程：
| public void NormalQuery() { DatabaseProperty dbp = new DatabaseProperty(); dbp.DatabaseType = DatabaseType.Oracle; dbp.ConnectionString = "Data Source=ORACLE1453;User Id=websharp;Password=websharp"; ApplicationConfiguration.FrameworkUssage = FrameworkUssage.Normal; ApplicationConfiguration.DefaultDatabaseProperty = dbp;
PersistenceManager pm = PersistenceManagerFactory.Instance().Create(); Query<Pencil> q = pm.NewQuery<Pencil>(); q.Filter = "Owner like :Owner"; QueryParameterCollection qpm = new QueryParameterCollection(1); QueryParameter qm = new QueryParameter(":Owner", "sunny"); qpm.Add(qm); q.Parameters = qpm; ICollection<Pencil> pencils = q.QueryObjects(); pm.Close(); } |
八. 配置文件
配置文件配置了Websharp运行时需要的一些信息，目前来说，在O/R Mapping部分，需要配置的是关于缓存的信息。在缓存部分，Websharp使用了微软的Enterprise工具中的缓存部分，因此，需要配置的信息同微软的Enterprise工具中的缓存部分一样。所需要添加的，就是缓存过期的策略部分，这个部分，在WebsharpExpirationPolicy中进行说明。配置文件的内容如下：
| xml version="1.0" encoding="utf-8" ?> <configuration> <configSections> <section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version= 2.0.0 .0, Culture=neutral, PublicKeyToken=null" /> <section name="WebsharpExpirationPolicy" type="Websharp.ORM.Service.WebsharpCofigurationHandler,Websharp.ORM.Service" /> configSections> <cachingConfiguration defaultCacheManager="Cache Manager"> <cacheManagers> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="Cache Manager" /> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="EntityCache" /> <add expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="Null Storage" name="SqlCache" /> cacheManagers> <backingStores> <add encryptionProviderName="" type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version= 2.0.0 .0, Culture=neutral, PublicKeyToken=null" name="Null Storage" /> backingStores> cachingConfiguration>
<WebsharpExpirationPolicy> <ExpirationPolicy ExpirationCheckInterval="60" AssemblyName="Microsoft.ApplicationBlocks.Cache" ClassName="Microsoft.ApplicationBlocks.Cache.ExpirationsImplementations.SlidingTime" /> WebsharpExpirationPolicy> configuration> |
Websharp默认使用的是时间过期清除缓存的策略，过期的时间，可以修改，单位为秒。
有一点另自己不满意的是，在配置文件部分，我依然使用了.Net Framewoork1.1时期的配置文件操作方式，不过这对系统并无丝毫影响。
九. 后记
设计Websharp时，在考虑映射方法的时候，曾经为使用XML文件还是Attribute来映射考虑了很长时间，最终还是选择了Attribute。用XML文件来作为映射手段，虽然这种使用方法很常见，但是，感觉使用起来非常不方便，我个人也时常为EJB和Hibernate里面的配置文件烦恼不已，而使用Attribute，明显感觉清爽了很多。这似乎也是未来的一个方向，这从EJB3.0的变化也可以看出。
Websharp O/R Mapping的结构设计，参考了JDO的很多东西，感觉在编程思想和面向对象方法的使用和讨论方面，Java阵营真是活跃的多。实际上，对于一个程序员来说，在对数个不同的技术都有了深入的了解以后，会发现自己对软件系统开发的看法有一种融会贯通的感觉。实现是一个方面，但同样重要的是结构。这两年，一直在同时做Java和.Net的开发，很多时候是跨两个平台的开发，从两个平台中都收获不少。没有感觉Java或者C#对一个程序员来说有什么区别。那些关于Java和C#孰优孰劣的争论真是没有必要，也很肤浅。当然，C#作为一种后出的语言，在语法设计上的确有不小精妙的地方，这也是我崇拜Anders Hejlsberg的原因，也是我使用C#来实现Websharp的原因。但对于一个系统的开发来说，这种语言上的差异是可以忽略不计的。语言不是重要的，重要的是编程的思想。
一个人开发一个框架，是一件累人的事情，有的时候自己几乎就要放弃。现在虽然终于有了一个阶段的成果，但是，有些地方可能没有经过严格的测试，因此，希望各位同仁在使用的过程中，如果发现问题，能够及时告诉我，以便于我及时修正问题。也希望有人如果感兴趣，我们一起来发展这个项目。
从此处下载全部源代码
在