Websharp使用说明

Websharp使用说明

一. 前言

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" ?>

</configSections>

<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>

<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>

</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对象，

Child1 c1 = new Child1();

c1.Property1 = "P11";

c1.Property2 = "P12";

c1.Property3 = "P13";

并保存到数据库中的时候，数据库中的记录应该是：

Column1	Column2	Column3	Column4
P11	P12	P13	NULL

如果按照如下的代码初始化一个Child2对象：

Child2 c1 = 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对象，

Child1 c1 = 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对象，

Child1 c1 = 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>(params object[] id);

T FindByPrimaryKey<T>(PersistOptions options, params object[] id);

/**

*获取某个对象的状态。这个对象必须是受该PersistenceManager管理的，否则，抛出异常

EntityState GetState(object entity);

ICollection GetManagedEntities();

/**

* 本操作使对实体对象所作的更改立即生效。

bool Flush();

/// <summary>

/// 该方法撤销前面所做的所有操作。

/// </summary>

void Cancel();

/**

* 创建Query对象。

Query NewQuery();

Query NewQuery(Type entityType);

Query NewQuery(Type entityType,string filter);

Query NewQuery(Type entityType,string filter,QueryParameterCollection paramColletion);

Query<T> NewQuery<T>();

Query<T> NewQuery<T>(string filter);

Query<T> NewQuery<T>(string filter, QueryParameterCollection paramColletion);

}

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<T> : Query

{

new ICollection<T> QueryObjects();

}

使用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" ?>

</configSections>

<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>

name="Null Storage" />

</backingStores>

</cachingConfiguration>

</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的原因。但对于一个系统的开发来说，这种语言上的差异是可以忽略不计的。语言不是重要的，重要的是编程的思想。

一个人开发一个框架，是一件累人的事情，有的时候自己几乎就要放弃。现在虽然终于有了一个阶段的成果，但是，有些地方可能没有经过严格的测试，因此，希望各位同仁在使用的过程中，如果发现问题，能够及时告诉我，以便于我及时修正问题。也希望有人如果感兴趣，我们一起来发展这个项目。

从此处下载全部源代码

posted on 2006-12-15 09:29 孙策阅读(11826) 评论(36) 编辑收藏举报