Castle.ActiveRecord初探

注：本文翻译自Castle的官方网站http://www.castleproject.org
有关Castle的更多内容请参阅李会军博客的系列文章
http://terrylee.cnblogs.com/archive/2006/04/28/castl_ioc_article.html

本文所用代码下载页面：
http://www.castleproject.org/activerecord/gettingstarted/index.html

配置要求

我们假定你安装了Castle Project assemblies以及自带的NHibernate assemblies，如果没有的话你可以下载安装MSI installer distribution(http://www.castleproject.org/castle/download.html)

本文假定你使用的是MSSQL Server 2003,不过NHibernate也支持其它的数据库.

如果你使用的是Visual Studio .Net,记得添加这些引用:

.Castle.ActiveRecord.dll
.Castle.Core.dll
.Castle.DynamicProxy.dll
.Iesi.Collections.dll
.log4net.dll
.NHibernate.dll

如果你使用的是其它的环境，务必在Castle安装目录里引用上述assemblies

创建数据库及表

我们将在数据库test里创建3个表:User, Blog 和 Post.你可以按如下构架创建或让ActiveRecord生成该构架.

                                                                                                图1

如你所见，User是孤立的表，而Blog 和 Post表是相互关联的，一个博客可以有很多文章，所以对blog来说是一对多关系，而对post来说是多对一关系.

                                                                                 图2

 创建类

现在我们要创建表的对应的类，你将看到这是多么的容易.首先我们创建最简单的User class:

创建User class

1.创建名为User的空类，添加using声明：

namespace BlogSample
{
    using System;
    using Castle.ActiveRecord;

    public class User
    {
    }
}

2.标明该类源自ActiveRecordBase，使用ActiveRecord特性:
namespace BlogSample
{
    using System;
    using Castle.ActiveRecord;

    [ActiveRecord]
    public class User : ActiveRecordBase
    {
    }
}

3.添加相应的域(field)和属性：

namespace BlogSample
{
    using System;
    using Castle.ActiveRecord;

    [ActiveRecord]
    public class User : ActiveRecordBase
    {
        private int id;
        private string username;
        private string password;

        public int Id
        {
            get { return id; }
            set { id = value; }
        }

        public string Username
        {
            get { return username; }
            set { username = value; }
        }

        public string Password
        {
            get { return password; }
            set { password = value; }
        }
    }
}

4.最后，添加特性以告知ActiveRecord这些属性的类别(也就是propertie, primary key 和 relationship).在此，我们将Id标记为primary key而余下的标记为property:

namespace BlogSample
{
    using System;
    using Castle.ActiveRecord;

    [ActiveRecord]
    public class User : ActiveRecordBase
    {
        private int id;
        private string username;
        private string password;

        [PrimaryKey]
        public int Id
        {
            get { return id; }
            set { id = value; }
        }

        [Property]
        public string Username
        {
            get { return username; }
            set { username = value; }
        }

        [Property]
        public string Password
        {
            get { return password; }
            set { password = value; }
        }
    }
}
这就完了，现在我们要创建Blog类和Post类，过程很简单，你自己试试吧.

创建Blog class

该Blog类简单易懂，不过还没有完，我们将创建一个连接Blog和Post的纽带，稍后你将看到.

namespace BlogSample
{
    using System;
    using System.Collections;

    using Castle.ActiveRecord;

    [ActiveRecord]
    public class Blog : ActiveRecordBase
    {
        private int id;
        private String name;
        private String author;

        public Blog()
        {
        }

        [PrimaryKey]
        public int Id
        {
            get { return id; }
            set { id = value; }
        }

        [Property]
        public String Name
        {
            get { return name; }
            set { name = value; }
        }

        [Property]
        public String Author
        {
            get { return author; }
            set { author = value; }
        }
    }
}

创建Post class

该Post类也很简单，我们也需要将其与Blog类联系起来.些许不同在于，Contents属性使用[Property(ColumnType="StringClob")]，这是必须的，因为该属性绑定到text字段.

namespace BlogSample
{
    using System;

    using Castle.ActiveRecord;

    [ActiveRecord]
    public class Post : ActiveRecordBase
    {
        private int id;
        private String title;
        private String contents;
        private String category;
        private DateTime created;
        private bool published;

        public Post()
        {
            created = DateTime.Now;
        }

        [PrimaryKey]
        public int Id
        {
            get { return id; }
            set { id = value; }
        }

        [Property]
        public String Title
        {
            get { return title; }
            set { title = value; }
        }

        [Property(ColumnType="StringClob")]
        public String Contents
        {
            get { return contents; }
            set { contents = value; }
        }

        [Property]
        public String Category
        {
            get { return category; }
            set { category = value; }
        }

        [Property]
        public DateTime Created
        {
            get { return created; }
            set { created = value; }
        }
    }
}

即使你第一次使用你也要承认用起来很简单，添加relationship也不难.

添加relationships

现在要告知ActiveRecord，类Blog 和 Post和有关联，对一对多关系要使用HasManyAttribute,而多对一关系要用BelongsToAttribute

对Post class使用BelongsTo

1.我们要在Post class里添加一个field 和 property以使Blog实例包含Post

    [ActiveRecord]
    public class Post : ActiveRecordBase
    {
        ...
       
        private Blog blog;
       
        ...

        public Blog Blog
        {
            get { return blog; }
            set { blog = value; }
        }

2.最后对属性添加BelongsToAttribute，以告知ActiveRecord这是一个多对一关系.注意，默认时字段名和属性名是一样的.此时字段名为BlogId，我们的属性名用的是Blog.

对Blog class使用HasMany

1.同样的，我们要向Blog class添加一个field 和 property，以包含所有的Post实例.

using System;
    using System.Collections;

    using Castle.ActiveRecord;

    [ActiveRecord]
    public class Blog : ActiveRecordBase
    {
        ...
       
        private IList posts = new ArrayList();
       
        ...

        public IList Posts
        {
            get { return posts; }
            set { posts = value; }
        }

2.向属性添加HasManyAttribute，以告知ActiveRecord这是一个一对多关系：

[HasMany(typeof(Post))]
public IList Posts
{
    get { return posts; }
    set { posts = value; }
}

HasManyAttribute有一些有用的特性用来更好的控制relationship行为。比如当2个类有关联时，它们之间就有一种"双边关系"(bidirectional relationship),那么由哪边来主导这种关系呢？你可能会想到将post添加到blog.Posts collection 集或使用Post.Blog属性。我要说的是就本例而言，使用Post.Blog是比较妥当的.为此，我们用Inverse属性:

[HasMany(typeof(Post), Inverse=true)]
public IList Posts
{
    get { return posts; }
    set { posts = value; }
}
   
我们也要定义其cascade行为.比如当用户删除blog时，NHibernate如何处理那些所属的post？我们的答案是全部删除：

[HasMany(typeof(Post), Inverse=true, Cascade=ManyRelationCascadeEnum.AllDeleteOrphan)]
public IList Posts
{
    get { return posts; }
    set { posts = value; }
}

另一件事你应该知道：Castle ActiveRecord会推断有外联关系的表和字段，这是因为另一边(比如Post class)有一个BelongsTo特性指向Blog.如果没有，你可以包含这些表和字段信息，比如下面：

[HasMany(typeof(Post),
    Table="Posts", ColumnKey="blogid",
    Inverse=true, Cascade=ManyRelationCascadeEnum.AllDeleteOrphan)]
public IList Posts
{
    get { return posts; }
    set { posts = value; }
}

接下来我们要启动framework并处理上述代码了

初始化framework

在调用任何类之前，Castle ActiveRecord必须要初始化.该过程只能执行一次且最好在程序启动时进行.就本例而言，由于我们的示例为WinForms 应用程序.我们必须要初始化ActiveRecord.

ActiveRecord也需要些许配置来告知使用哪个数据库。实际上当初始化NHibernate时，ActiveRecord也继承(pass on)了NHibernate配置.现在我们要决定如何存储配置信息.

配置ActiveRecord

当配置ActiveRecord以及如何保存储配置信息时，我们有多种选择.在官方文档里对对此做了详细阐述.为简单起见，我们使用一个简单的xml文件：

<?xml version="1.0" encoding="utf-8" ?>

<activerecord>

  <config>
    <add
        key="hibernate.connection.driver_class"       
        value="NHibernate.Driver.SqlClientDriver" />
    <add
        key="hibernate.dialect"                       
        value="NHibernate.Dialect.MsSql2000Dialect" />
    <add
        key="hibernate.connection.provider"           
        value="NHibernate.Connection.DriverConnectionProvider" />
    <add
        key="hibernate.connection.connection_string"   
        value="Data Source=.;Initial Catalog=test;Integrated Security=SSPI" />
  </config>
 
</activerecord>

注意：上述配置使用的是SQL Server 2000数据库.如果你使用的是其它数据库，你需要做相应的改动.具体信息请参阅Xml Configuration Reference(Xml Configuration Reference).

现在将上述内容保存为appconfig.xml(并存储在生成assembly的文件夹里)，如下的代码创建了一个

XmlConfigurationSource以加载上述配置信息.

namespace BlogSample
{
    using System.Windows.Forms;

    using BlogSample.UI;

    using Castle.ActiveRecord;
    using Castle.ActiveRecord.Framework.Config;

    public class App
    {
        public static void Main()
        {
            XmlConfigurationSource source = new XmlConfigurationSource("appconfig.xml");
        }
    }
}

初始化ActiveRecord

最后我们要通过加载配置信息来初始化ActiveRecord.我们也需要指定ActiveRecord的类型.我们可以指定一个assemblies、一个assemblies数组或一个type数组.为简单起见，我们用一个type数组：

namespace BlogSample
{
    using System.Windows.Forms;

    using BlogSample.UI;

    using Castle.ActiveRecord;
    using Castle.ActiveRecord.Framework.Config;

    public class App
    {
        public static void Main()
        {
            XmlConfigurationSource source = new XmlConfigurationSource("appconfig.xml");
           
            ActiveRecordStarter.Initialize( source, typeof(Blog), typeof(Post), typeof(User) );
        }
    }
}

此时我们就可以使用了(只要配置正确，数据库存在)

创建表

如果你还没有创建表的话，可以让ActiveRecord来为我们创建：

public class App
{
    public static void Main()
    {
        XmlConfigurationSource source = new XmlConfigurationSource("appconfig.xml");
       
        ActiveRecordStarter.Initialize( source, typeof(Blog), typeof(Post), typeof(User) );

        if (MessageBox.Show("Do you want to let ActiveRecord create the database tables?",
                              "Schema", MessageBoxButtons.YesNo, MessageBoxIcon.Question) ==

DialogResult.Yes)
        {
            ActiveRecordStarter.CreateSchema();
        }
    }
}

我们将在类里包含一些方法来执行更多的数据库相关操作.

使用类

如果你现在对ActiveRecord比较了解了的话，我们只需要使用我们创建好了的类.

创建第一个用户

我们的应用程序有一个登录窗口，你必须提供正确的用户名和密码才能运行余下的程序.但是数据库才刚刚创建，我们如何添加第一个用户呢？如下的代码创建了一个用户，它应该添加到main class，如下：

User user = new User("admin", "123");
user.Create(); 

但如果我们多次运行程序呢？一个比较好的解决办法是，只有在数据库里user为空才创建用户，我们可以统计现有的user，若为0，则创建用户"admin":

if (User.GetUsersCount() == 0)
{
    User user = new User("admin", "123");
    user.Create();
}

很明显，我们要向User class添加方法GetUsersCount：

[ActiveRecord("[User]")]
public class User : ActiveRecordBase
{
    ...
   
    public static int GetUsersCount()
    {
        return CountAll(typeof(User));
    }
}

login窗体

供登录的窗口如下：

 

                  图3

代码很简单，利用一个查找方法来看用户是否存在：

private void logInButton_Click(object sender, System.EventArgs e)
{
    User user = User.FindByUserName(loginText.Text);

    if (user == null)
    {
        MessageBox.Show(this, "User not found", "Error", MessageBoxButtons.OK,

MessageBoxIcon.Error);
        return;
    }

    if (user.Password != passwordText.Text)
    {
        MessageBox.Show(this, "Wrong password", "Error", MessageBoxButtons.OK,

MessageBoxIcon.Error);
        return;
    }

    DialogResult = DialogResult.OK;
    Hide();
}

为此，我们要包含一个FindByUserName方法：

using NHibernate.Expression;

[ActiveRecord("[User]")]
public class User : ActiveRecordBase
{
    ...
   
    public static User FindByUserName(string userName)
    {
        // Note that we use the property name, _not_ the column name
        return (User) FindOne(typeof(User), Expression.Eq("Username", userName));
    }
}

blog管理

该窗口允许添加、编辑、删除一个blog，同时还有一个窗口对选定blog所属的post进行管理.

                                                                                        图4

当你单击Add或选中一个现有的blog，将显示另一个窗体.

                                             

                                                                          图5

要填充blog列表，我们要选择所有的现有blog：

private void PopulateBlogList()
{
    blogsList.Items.Clear();

    foreach(Blog blog in Blog.FindAll())
    {
        ListViewItem item = blogsList.Items.Add(blog.Id.ToString());

        item.Tag = blog;

        item.SubItems.Add(blog.Name);
        item.SubItems.Add(blog.Author);
    }
}

为此我们要在Blog class里添加FindAll方法，此外我们还有添加一个方法获取主键值primary key：

[ActiveRecord]
public class Blog : ActiveRecordBase
{
    ...
   
    public static Blog[] FindAll()
    {
        return (Blog[]) ActiveRecordBase.FindAll(typeof(Blog));
    }

    public static Blog Find(int id)
    {
        return (Blog) ActiveRecordBase.FindByPrimaryKey(typeof(Blog), id);
    }
   
    ...

要向数据库添加一个新的blog，为此添加如下代码：

Blog blog = new Blog();
blog.Name = "My blog";
blog.Author = "hammett";
blog.Create();

假如你只记得blog的id值，我们可以：

Blog blog = Blog.Find(100); // Id that we know exists
blog.Name = "Different name";
blog.Author = "Different author";
blog.Update();

要删除一个blog实例，仅仅需要调用Delete方法即可.

posts管理

对post来说，我们需要将blog实例与创建的post关联起来：

currentPost.Blog = parentBlog;

currentPost.Title = titleText.Text;
currentPost.Contents = contentsText.Text;
currentPost.Category = categoryText.Text;
currentPost.Created = createdDtTime.Value;
currentPost.Published = publishedCheck.Checked;

currentPost.Save();

更多功能请参阅官方文档！