【转】【翻译】Code Only增强

2009-08-18 11:20 E2Home 阅读(463) 评论(0) 编辑收藏举报

【原文地址】Code Only Enhancements
【原文发表日期】 03 August 09 11:11

自从第一个预览版发布之后，我们一直在奋力增强Code Only功能。

在下一个版本中，你将能够指定

导航属性的倒转（Inverse）关系
属性的细节（Facets），象like Nullability（可null性）, MaxLength（最大长度）, Precision（精度）等等
属性与字段间的映射
类型与数据表间的映射
继承策略
配置的封装

本贴的余下部分将依次对这些特性进行详述。

注册导航属性的倒转关系：

你现在可以注册倒转关系，即一个导航属性到另一个导航属性的倒转（inverse）关系，象这样：

builder.RegisterInverse(
(Customer c) => c.Orders,
(Order o) => o.Customer)
);

这代码表示Customer.Orders是Order.Customer关系的另一头。把order1 加到customer1.Orders集合中去，与把order1.Customer设置成customer1具有同等的效果。

指定属性细节（Facets）：

你还可以指定属性的细节，即象Nullability（可null性）, MaxLength（最大长度）, Precision（精度）等等这样的东西，象这样：

var customerConfig = new EntityConfiguration<Customer>();
// 我们可以推断出ID是主键
// 但无法推断出它在插入时是在数据库生成的
customerConfig.ForProperty(c => c.ID)
              .Identity();
customerConfig.ForProperty(c => c.Name)
              .MaxLength(100)
              .NonUnicode();
customerConfig.ForProperty(c => c.Website)
              .MaxLength(200)
              .Nullable()

builder.Configure(customerConfig);

这把Customer类型配置成：

ID 属性是Identity字段，即在我们插入数据到数据库时，其值是由数据库计算出来的。
Name属性，其MaxLength为100个字符，是NonUnicode（非Unicode），即在SQL Server中是VARCHAR而不是NVARCHAR。
Website属性，其MaxLength为200个字符串，是Nullable。

这些细节是针对概念模型Conceptual Model，即CSDL)的，从那里，也传到数据库（即SSDL）。

封装细节配置

你可以创建一个EntityConfiguration<T>的继承类来封装所有这些配置。

例如：

public class CustomerConfig: EntityConfiguration<Customer>
{
    public CustomerConfig(){
       ForProperty(c => c.ID)
                 .Identity();
       ForProperty(c => c.Name)
                 .MaxLength(100)
                 .NonUnicode();
       ForProperty(c => c.Website)
                 .MaxLenght(200)
                 .Nullable();
    }
}

我们建议你创建象这样的类，而不是配置EntityConfiguration<>，因为封装的好处。

指定数据表名

在你使用Configure<T>(..) 时，实体框架为你推断出默认的映射，继承策略(TPH)和表名。

但如果你要指定表名，你可以这么做：

var customerConfig = new EntityConfiguration<Customer>();
// 象上面那样配置细节
...

// 用一个特定的表名注册配置
builder.Tables[“dbo.Custs”] = customerConfig;

指定映射：

如果你需要对映射更多的控制（例如，要映射到一个现有的数据库或者使用企业的命名规则），那么你可以象这样指定映射：

EntityMap<Customer> customerMap =
    Map.OfType<Customer>(
        c => new {
            cid = c.ID,
            c.Name,
            csite = c.Website
        }
    );

映射解释

这个映射表明，ID是映射到‘cid’字段，Name属性是保存到‘Name’字段，而Website是映射到‘csite’ 字段的。

没有被引用的属性是不会被持久化的，就象使用实体框架默认的代码生成时生成的部分类上的属性一样。

LINQ内涵句法（Comprehension Syntax）

你甚至也可以使用LINQ内涵句法来指定同样的事情：

EntityMap<Customer> customerMap =
    from c in Map.OfType<Customer>()
    select new {
            cid = c.ID,
            c.Name,
            csite = c.Website
        };

用映射指定细节（Facets）

在配置完映射后，你还可以象这样在映射上指定facets:

customerMap.ForProperty(c => c.ID)
           .Identity();
customerMap.ForProperty(c => c.Name)
           .MaxLength(100)
           .NonUnicode();
customerMap.ForProperty(c => c.Website)
           .MaxLenght(200)
           .Nullable();

指定数据表

最后一步是指派数据表映射。

builder.Tables[“dbo.Custs”] = customerMap;

至此，我们为Customer类指定了自定义表，映射和自定义facets。

指定继承：

CodeOnly默认所用的继承策略是Table Per Hierarchy （每个类分层结构共用一个数据表）(或 TPH)。

但如果你需要一个不同的策略，你需要动手配置相应映射

设想一下，如果你要映射三个类：Vehicle , Car 和 Boat，其中Car 和 Boat是从Vehicle继承而来，而Vehicle本身是个抽象类。

Table Per Hierarchy (TPH，每个类分层结构共用一个数据表)

如果你想要使用TPH做映射，你可以这么做：

var vehicleMap =
    Map.OfTypeOnly<Vehicle>(
        v => new {
            vid = v.ID,
            v.Name,
            vdesc = v.Description
            v.MaxPassengers,
        }
    ).Union(Map.OfTypeOnly<Car>(
        c => new {
            vid = c.ID,
            c.Name,
            vdesc = c.Description
            c.MaxPassengers,
            trans = c.Transmission,
            tspd = c.Topspeed,
            ccty = c.EngineCapacity,
            ncyld = c.NoCylinder,
            discriminator = “CAR”
        })
    ).Union(Map.OfTypeOnly<Boat>(
        b => new {
            vid = b.ID,
            b.Name,
            vdesc = b.Description
            b.MaxPassengers,
            lng = b.Length,
            b.HasSail,
            b.HasEngine
            discriminator = “BOAT”
        })
    );

builder.Tables[“dbo.vehicles”] = vehicleMap;

在TPH映射中：

OfTypeOnly() 用来创建映射片段。
然后，映射片段可以联合（union）起来，这样，它们就可以指派到一个表上（TPH中整个类分层结构共用一个数据表）。
每个非抽象类型需要一个鉴别器字段（discriminator column），该字段可以是任何名称，但类分层结构中的每个非抽象类型必须有一个不同的常数（即“CAR”）。
在映射继承类时，你必须重新映射基类中已经映射了的所有属性。

Table Per Type (TPT，每个类型一个表)

如果你想要使用Table Per Type （每个类型一个表）或TPT来映射同个类分层结构，你该这么做：

builder.Table[“dbo.Vehicles”]=
    Map.OfType<Vehicle>(
        v => new {
            vid = v.ID,
            v.Name,
            vdesc = v.Description
            v.MaxPassengers,
        }
    );

builder.Tables[“dbo.Cars”] =
    Map.OfType<Car>(
        c => new {
            cid = c.ID,
            trans = c.Transmission,
            tspd = c.Topspeed,
            ccty = c.EngineCapacity,
            ncyld = c.NoCylinders,
         }
     );

builder.Tables[“dbo.Boats”] =
    Map.OfType<Boat>(
        b => new {
            bid = b.ID,
            lng = b.Length,
            b.HasSail,
            b.HasEngine
        }
    );

在TPT映射中：

OfType<>()用于每个映射“片段”。
每个映射“片段”指派到不同的表上。
每个映射“片段”只映射在当前类上声明的属性，除非。。。
键属性必须在每个片段中映射（这允许参与该类型的表间的JOIN）。
没有鉴别器字段。

Table Per Class (TPC，每个类一个表，【译注】常规的说法是，每个非抽象类或每个具体类一个表)

你还可以象这样使用TPC来映射这个类分层结构：

builder.Tables[“dbo.Cars”] =
    Map.OfTypeOnly<Car>(
        c => new {
            cid = c.ID,
            c.Name,
            vdesc = c.Description
            c.MaxPassengers,
            trans = c.Transmission,
            tspd = c.Topspeed,
            ccty = c.EngineCapacity,
            ncyld = c.NoCylinders,
         }
     );

builder.Tables[“dbo.Boats”] =
    Map.OfTypeOnly<Boat>(
        b => new {
            bid = b.ID,
            b.Name,
            description = b.Description
            b.MaxPassengers,
            lng = b.Length,
            b.HasSail,
            b.HasEngine
        }
    );

在TPC映射中：

跟TPH一样，我们使用OfTypeOnly(..)。
但跟TPH不一样，每个非抽象的类型拥有自己的表（所以，Vehicle没有自己的表，因为它是个抽象类）。
每个映射片段重新映射每个持久（non-transient）属性。
类分层结构中的抽象类没有映射。
没有鉴别器字段。

默认的外键的位置：

如果我们看到一个引用（譬如Order.Customer），我们假定其多重性（multiplicity）为0..1。意即，其外键或FK是可null的。

如果我们看到一个集合（譬如Customer.Orders），我们假定其多重性为多（many）。

然后，在注册倒转（inverse）时，我们知道一个关系的两头的多重性，譬如，在上面的例子中，我们知道，每个Order可以有0..1个 Customer，每个Customer可以有多个Order。

所以按约定，共有三种主要的关系类型，我们需要推断出其FK的位置：

0..1 to many –> 按约定，我们把FK放在many一端，所以上面的Customer.Orders例子中， FK放在Orders 表上。

many to many –> 没什么选择，只能引进一个连接表（join table）。

0..1 to 0..1 –> 你可以配置FK应该在什么地方，但不配置的话，我们会引进一个连接表（join table）。

但有时候，引用可以不是0..1，而是1，例如，FK（不管它在什么地方），也许不可以null的。

你可以这样来指定FK不是nullable的：

var orderConfig = builder.Configure<Order>();
orderConfig.RegisterInverse(o => o.Customer, c => c.Orders);
orderConfig.ForProperty(o => o.Customer).NonNullable();

这告诉我们，每个Order正好有一个1个Customer，而每个Customer有多个Orders。

能够区分一个引用是非Nullable，会引进几个新的多重性组合，对此，我们也需要约定：

1 to many –> 按约定，我们把FK放在many的一端, 并且在数据库中将其设置为非nullable。

0..1 to 1 –> 按约定，我们把FK放在1的一端, 并且将其设置为非nullable。

1 to 1 –> 跟0..1 to 0..1一样，我们无法决定该把FK放在何处，所以按约定，我们要引进一个连接表（join table）。

指定外键（FK）映射：

至此，我们为实体的属性创建了映射。

那么导航属性和外键怎么办？

所有的关系类型（除了many to many）可以不用数据库中的连接表（join table）来建模，所以我们允许你象这样，作为EntityMap的一部分来映射外键：

EntityMap<Customer> customerMap =
    from c in Map.OfType<Customer>()
    select new {
            cid = c.ID,
            c.Name,
            csite = c.Website,
            salesPersonFK = c.SalesPerson.ID
        };

customerMap.RegisterInverse(c => c.SalesPerson, s => c.Clients);
builder.Tables[“dbo.Custs”] = customerMap;

这指定，Customer.SalesPerson导航属性，以及它的倒转（inverse）SalesPerson.Customers是保存在 dbo.Custs表的salesPersonFK字段中的。因为映射片段把 salesPersonFK 字段映射到了c.SalesPerson.ID上，而 SalesPerson.ID是相关的SalesPerson实体的主键（或者是主键的一部分），当然，外键是指向主键的。

指定连接表（Join Table）映射：

在many to many关系的情形下，你必须有一个连接表，所以按约定，没有映射信息，我们就会产生一个连接表(join table)。

但假如你需要更多的控制，你可以这么做：

var blogPostsMap = new AssociationMap<Blog, Post>(
b => b.Posts
).Map(
(b, p) => new {BlogId = b.ID, PostId = p.ID}
);

builder.Tables[“dbo.BlogPosts”] = blogPostsMap;

这是说， Blog 与 Post间的many to many关系是保存在dbo.BlogPosts表中的，它有2个字段：

‘BlogId’ 是个外键，指向Blog的ID属性映射到的字段。
‘PostId’ 是个外键，指向Post的ID属性映射到的字段。

分割实体（Entity Splitting）：

Code Only甚至还支持象分割实体这样高级的映射策略：

builder.Tables[“dbo.Customer”] = Map.OfType<Customer>(
   c => new {
      cid = c.ID,
      c.Name,
      active = c.IsActive
   }
);

builder.Tables[“dbo.CustomerDetails”] = Map.OfType<Customer>(
    c => new {
       cid = c.ID,
       c.Size,
       c.Industry
    }
);

这是说，Customer实体是分开保存在dbo.Customer和dbo.CustomerDetails两个表中的。

封装所有的配置：

你还可以编写一个类，从EntityMap<T>继承而来，含有所有的映射，facets等等。例如，下面是一个类，包含了Product的配置：

public class ProductMap: EntityMap<Product>
{
    public ProductMap{
         this.Map( p => new {
              pid = p.ID,
              pcode = p.Name,
              cid = p.Category.ID
         });
         this.ForProperty(p => p.ID).Identity();
         this.ForProperty(p => p.Name).MaxLength(100)
             .NonUnicode();
         this.ForProperty(p => p.Category).NonNullable();
         this.RegisterInverse(p => p.Category,
                              c => c.Products);
     }
}

这是个高度推荐的做法，因为配置Product类型变得容易之极：

builder.Tables[“dbo.Products”] = new ProductMap();

结束语：

正如你看到的，我们正在计划许多的增强，以允许最核心的场景。

你觉得怎么样？你喜欢这些API么？有什么东西你想要改变的？

一如既往，我们期待听到你的反馈。

Alex James
微软Entity Framework开发团队的Program Manager

本贴是Entity Framework开发团队的透明设计实践的一部分。想了解其工作原理，以及你的反馈是如何被使用的，请参阅 这个贴子。

推荐文章

刷新页面返回顶部

E2Home 利用网上的开源技术打造快速开发框架