NHibernate系列文章二十七：NHibernate Mapping之Fluent Mapping基礎（附程序下載）

摘要

從這一節起，介紹NHibernate Mapping的內容。前面文章都是使用的NHibernate XML Mapping。NHibernate XML Mapping是NHibernate最早最成熟的Mapping方法。其他的Mapping方法都是基於XML Mapping的思想進行的“變種”，要么暫時不能完全像XML Mapping那樣功能豐富。其他的Mapping方法目前包括：Fluent Mapping、Attribute Mapping和Mapping by Conventions。他們各自都有優缺點。使用者應該根據實際情況選擇適合自己項目的Mapping方式。

這篇文章介紹Fluent Mapping。本篇文章的代碼可以到Fluent NHibernate下載。

1、Fluent Mapping的優點

• Fluent Mapping提供了大量的Fluent API進行映射配置。相比XML Mapping，在代碼中進行配置能夠在編譯時發現很多問題。
• Fluent Mapping的可讀性更強，代碼更簡潔。
• Fluent Mapping將映射配置的類和實體映射類相分離，在一定程度上保持了實體類的簡潔性。
• Fluent Mapping使用Lamda表達式和靜態類型反射技術，不用寫大量常量字符串，避免了很多粗心的錯誤。

2、Fluent Mapping的缺點

• 在定義了實體類之后，需要另外定義一個實體映射類。
• 許多XML Mapping支持的功能，Fluent Mapping暫時不支持，需要等到Fluent Mapping新版本出來后才能支持。
• Fluent Mapping底層其實還是將代碼定義的映射翻譯成XML映射文件，因此在程序啟動的時候比XML Mapping稍慢。
• 如果數據庫表名稱和實體類名稱不一致，或者數據庫列名稱和屬性名稱不一致，還是需要用字符串的形式做映射，這基本是避免不了的。

3、程序演示

繼續使用以之前文章使用過的NHibernateDemoDB數據庫。

1）新建工程Demo.Fluent。

 2）新建Class Library，名稱為Demo.Fluent.Entities。移除Class1.cs文件。

3）在新建的工程中，使用NuGet安裝FluentNHibernate。

單擊“Install”按鈕，會出現Priview對話框，列出將要添加的引用。安裝FluentNHibernate將會安裝他所依賴的NHibernate和Isesi.Collections。

點擊“OK”按鈕。等上幾分鍾時間去喝口茶， 安裝完成之后Output將顯示Finished。

展開工程的Reference，看到已經將FluentNHibernate添加進來了。

4）添加Domain文件夾和Mapping文件夾。

5）在Domain文件夾內，添加實體類的抽象泛型基類Entity。

namespace Demo.Fluent.Entities.Domain
{
    public abstract class Entity<T> where T : Entity<T>
    {
        public virtual int Id { get; private set; }

        public override bool Equals(object obj)
        {
            var other = obj as T;
            if (other == null) return false;
            var thisIsNew = Equals(Id, 0);
            var otherIsNew = Equals(other.Id, 0);
            if (thisIsNew && otherIsNew)
            {
                return ReferenceEquals(this, other);
            }
            return Id.Equals(other.Id);
        }

        private int? oldHashCode;
        public override int GetHashCode()
        {
            // once we have a hashcode we'll never change it
            if (oldHashCode.HasValue)
            {
                return oldHashCode.Value;
            }
            // when this instance is new we use the base hash code
            // and remember it, so an instance can NEVER change its
            // hash code.
            var thisIsNew = Equals(Id, 0);
            if (thisIsNew)
            {
                oldHashCode = base.GetHashCode();
                return oldHashCode.Value;
            }
            return Id.GetHashCode();
        }

        public static bool operator ==(Entity<T> lhs, Entity<T> rhs)
        {
            return Equals(lhs, rhs);
        }
        public static bool operator !=(Entity<T> lhs, Entity<T> rhs)
        {
            return !Equals(lhs, rhs);
        }
    }
}

• 抽象基類Entity定義了實體類共有的Id屬性。
• 抽象基類Entity重寫了object類的Equals方法和GetHashCode方法，同時重載了運算符==和！＝。

6）在Domain文件夾下，添加值對象類Address類、Name類，實體類：Customer類、Product類和Order類。

Address類

namespace Demo.Fluent.Entities.Domain
{
    public class Address
    {
        public virtual string Street { get; set; }
        public virtual string City { get; set; }
        public virtual string Province { get; set; }
        public virtual string Country { get; set; }

        public bool Equals(Address other)
        {
            if (other == null) return false;
            if (ReferenceEquals(this, other)) return true;
            return Equals(other.Street, Street) &&
                Equals(other.City, City) &&
                Equals(other.Province, Province) &&
                Equals(other.Country, Country);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as Address);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                var result = Street.GetHashCode();
                result = (result * 397) ^ (City != null ? City.GetHashCode() : 0);
                result = (result * 397) ^ Province.GetHashCode();
                result = (result * 397) ^ Country.GetHashCode();
                return result;
            }
        }
    }
}

Name類

using System;

namespace Demo.Fluent.Entities.Domain
{
    public class Name
    {
        public string LastName { get; private set; }
        public string FirstName { get; private set; }

        public Name() { }

        public Name(string firstName, string lastName)
        {
            if (string.IsNullOrWhiteSpace(firstName))
            {
                throw new ArgumentException("First name must be defined.");
            }
            if (string.IsNullOrWhiteSpace(lastName))
            {
                throw new ArgumentException("Last name must be defined.");
            }
            FirstName = firstName;
            LastName = lastName;
        }

        public override int GetHashCode()
        {
            unchecked
            {
                var result = FirstName.GetHashCode();
                result = (result * 397) ^ LastName.GetHashCode();
                return result;
            }
        }

        public bool Equals(Name other)
        {
            if (other == null) return false;
            if (ReferenceEquals(this, other)) return true;
            return Equals(other.FirstName, FirstName) &&
                Equals(other.LastName, LastName);
        }

        public override bool Equals(object other)
        {
            return Equals(other as Name);
        }
    }
}

Address和Name兩個類注意兩點：

• 重寫了object類的Equals方法和GetHashCode方法。
• 因為是值對象類型，因此不繼承Entity類。

Customer類

using System;
using System.Collections.Generic;

namespace Demo.Fluent.Entities.Domain
{
    public class Customer : Entity<Customer>
    {
        public Customer()
        {
            MemberSince = DateTime.UtcNow;
        }

        public virtual Name Name { get; set; }
        public virtual double AverageRating { get; set; }
        public virtual int Points { get; set; }
        public virtual bool HasGoldStatus { get; set; }
        public virtual DateTime MemberSince { get; set; }
        public virtual CustomerCreditRating CreditRating { get; set; }
        public virtual Address Address { get; set; }

        private readonly IList<Order> orders; 22 
        public virtual IList<Order> Orders 24  { 25             get
 { 27                 return orders; 28  } 29  } 30     }

    public enum CustomerCreditRating
    {
        Excellent, VeryVeryGood, VeryGood, Good, Neutral, Poor, Terrible
    }
}

這里有六個需要注意的地方：

• Customer類繼承泛型類Entity<Customer>。
• 不用再在Customer類里定義Id屬性。
• 必須有一個無參數的構造函數，可以在這個構造函數中定義屬性的默認值。
• 集合屬性類型必須定義成接口類型，Fluent NHibernate通過反射生成Fluent對應的集合類型。
• 不能在構造函數中對集合屬性進行初始化。
• 所有成員函數（如果有的話）和成員屬性都以virtual修飾。

Product類

using System.Collections.Generic;

namespace Demo.Fluent.Entities.Domain
{
    public class Product : Entity<Product>
    {
        public virtual string ProductCode { get; set; }

        public virtual string ProductName { get; set; }

        public virtual string Description { get; set; }

        private readonly IList<Order> orders;

        public virtual IList<Order> Orders
        {
            get
            {
                return orders;
            }
        }
    }
}

Order類

using System;
using System.Collections.Generic;

namespace Demo.Fluent.Entities.Domain
{
    public class Order : Entity<Order>
    {
        public virtual DateTime Ordered { get; set; }
        public virtual DateTime? Shipped { get; set; }
        public virtual Address ShipTo { get; set; }
        public virtual Customer Customer { get; set; }

        private readonly IList<Product> products;

        public virtual IList<Product> Products
        {
            get
            {
                return products;
            }
        }
    }
}

7）在Mapping文件夾下，定義映射類AddressMap、NameMap、CustomerMap、ProductMap和OrderMap。

類名稱必須是值對象類型名稱或實體類名稱后面跟Map。

在映射類的無參構造函數內，調用Fluent NHibernate的API函數，定義映射。

AddressMap類

using Demo.Fluent.Entities.Domain;
using FluentNHibernate.Mapping;

namespace Demo.Fluent.Entities.Mapping
{
    public class AddressMap : ComponentMap<Address>
    {
        public AddressMap()
        {
            Map(x => x.Street).Length(100);
            Map(x => x.City).Length(100);
            Map(x => x.Province).Length(100);
            Map(x => x.Country).Length(100);
        }
    }
}

 NameMap類

using Demo.Fluent.Entities.Domain;
using FluentNHibernate.Mapping;

namespace Demo.Fluent.Entities.Mapping
{
    public class NameMap : ComponentMap<Name>
    {
        public NameMap()
        {
            Map(x => x.LastName).Not.Nullable().Length(10);
            Map(x => x.FirstName).Not.Nullable().Length(10);
        }
    }
}

• Address類和Name類都時值對象類，因此他們的映射類文件都繼承ComponetMap的泛型類。
• Map、Not.Nullable、Length都時Fluent NHibernate的API函數（見名知意），通過鏈式調用，對單個屬性進行映射定義。

CustomerMap類

using Demo.Fluent.Entities.Domain;
using FluentNHibernate.Mapping;

namespace Demo.Fluent.Entities.Mapping
{
    public class CustomerMap : ClassMap<Customer>
    {
        public CustomerMap()
        {
            Id(x => x.ID).GeneratedBy.Native(); 11             Component(x => x.Address); 12             Component(x => x.Name); 13             Map(x => x.Points);
            Map(x => x.HasGoldStatus);
            Map(x => x.MemberSince);
            Map(x => x.CreditRating).CustomType<CustomerCreditRating>();
            HasMany(x => x.Orders).Inverse().Cascade.AllDeleteOrphan().Fetch.Join(); 18         }
    }
}

• Customer類是實體類，繼承ClassMap的泛型類。
• Id方法定義主鍵屬性，調用Generate.Native()方法指出主鍵生成策略是indentity的。
• 對值對象類型的屬性，調用Component方法，定義映射。
• HasMany方法生成OneToManyPart對象，映射一對多關系。
• HasMany方法調用后面的一串方法：Cascade.AllDeleteOrphan().Fetch.Join()對應了XML映射響應的屬性。

關系映射的API方法：

一對一：HasOne

一對多：HasMany

多對對：HasManyToMany

ProductMap類

using Demo.Fluent.Entities.Domain;
using FluentNHibernate.Mapping;

namespace Demo.Fluent.Entities.Mapping
{
    public class ProductMap : ClassMap<Product>
    {
        public ProductMap()
        {
            Id(x => x.ID).GeneratedBy.Native();
            Map(x => x.ProductCode).Not.Nullable().Length(10);
            Map(x => x.ProductName).Not.Nullable().Length(50);
            Map(x => x.Description).Length(100);
            HasManyToMany(x => x.Orders).Table("ProductOrder").ParentKeyColumn("ProductId").ChildKeyColumn("OrderId").Cascade.AllDeleteOrphan();
        }
    }
}

• HasManyToMany方法生成ManyToManyPart對象，映射Many-to-Many關系。
• Table("ProductOrder").ParentKeyColumn("ProductId").ChildKeyColumn("OrderId")
• 上面連串方法調用定義了Many-to-Many映射的中間表表名。對於Product表，這個關系的主鍵列和外鍵列。
• 多對多關系映射默認生成的中間表的名稱是ProductToOrder。因此，這里要調用Table方法，用字符串定義中間表名稱。

OrderMap類

using FluentNHibernate.Mapping;

namespace Demo.Fluent.Entities.Domain
{
    public class OrderMap : ClassMap<Order>
    {
        public OrderMap()
        {
            Table("`Order`"); 10             Id(x => x.ID).GeneratedBy.Native();
            Map(x => x.Ordered);
            Map(x => x.Shipped);
            Component(x => x.ShipTo);
            References(x => x.Customer).Column("CustomerId").Cascade.SaveUpdate(); 15             HasManyToMany(x => x.Products).Table("ProductOrder").ParentKeyColumn("OrderId").ChildKeyColumn("ProductId").Cascade.All();
        }
    }
}

• Table方法定義映射的表名稱，因為Order是SQL Server關鍵字，因此調用此方法，傳入字符串"`Order`"作為表名稱。生成的SQL語句的表名稱字符串是"[Order]"。
• Many-to-One關系，實體類屬性用Reference方法定義，指定外鍵列名稱。 
• 在ProductMap類構造函數內已經定義了中間表名稱。因此，這里的Table("ProductOrder")可以省略。

8）添加用於測試的控制台應用程序Demo.Fluent.Console工程。

9）添加用於NHibernate設置的FluentConfig類。

using Demo.Fluent.Entities.Mapping;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;

namespace Demo.Fluent.Console
{
    class FluentConfig
    {
        const string connString = "server=localhost;" + "database=NHibernateDemoDB;" + "integrated security=SSPI;";

        public static ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                .Database(MsSqlConfiguration.MsSql2008.ConnectionString(connString))
                .Mappings(m => m.FluentMappings.AddFromAssemblyOf<CustomerMap>()) 17                 .BuildSessionFactory();
        }
    }
}

9）修改Program類。

using Demo.Fluent.Entities.Domain;
using NHibernate.Linq;
using System.Linq;

namespace Demo.Fluent.Console
{
    class Program
    {
        static void Main(string[] args)
        {
            var factory = FluentConfig.CreateSessionFactory();
            using (var session = factory.OpenSession())
            {
                var customer = session.Get<Customer>(2);
                System.Console.WriteLine("{0} {1}", customer.Name.LastName, customer.Name.FirstName);

                System.Console.WriteLine("order count: {0}",customer.Orders.Count());

                System.Console.WriteLine();
                System.Console.WriteLine("customers and their order count:");
                var queryCount = session.Query<Customer>().Select(c => new
                {
                    CustomerId = c.Id,
                    CustomerName = c.Name.FirstName + " " + c.Name.LastName,
                    Count = c.Orders.Count()
                });
                var listCount = queryCount.ToList();
                if (listCount.Count > 0)
                {
                    listCount.ForEach(o =>
                    {
                        System.Console.WriteLine("{0}-{1}: {2}", o.CustomerId, o.CustomerName, o.Count);
                    });
                }

                System.Console.WriteLine();

                System.Console.WriteLine("customers whose oders count greater than 2:");
                var queryCountGreater = session.Query<Customer>().Where(c => c.Orders.Count > 2);
                var listCountGreater = queryCountGreater.ToList();
                if (listCountGreater.Count > 0)
                {
                    listCountGreater.ForEach(o =>
                    {
                        System.Console.WriteLine("{0}-{1} {2}", o.Id, o.Name.FirstName, o.Name.LastName);
                    });
                }
            }
            System.Console.WriteLine();
            System.Console.WriteLine("Finished");
            System.Console.ReadLine();
        }
    }
}

這里寫了三個查詢用來測試。第一個查詢是通過Id查找Customer對象。第二個查詢使用Linq to NHibernate對Customer和訂單數量分組查詢。第三個查詢查找訂單數大於2的Customer信息。

執行程序，得到結果（與數據庫記錄有關）。

 

結語

雖然Fluent NHibernate目前還不是很成熟（比起XML Mapping來說），但是絕大部分Mapping功能都已經可以能滿足了。前面提過了他的優缺點，有興趣的可以到Fluent NHibernate官網http://www.fluentnhibernate.org上去查看更詳細的內容。