Websharp.ORM3.0使用

Websharp.ORM3.0使用

Websharp.ORM 3.0 下载(包括源代码、Websharp.Editor工具和Websharp.Permission事例程序)

说明

为了演示Websharp.ORM的使用，源代码附带了一个Websharp.Demo项目，该项目可以您让快速的了解使用方法，该项目中使用到的数据模型如下：

实体映射配置

实体映射配置方法

关系型数据库中表的关系，主要体现在表的主、外键上。根据主外键把关联的两个表称作主表和从表，主表的主键和从表的外键之间有关联关系。

OO中主要用静态类之间的关系，UML把类之间的关系分为四种类型：

1，  关联（Association）

2，  依赖 (Dependency)

3，  实现

4，  泛化（Gerneralization）

OO中的关联再细分，可以分为聚合和组合。Websharp中一个实体和其他实体关联只有两种类型，分别是引用实体和从实体，引用关系对应聚合关系，使用ReferenceObjectAttribute标记；从实体对应组合关系，使用SubObjectAttribute来标记。类似数据库的主外键，ReferenceObject和SubObject都需要区别主对象和从对象，主键配置引用对象的主键，外键配置从对象的外键。

[Serializable()]
    [TableMap("Orders", "OrderUID")]
    public class Order
    {
        private Customer m_Customer;
        
        private List<OrderItem> m_OrderItems;
        
        [ReferenceObject(typeof(Customer), "CustomerUID", "CustomerUID")]
        public Customer Customer
        {
            get{ return this.m_Customer; }
            set { this.m_Customer = value; }
        }
        
        [SubObject(typeof(OrderItem), "OrderUID", "OrderUID")]
        public List<OrderItem> OrderItems
        {
            set { return this.m_OrderItems; }
            get { this.m_OrderItems = value; }
        }
    }

上面的Order实体分别有一个引用对象属性Customer和从对象属性OrderItems，Customer属性是一个Customer类型的引用对象，OrderItems属性是List<OrderItem>类型的从对象集合，配置这两种类型的属性都需要配置主从对象的主外键关系。Customer属性的ReferenceObject配置中主对象是Customer类型，在从对象是Order类型，主键配置Customer类型对应表的主键，引用键配置Order表对Customer表的引用外键。OrderItems属性在SubObject配置中的主对象是Order类型，从对象是OrderItem类型， 主键配置Order表的主键，引用键配置OrderItem表对Oder表的引用外键。

 

 

实体映射可以查看孙亚民Blog中这篇文章：http://www.cnblogs.com/sunnyym/archive/2006/12/15/592907.html

Websharp.ORM3.0的映射和孙亚民有两点不同：

一个是小的改进，原来一个实体映射到列使用ColumnMapAttribute，Websharp.ORM3.0

默认不配置也是进行映射的，这个时候属性名和列名相同，如果不同的话必须使用ColumnMapAttribute进行映射。默认情况下属性映射到一个列了，那么我实体属性不想映射到一个列怎么办呢？后来有加入了一个ExclusiveAttibute来实现这个功能。

说明：实际上这个默认的属性和ExclusiveAttibute也是孙亚民在Websharp2005中加的。

 

二是一个是Websharp.ORM3.0目前不处理继承，孙亚民在Websharp2005中是处理继承的，对于复杂的引用程序肯定要考虑继承的情况，Websharp.ORM3.0以后版本中会提供支持。

订单映射

[Serializable()]
    [TableMap("Orders", "OrderUID")]
    public class Order
    {
        private Int32 m_OrderUID;
        
        private DateTime m_AddDate;
        
        private User m_User;
        
        private Customer m_Customer;
        
        private List<OrderItem> m_OrderItems;
        
        public Order()
        {
        }
        
        /**//// <summary>
        /// OrderUID
        /// </summary>
        public Int32 OrderUID
        {
            get
            {
                return this.m_OrderUID;
            }
            set
            {
                this.m_OrderUID = value;
            }
        }
        
        /**//// <summary>
        /// AddDate
        /// </summary>
        public DateTime AddDate
        {
            get
            {
                return this.m_AddDate;
            }
            set
            {
                this.m_AddDate = value;
            }
        }
        
        /**//// <summary>
        /// User
        /// </summary>
        [ReferenceObject(typeof(User), "UserUID", "UserUID")]
        public User User
        {
            get
            {
                return this.m_User;
            }
            set
            {
                this.m_User = value;
            }
        }
        
        /**//// <summary>
        /// Customer
        /// </summary>
        [ReferenceObject(typeof(Customer), "CustomerUID", "CustomerUID")]
        public Customer Customer
        {
            get
            {
                return this.m_Customer;
            }
            set
            {
                this.m_Customer = value;
            }
        }
        
        /**//// <summary>
        /// OrderItems
        /// </summary>
        [SubObject(typeof(OrderItem), "OrderUID", "OrderUID")]
        public List<OrderItem> OrderItems
        {
            get
            {
                return this.m_OrderItems;
            }
            set
            {
                this.m_OrderItems = value;
            }
        }
    }

订单明细映射配置

 

/**//// <summary>
    /// OrderItem
    /// </summary>
    [Serializable()]
    [TableMap("OrderItems", "OrderItemUID")]
    public class OrderItem
    {
        
        private Int32 m_OrderItemUID;
        
        private Product m_Product;
        
        private Int32 m_Amount;
        
        private Decimal m_Price;
        
        private Int32 m_OrderUID;
        
        public OrderItem()
        {
        }
        
        /**//// <summary>
        /// OrderItemID
        /// </summary>
        public Int32 OrderItemUID
        {
            get
            {
                return this.m_OrderItemUID;
            }
            set
            {
                this.m_OrderItemUID = value;
            }
        }
        
        /**//// <summary>
        /// Product
        /// </summary>
        [ReferenceObject(typeof(Product), "ProductUID", "ProductUID")]
        public Product Product
        {
            get
            {
                return this.m_Product;
            }
            set
            {
                this.m_Product = value;
            }
        }
        
        /**//// <summary>
        /// Amount
        /// </summary>
        public Int32 Amount
        {
            get
            {
                return this.m_Amount;
            }
            set
            {
                this.m_Amount = value;
            }
        }
        
        /**//// <summary>
        /// Price
        /// </summary>
        public Decimal Price
        {
            get
            {
                return this.m_Price;
            }
            set
            {
                this.m_Price = value;
            }
        }
        
        /**//// <summary>
        /// OrderID
        /// </summary>
        public Int32 OrderUID
        {
            get
            {
                return this.m_OrderUID;
            }
            set
            {
                this.m_OrderUID = value;
            }
        }
    }

客户映射

/**//// <summary>
    /// Customer
    /// </summary>
    [Serializable()]
    [TableMap("Customers", "CustomerUID")]
    public class Customer
    {
        private Int32 m_CustomerUID;
        
        private String m_Name;
        
        public Customer()
        {
        }
        
        /**//// <summary>
        /// CustomerUID
        /// </summary>
        public Int32 CustomerUID
        {
            get
            {
                return this.m_CustomerUID;
            }
            set
            {
                this.m_CustomerUID = value;
            }
        }
        
        /**//// <summary>
        /// Name
        /// </summary>
        public String Name
        {
            get
            {
                return this.m_Name;
            }
            set
            {
                this.m_Name = value;
            }
        }
    }

基本增删改

   PersistenceManager<Order> orderPm = PersistenceManagerFactory.Instance.Create<Order>();
                User user = new User();
                user.UserUID = 1;
                Customer cusomer=new Customer();
                cusomer.CustomerUID=1;

                Order order = new Order();
                order.OrderUID = 1;
                order.User = user;
                order.Customer = cusomer;
                order.AddDate = DateTime.Now;
                order.OrderItems = new List<OrderItem>();

                Product product=new Product();
                product.ProductUID=1;


                OrderItem item = new OrderItem();
                item.OrderItemUID = 1;
                item.OrderUID = order.OrderUID;
                item.Price = 10;
                item.Product = product;
                item.Amount = 3;
                order.OrderItems.Add(item);

                item = new OrderItem();
                item.OrderItemUID = 2;
                item.OrderUID = order.OrderUID;
                item.Price = 10;
                item.Product = product;
                item.Amount = 3;
                order.OrderItems.Add(item);

                orderPm.PersistNew(order, PersistOptions.IncludeChildren);

事务处理

  // 声明事务类
            using (TransactionScope ts = new TransactionScope())
            {
                try
                {
                    PersistenceManager<Order> orderPm = PersistenceManagerFactory.Instance.Create<Order>();
                    PersistenceManager<OrderItem> orderItemPm = PersistenceManagerFactory.Instance.Create<OrderItem>();
                    User user = new User();
                    user.UserUID = 1;
                    Customer cusomer = new Customer();
                    cusomer.CustomerUID = 1;

                    Order order = new Order();
                    order.OrderUID = 2;
                    order.User = user;
                    order.Customer = cusomer;
                    order.AddDate = DateTime.Now;
                    order.OrderItems = new List<OrderItem>();

                    // 插入订单对象
                    orderPm.PersistNew(order);

                    Product product = new Product();
                    product.ProductUID = 1;

                    OrderItem item = new OrderItem();
                    item.OrderItemUID = 3;
                    item.OrderUID = order.OrderUID;
                    item.Price = 10;
                    item.Product = product;
                    item.Amount = 3;
                    order.OrderItems.Add(item);

                    // 插入第一个订单明细对象
                    orderItemPm.PersistNew(item);

                    // 抛出一个异常
                    throw new WebsharpException("some error!");

                    item = new OrderItem();
                    item.OrderItemUID = 4;
                    item.OrderUID = order.OrderUID;
                    item.Price = 10;
                    item.Product = product;
                    item.Amount = 3;
                    order.OrderItems.Add(item);

                    // 插入第二个订单明细对象
                    orderItemPm.PersistNew(item);

                    // 提交事务
                    ts.Complete();

                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }

查询

普通的查询

   PersistenceManager<User> userPm = PersistenceManagerFactory.Instance.Create<User>();

                string filter = "Name = @Name";
                QueryParameterCollection qpc = new QueryParameterCollection();
                QueryParameter qp = new QueryParameter();
                qp.DbType = DbType.String;
                qp.ParameterName = "@Name";
                qp.Value = "xufangbo";
                qpc.Add(qp);

                List<User> users = userPm.QueryObjects(filter,qpc);

查询从对象

              PersistenceManager<Order> orderPm = PersistenceManagerFactory.Instance.Create<Order>();
                
                Order order = new Order();
                order.OrderUID = 1;

                orderPm.FindByPrimaryKey(order);
                orderPm.GetChild<OrderItem>(order);

                this.dataGridView1.DataSource = order.OrderItems;

查询ManyToMany对象

               PersistenceManager<User> userPm = PersistenceManagerFactory.Instance.Create<User>();
                User user = new User();
                user.UserUID = 2;

                EntityList<Role> roles = userPm.QueryLinkObjects<Role>(user, typeof(UserRole));

查询主从对象

对于查询主从对象，可以通过先查询主对象集合，然后再使用循环分别查询从对象。这种情况适合数据量较少的时候，因为每次查询子对象导致连接数据库过多，性能不好。Websharp.ORM还提供了另外一种接口把数据读到DataSet中，这样解决性能问题。

PersistenceManager<Order> orderPm = PersistenceManagerFactory.Instance.Create<Order>();
DataSet ds = orderPm.QueryDataset(null, null, PersistOptions.IncludeChildren);

 

上面例子的查询中，得到的DataSet将会分别创建Order的DataTable和OrderItem的DataTable，并且还会为这两个表建立一个名为”Order_OrderItem”(EntityType.Name + "_" + SubObjectType.Name)的DataRelation。

同样这个查询接口也可以把Reference对象查询到对应的DataTable中，并且创建一个名为ReferenceType.Name + "_" + EntityType.Name的DataRelation。

其他

分页

DataTable转换

数据绑定

配置

<?xml version="1.0" encoding="utf-8" ?>
<configSections>
    <section name="Websharp.ORM" type="Websharp.ORM.Service.DataPropertyConfigurationHandler,Websharp.ORM.Service"/>
  </configSections>

  <Websharp.ORM>
    <DatabaseProperties>
      <DatabaseProperty name="MSSQLServer">
        <DataBaseType>MSSQLServer</DataBaseType>
       <ConnectionString>
server=(local);database=WebsharpTest;uid=sa;pwd=foolnet
</ConnectionString>
      </DatabaseProperty>
      <DatabaseProperty name="default">
        <DataBaseType>OleDBSupported</DataBaseType>
        <ConnectionString>Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Websharp.Permission.mdb;User ID=Admin;Password=;</ConnectionString>
      </DatabaseProperty>
      <DatabaseProperty name="oracle">
        <DataBaseType>Oracle</DataBaseType>
        <ConnectionString>Data Source=WebsharpTest;user id=foolnet;pwd=foolnet</ConnectionString>
      </DatabaseProperty>
    </DatabaseProperties>
    <!-- PersistenceManagerType { Cached, StoredAssemble }
                      -->
    <PersistenceManagerType NameSpace="Websharp.ORM.PersistenceManagerImp" Assembly="Websharp.Tool.dll">Cached</PersistenceManagerType>
    <!-- SqlCommandType {  Text, StoredProcedurey }
                    -->
    <SqlCommandType>Text</SqlCommandType>
    <OutPutSourceCode SourceCodePath="e:\temp">false</OutPutSourceCode>
  </Websharp.ORM>
</configuration>

上面的配置配置了三个数据库连接，默认情况下会使用名为“default”的数据库连接。

Websharp.ORM 3.0 下载(包括源代码、Websharp.Editor工具和Websharp.Permission事例程序)