【原文地址】Feature CTP Walkthrough: Code Only for the Entity Framework
【原文发表日期】 22 June 09 02:54 PM

public class Category{    private List<Product> _products;    public int ID { get; set; }    public string Name { get; set; }    public virtual List<Product> Products {         get         {            if (_products == null)                _products = new List<Product>();            return _products;        }         set         {             _products = value;         }     }}

public class Product    {        public int ID { get; set; }        public string Name { get; set; }    }

public class ProductDBContext: ObjectContext{    public ProductDBContext(EntityConnection connection)        : base(connection, "ProductDBContext")    {        ContextOptions.DeferredLoadingEnabled = true;    }    public IObjectSet<Category> Categories    {        get { return CreateObjectSet<Category>(); }    }    public IObjectSet<Product> Products    {        get { return CreateObjectSet<Product>(); }    }}

SqlConnection connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=ProductDB;Integrated Security=SSPI;");using (ProductDBContext context = ContextBuilder.Create<ProductDBContext>(connection)){    if (!context.DatabaseExists())        context.CreateDatabase();    Category food = new Category { CID = 1, Name = "Food" };    Product bovril = new Product { ID = 1, Name = "Bovril" };    Product marmite = new Product { ID = 2, Name = "Marmite" };    Product vegemite = new Product { ID = 3, Name = "Vegemite" };    food.Products.Add(bovril);    food.Products.Add(marmite);    food.Products.Add(vegemite);    context.Categories.AddObject(food);    context.SaveChanges();    // Query the database    food = context.Categories.Single();    foreach (var product in food.Products)        Console.WriteLine(product.Name);}

public class Category{    private List<Product> _products;    public int CID { get; set; }    public string Name { get; set; }    public virtual List<Product> Products {         get         {            if (_products == null)                _products = new List<Product>();            return _products;        }         set         {             _products = value;         }     }}

var builder = new ContextBuilder<ProductDBContext>();builder.RegisterKey((Category c) => c.CID);

using (ProductDBContext context = builder.Create(connection))

【原文地址】Using Repository and Unit of Work patterns with Entity Framework 4.0
【原文发表日期】 16 June 09 04:08 PM

public interface ICustomerRepository{            Customer GetCustomerById(string id);    IEnumerable<Customer> FindByName(string name);    void AddCustomer(Customer customer);}

public CustomerRepository(NorthwindContext context){    if (context == null)        throw new ArgumentNullException("context");

   _context = context;} 

public Customer GetCustomerById(string id){    return _context.Customers.Where(c => c.CustomerID == id).Single();}

public IEnumerable<Customer> FindByName(string name){    return _context.Customers.Where( c => c.ContactName.StartsWith(name)                                   ).ToList();                        }

public void AddCustomer(Customer customer){    _context.Customers.AddObject(customer);}

public class CustomerRepository : ICustomerRepository{    private NorthwindContext _context;

    public CustomerRepository(NorthwindContext context)    {        if (context == null)            throw new ArgumentNullException("context");

         _context = context;    }

    public Customer GetCustomerById(string id)    {        return _context.Customers.Where(c => c.CustomerID == id).Single();    }

    public IEnumerable<Customer> FindByName(string name)    {        return _context.Customers.Where(c => c.ContactName.StartsWith(name))            .AsEnumerable<Customer>();                            }

    public void AddCustomer(Customercustomer)    {        _context.Customers.AddObject(customer);    }}

CustomerRepository repository = new CustomerRepository(context);Customer c = new Customer( ... );repository.AddCustomer(c);context.SaveChanges();

public interface IProductRepository{    Product GetProductById(int id);}

public interface IOrderRepository{    void AddOrder(Order order);}

public interface IUnitOfWork{            void Save();}

public class NorthwindContext : ObjectContext, IUnitOfWork{       public void Save()    {        SaveChanges();    }

. . . 

public class CustomerRepository : ICustomerRepository{    private NorthwindContext _context;

    public CustomerRepository(IUnitOfWork unitOfWork)    {        if (unitOfWork == null)            throw new ArgumentNullException("unitOfWork");

        _context = unitOfWork as NorthwindContext;    }

    public Customer GetCustomerById(string id)    {        return _context.Customers.Where(c => c.CustomerID == id).Single();    }

    public IEnumerable<Customer> FindByName(string name)    {        return _context.Customers.Where(c => c.ContactName.StartsWith(name))            .AsEnumerable<Customer>();    }

    public void AddCustomer(Customer customer)    {        _context.Customers.AddObject(customer);    }}

IUnitOfWork unitOfWork = new NorthwindContext();

CustomerRepository customerRepository = new CustomerRepository(unitOfWork);Customer customer = customerRepository.GetCustomerById("ALFKI");

ProductRepository productRepository = new ProductRepository(unitOfWork);Product product = productRepository.GetById(1);

OrderRepository orderRepository = new OrderRepository(unitOfWork);

Order order = new Order(customer); order.AddNewOrderDetail(product, 1);

orderRepository.AddOrder(order);

unitOfWork.Save();

【原文地址】POCO in the Entity Framework : Part 3 – Change Tracking with POCO
【原文发表日期】 10 June 09 08:43 AM

Customer customer = (from c in context.Customers                     where c.CustomerID == "ALFKI"                     select c).Single();

ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(customer);

Console.WriteLine("Customer object state: {0}", ose.State); // Unchanged

customer.Country = "UK";

Console.WriteLine("Customer object state: {0}", ose.State); // Still Unchanged

Customer customer = (from c in context.Customers                     where c.CustomerID == "ALFKI"                     select c).Single();

ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(customer);

Console.WriteLine("Customer object state: {0}", ose.State); // Unchanged

customer.Country = "UK";

Console.WriteLine("Customer object state: {0}", ose.State); // Modified

Customer customer = (from c in context.Customers                     where c.CustomerID == "ALFKI"                     select c).Single();

ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(customer);

Console.WriteLine("Customer object state: {0}", ose.State); // Unchanged

customer.Country = "UK";Console.WriteLine("Customer object state: {0}", ose.State); // Still Unchanged

context.DetectChanges();Console.WriteLine("Customer object state: {0}", ose.State); // Modified

[Flags]public enum SaveOptions{    None = 0,    DetectChangesBeforeSave = 1,    AcceptChangesAfterSave = 2,}

public virtual int SaveChanges(SaveOptions options);

【原文地址】POCO in the Entity Framework : Part 2 – Complex Types, Deferred Loading and Explicit Loading
【原文发表日期】 28 May 09 09:03 AM

在上星期的贴子《POCO Experience in Entity Framework》 （实体框架中的POCO体验）中，我讨论了Entity Framework 4.0中POCO支持的基本。在这个贴子里，我将讨论与POCO相关的另外几个方面。

复杂类型（Complex Types）

POCO中的复杂类型支持跟常规的基于EntityObject的实体中的复杂类型支持一样。你要做的就是将它们声明为POCO类，然后在你的POCO实体中使用和声明基于它们的属性。

作为例子，这里是一个InventoryDetail复杂类型，代表我的Product实体的一个部分：

public class InventoryDetail{    public Int16 UnitsInStock { get; set; }    public Int16 UnitsOnOrder { get; set; }    public Int16 ReorderLevel { get; set; }} 

把我的Product类修改成包含一个这个类型的属性，用来组合几个有关库存细节的字段：

public class Product{    public int ProductID { get; set; }    public string ProductName { get; set; }    public int SupplierID { get; set; }    public string QuantityPerUnit { get; set; }    public decimal UnitPrice { get; set; }    public InventoryDetail InventoryDetail { get; set; }    public bool Discontinued { get; set; }    public Category Category { get; set; }}

然后你可以做你以前对复杂类型所能做的一切，这是一个查询的例子：

var outOfStockProducts = from c in context.Products                         where c.InventoryDetail.UnitsInStock == 0                         select c;

你可以看到，POCO中的复杂类型支持用起来非常直截了当。但在POCO中使用复杂类型支持时，你需要记住几件事情：

1. 你必须将复杂类型定义为类（class），结构体（struct）是不支持的。
2. 在你的复杂类型类中，你不能使用继承。

既然在讨论复杂类型，我想我要提一下另外一件事，你知道Visual Studio 2010中的实体框架设计器支持复杂类型的声明么？

在Visual Studio 2008中，你只能手工将复杂类型的声明加到CSDL中去，但随着Visual Studio 2010中的设计器中对复杂类型支持的推出，这一切都成了历史。

更酷的是，因为Visual Studio 2010支持多定向（Multi-Targeting），你可以在开发针对.NET Framework 3.5，使用了Entity Framework 3.5的应用中也使用这个功能！

延迟/懒式装载

在我2个星期前发表的《延迟装载初览》一文中，我提到了实体框架现在支持延迟装载了。默认的、代码生成的基于EntityObject的实体类型将提供延迟装载，自然毫不奇怪。如果你想知道POCO对象中是否也支持延迟装载，那么我想，你会很高兴地知道，你在POCO中也能得到延迟装载支持。

为在POCO实体中使用延迟装载支持，你需要做2件事情：

1. 将你想要懒式装载的属性声明为virtual，这些属性可以是任何实现了ICollection<T> 的集合类，或者它们可以是代表了1/0..1 关系的引用。

例如，这里是更新过的Category实体类的部分代码，我将其改成支持延迟装载了：

public class Category{    public int CategoryID { get; set; }    public string CategoryName { get; set; }    public string Description { get; set; }    public byte[] Picture { get; set; }    public virtual List<Product> Products { get; set; }    ...

     2.   在上下文中启用延迟装载选项：

context.ContextOptions.DeferredLoadingEnabled = true;

这就行了，你现在就将得到POCO类型的自动延迟装载，而不用做任何其他什么事情。

那么这玩意到底是怎么工作的，底层是怎么进行的？

这玩意能工作的原因是因为，在我将集合类型的属性标记为virtual后，这允许实体框架在运行时为我的POCO类型提供一个代理（proxy） 实例，正是这个代理实现了自动的延迟装载。该代理实例是基于一个继承自我的POCO实体类的类型，所以你提供的所有功能都被保留下来了。从开发人员的角度来看，即使延迟装载或许是个需求，这也允许你编写透明持久性的代码。

如果你在调试器中检查实际的实例时，你会看到该实例的底层类型与我原先声明的类型是不同的：

虽然实体框架尽力以最小的摩擦提供自动的延迟装载，但在处理你想要添加或附加手工生成的实例时，或者当你序列化/发序列化实例时，这是你需要知道的事情。

为POCO实体手工生成代理实例

为了允许可以添加或附加的代理实例的生成，你可以使用ObjectContext上的CreateObject工厂方法来生成实体实例：

Category category = context.CreateObject<Category>();

要把这个记住，在生成你想要用于实体框架的实例时，要使用CreateObject。

用“变动跟踪代理（Change Tracking Proxies）”来提供更有效的变动跟踪

到目前为止，我们讨论过的标准POCO实体都依赖于基于快照（snapshot）的变动跟踪，即，实体框架会保管实体变动之前的值和关系的快照，这样，在保存（Save）时，可以与当前的值做比较。但这个比较的花销是相当大的，如果跟基于EntityObject的实体的变动跟踪的方式相比的话。

还有另外一种类型的代理，它允许你在使用POCO实体时得到比较好的变动跟踪性能。

如果你熟悉IPOCO接口，你知道IEntityWithChangeTracker是要求你在类中实现、来向实体框架提供变动通知的接口之一。

变动跟踪代理从你的POCO实体类继承而来，在运行时给你提供这个功能，而不要求你自己实现IPOCO接口。

从许多方面讲，用这种方式的话，你是鱼与熊掌都兼得了：你得到了POCO类的透明持久性，在变动跟踪方面你也得到了EntityObject / IPOCO 的性能。

为了得到变动跟踪代理，基本的规则是，你的类必须是公开的，非抽象的或者非密封的（non-sealed）。你的类对所有要持久的属性都必须实现公开的virtual getters/setters。最后，你必须将基于集合的关系导航属性严格声明为ICollection<T>。它们不能是具体的实现或者继承自ICollection<T>的另外的接口（与延迟装载代理有所不同）。

这里是我的Product POCO类的例子，它将在运行时给我提供更有效的基于代理的变动跟踪：

public class Product{    public virtual int ProductID { get; set; }    public virtual string ProductName { get; set; }    public virtual int SupplierID { get; set; }    public virtual string QuantityPerUnit { get; set; }    public virtual decimal UnitPrice { get; set; }    public virtual InventoryDetail InventoryDetail { get; set; }    public virtual bool Discontinued { get; set; }    public virtual Category Category { get; set; }}

再说一遍，要记住，如果你要将实体加到或附加到上下文的话，你必须使用CreateObject来生成代理实例。但不依赖代理的纯粹的POCO实体和基于代理的实体可以共处。你只有在涉及基于代理的实体时才需使用CreateObject。

如果我想在同个POCO类型中同时启用延迟装载和更好的变动跟踪，该怎么办？

这两个东西不是互相排斥的，你不必在延迟装载代理和变动跟踪代理间做选择。如果你想要延迟装载，以及有效的变动跟踪，你只要按照变动跟踪代理的规则办，以及启用延迟装载选项。变动跟踪代理会给你提供延迟装载，如果延迟装载选项是启用了的话。

显式装载

这个延迟装载的功能确实很棒，但你们中很多人大概想要完全控制你是如何装载相关实体的吧。你甚至会选择走纯粹的POCO之路，而不诉诸于任何自动代理生成能给你提供的功能。

这是完全可以接受的，（在很多情形下也许是更好的方法），你可以使用显式关系装载，对你是如何在数据库中查询数据的做完全的控制。

在POCO中做显式装载，有2个选项：

一个是使用 ObjectContext.LoadProperty ，设置你想要装载的导航属性的名称：

context.LoadProperty(beveragesCategory, "Products");

这是可行的，但你可以看出来，这并不类型安全（type safe）。如果我没有正确的导航属性的名称的话，我会得到一个运行时异常。

你们中的一些人大概更喜欢这个：

context.LoadProperty(beveragesCategory, c => c.Products);

我可以使用lambda表达式来指定我想要显式装载的属性，这提供了更好的类型安全。

上面是我计划在这第二个贴子里讨论的所有的内容了。但以后还会有更多内容，在这个系列的最后一篇里，我们将讨论在处理纯POCO（非代理化的）实例以及在你的对象图和对象状态管理器（Object State Manager）间保持一致时需要知道的几件事情。我们也会讨论你也许想要知道的SaveChanges方法的多个变种。

与此同时，请看一下我更新过的样例代码，其中包括了我们在本贴里讨论过的一些东西。

Faisal Mohamood

Entity Framework的Program Manager

【译者按】 Entity Framework 1.0 发布也有一段时间了，但感觉用的人很少。其中一个很大的原因，也许就是不支持POCO。要知道，Entity Framework 1.0的做法是让你的实体从EF的基类继承而来，这对很多人，特别是崇尚DDD的人来说，那是一副难以下咽的药啊。曾有微软开发人员提供了一个 POCO Adapter，但那究竟不是正规的做法。Visual Studio 2010 和 .NET 4.0 提供了许许多多的新特性，真是让人激动，向往，大有一种回到.NET 1.0 刚出来时的感觉。春天啊（应该是夏天啊），你终于回来了（虽然早晨/晚上还是unseasonably冷）。其中的Entity Framework 4.0版本将提供POCO支持，对很多人来说，这是开始使用Entity Framework的时候了。ADO.NET 团队博客上贴出了一些关于EF和POCO的贴子，非常值得一读。

【原文地址】POCO in the Entity Framework: Part 1 – The Experience
【原文发表日期】 21 May 09 05:46 PM

上个星期，我在《POCO初览》中提到了POCO实体支持是我们加到Entity Framework 4.0中的新功能之一。这个星期，我要对Entity Framework 4.0中POCO支持的细节进行深入讨论。

要讨论的东西很多，包括

• Entity Framework 4.0中总的POCO体验
• POCO的变化跟踪
• 关系修整
• 复杂类型
• 延迟（懒式）装载和显式装载
• 最佳实践

在这个贴子中，我将主要着重于总的体验，这样，你可以马上启用Entity Framework 4.0中的POCO支持。我将使用一个简单的例子做示范，这样，你可以看到在Entity Framework 4.0中使用POCO的感觉。我将使用Northwind数据库，在随后的贴子中，将继续建立在这个例子的基础之上。

第一步： 创建模型，关闭默认的代码生成

虽然POCO允许你以透明持久化的方式编写自己的实体类，但还是有必要“接入”持久性和EF元数据，这样你的POCO实体可以从数据库中复原，以及持久化到数据库中。为实现这个，你还是需要使用实体框架设计器创建一个实体数据模型（Entity Data Model），或者提供跟你在Entity Framework 3.5中生成的完全一样的CSDL, SSDL 和 MSL 元数据文件。所以，首先，我将使用ADO.NET实体数据模型向导（Entity Data Model Wizard）来生成一个EDMX。

1. 创建一个类库项目来定义你的POCO类型，我将其命名为NorthwindModel。这个项目与持久性毫不相关，对实体框架没有依赖性。
2. 创建一个类库项目，它将包含与持久性相关的代码，我将其命名为NorthwindData。这个项目除了对NorthwindModel项目有依赖外，还对实体框架(System.Data.Entity)有依赖。
3. 在NorthwindData 项目中添加新项，加一个名为“Northwind.edmx ”的ADO.NET实体数据模型（这么做将自动在项目中添加对实体框架的依赖）。
4. 选择“从数据库生成”，给Northwind数据库建造模型
5. 暂时只选Categories和Products这两个你感兴趣的表到你的实体数据模型中。

至此，生成了可以为我所用的实体数据模型，但在开始编写代码前，还有最后一步：关闭代码生成。毕竟你感兴趣的是POCO啊，请去除负责从Northwind.edmx生成基于EntityObject代码的Custom Tool（自定义工具）属性，这将关闭你的模型的相应代码生成。

现在，我们可以编写POCO实体了。

第二步： 编写你的POCO实体

我将为Category和Product编写简单的POCO实体，这些类将加到NorthwindModel项目中去。注意，我在这里展示的，不应该看成是最佳实践，这里的意图只是示范可以工作的最简单的例子。在以后我们将根据需要将对这些例子进行扩展和定制，之后建立在其基础之上，使用Repository和Unit of Work模式做进一步的扩展。

这里是Category实体的样例代码：

    public class Category
    {
        public int CategoryID { get; set; }
        public string CategoryName { get; set; }
        public string Description { get; set; }
        public byte[] Picture { get; set; }
        public List<Product> Products { get; set; }
    }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

注意，在模型中我既为标量字段定义了属性，也定义了导航属性。模型中的导航属性（Navigation Property）转换成了List<Product>。

类似地，Product实体可以这样编写：

    public class Product
    {
        public int ProductID { get; set; }
        public string ProductName { get; set; }
        public int SupplierID { get; set; }
        public string QuantityPerUnit { get; set; }
        public decimal UnitPrice { get; set; }
        public Int16 UnitsInStock { get; set; }
        public Int16 UnitsOnOrder { get; set; }
        public Int16 ReorderLevel { get; set; }
        public bool Discontinued { get; set; }
        public Category Category { get; set; }
    }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

在这个例子中，因为其间的关系，一个Product只允许属于一个Category，因此我们有一个对Category的引用（而不象Category中的导航属性，是一个List<T>集合）。

第三步： 编写你的实体框架上下文

为把所有这些东西结合在一起，我所要做的最后一件事情是，提供一个上下文实现（就象使用默认的代码生成时你得到的ObjectContext实现一样）。上下文（context）是把持久化意识带进你的应用的胶水（glue），它允许你编写查询，将实体复原，以及将变化存回到数据库中去。该上下文将是NorthwindData项目的一部分。

为简单起见，我将我们的上下文类包括在了包含实体类型的同个类库项目中了，但在我们讨论诸如Repository 和Unit of Work等模式时，我们将做这样的设置，即，你将拥有一个纯粹的POCO类库，不带任何一丝与持久性相关的东西。

这里是针对我们场景的简单的上下文实现：

public class NorthwindContext : ObjectContext
    {
        public NorthwindContext() : base("name=NorthwindEntities", "NorthwindEntities")
        {
            _categories = CreateObjectSet<Category>();
            _products = CreateObjectSet<Product>();
        }

        public ObjectSet<Category> Categories
        {
            get
            {
                return _categories;
            }
        }
        private ObjectSet<Category> _categories;

        public ObjectSet<Product> Products
        {
            get
            {
                return _products;
            }
        }
        private ObjectSet<Product> _products;
    }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

注意，ObjectSet<T> 是Entity Framework 4.0中引进的一个特殊的ObjectQuery<T>。

就这么简单！现在你有了纯粹的POCO实体，一个简单的上下文，允许你编写象这样的查询：

    NorthwindContext db = new NorthwindContext();

    var beverages = from p in db.Products
                    where p.Category.CategoryName == "Beverages"
                    select p;

从数据库中复原的实体是纯粹的POCO实体，你可以对这些实体做变动，将变动保存到数据库中，跟平常的EntityObject或IPOCO实体非常类似。你将得到实体框架提供的所有服务，唯一的区别是，你现在使用的是纯粹的POCO实体。

就我们的简化了的例子而言，尚有无数改进的可能性。但在那之前，我想先把一些基本的问题解决掉。

在使用POCO之前我需要一个实体数据模型么？

是的，Entity Framework 4.0中的POCO支持只是去除了在你的实体类中带特定于持久性的关注的需求而已。但还是需要你提供CSDL/SSDL/MSL (总称EDMX)元数据，这样实体框架才能够将你的实体和元数据结合起来，以允许你访问数据。我们还在另外开发一个东西，它允许你做真正的“代码优先（code-first）”的开发，而不需要预先定义好的EDMX模型。这个功能的社区预览版将在几个月内在网上发布，一有机会我们就会将其加入实体框架。一如既往，你的反馈对我们极其有用。

我始终都只能手写这些实体和上下文么？

不， Entity Framework 4.0中有一个非常强大和灵活的代码生成机制，该机制是基于T4之上的（Alex曾在这里的博客上讨论过）。你可以提供你自己的模板，允许你按照你自己选择的方式建造实体。我们还在努力，以提供一些标准的模板，可为你生成POCO实体。

使用POCO实体时，元数据是怎么映射的？

在Entity Framework 3.5中，基于EntityObject和IPOCO的实体都是依赖着使用映射特性（attributes），对实体类型和属性进行修饰和映射到概念性模型中对应的元素的。Entity Framework 4.0 引入了基于约定（convention）的映射，以允许不用显式的修饰，就可将实体类型，属性，复杂类型和关系映射到概念性模型。一个简单的规则是，在你的POCO类中使用的实体类型名称，属性名称，和复杂类型名称必须匹配那些在概念性模型中定义了的相应名称。命名空间的名称不在考虑之中，类中的命名空间定义和概念性模型中的命名空间定义不必相符。

我的实体类中的所有属性都需要有公开的getters和setters么？

你可以在你的POCO类型的属性上使用任何访问控制修饰符（access modifier），只要被映射的任何属性都不是虚拟的，以及你不需要局部信任（partial trust）支持。在局部信任下运行时，对你的实体类的访问控制修饰符的可见性有一些特定的要求。我们将对在涉及局部信任时，所支持的完整的访问控制修饰符集提供详细的文档。

对基于集合的导航属性都支持哪些集合类型？

任何属于ICollection<T>的类型都是支持的。如果你对ICollection<T>类型的字段不以具体的类型初始化的话，那么从数据库中复原实体集合时， 将提供List<T>。

我可以有单向的关系么？例如，我想在我的Product类中有一个 Category 属性，但在Category类中我不想要一个Products集合。

是的，这是支持的。唯一的限制是，你的实体类型必须反映模型中所定义的东西。如果你不想拥有对应于关系的某一边的导航属性的话，那么你需要从模型中将其完全剔除。

POCO支持延迟（懒式）装载么？

是的，POCO是通过使用代理类型来支持延迟（懒式）装载的，这些代理类型是在你的POCO类之上提供自动的懒式装载行为的。在讨论到延迟装载时，我们会对此做详述，在那之前，知道一下我们也支持通过使用“Include”来实现的早期装载（eager loading），象这样：

var beverageCategory = (from c in context.Categories.Include("Products")
                        where c.CategoryName == "Beverages"
                        select c).Single();

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

如果我要使用延迟（懒式）装载的话，我不用这么做， 在讨论代理时我们会对此进行讨论。

修整（fix-up）关系

要了解有2种类型的修整：1)查询时的修整, 2) 对你的实体/关系进行改动时的修整。

查询时的修整

查询时的修整是在同一个ObjectContext上使用不同的查询来装载相关的实体时发生的。例如，如果我查询了一个分类实例“Beverages（饮料）”，之后又查询一个产品实例“Chai”（是在Beverages分类中的），我想要chai.Category 指向Beverages分类实例，不用我做额外的工作。

这在今天是自动的，而且已经工作。

对你的实体/关系进行改动时的修整

这是在添加/去除与另一个实体相关的实体或者改变关系时两个实体间的关系修整。设想一下这样的例子：在我创建一个名叫“Diet Chai”的新产品时，我想要将其与Beverages 分类相关联。

在Entity Framework 4.0 Beta1 中，在这种情形下，POCO实体得不到自动的关系修整。在处理实体间的关系变动时，你需要确认你的POCO类型包含了在关系两头正确处理关系修整的逻辑。

例如，在我的Northwind例子中，我在Category上定义了如下的方法，以支持添加/去除订单。

        public void AddProduct(Product p)
        {
            if (Products == null)
            {
                Products = new List<Product>();
            }

            if (!Products.Contains(p))
            {
                Products.Add(p);
            }

            p.Category = this;
        }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

总的来说，使用象这样的模式来支持添加/去除相关项，要比使用关系集合来添加/去除相关实体为好。你还可以选择将实际由EF支持的集合的getter/setter变成私有或内部访问控制，来支持更为细颗粒的访问，但就象前面提到的那样，其中一些东西取决于你是否需要局部信任支持这样的需求。

我们在这个“简短的综述”中对总的POCO体验做了一番讨论。要讨论的东西还有很多很多，下个星期我将继续这个讨论。与此同时，请看一下附件中的完整解决方案，如果你对我们在这里讨论的所有概念的相应例程代码感兴趣的话。请记住，你必须在运行这个例程的机器上安装一个本地Northwind数据库。

在下一个贴子中，我们将看一下复杂类型，变化跟踪，代理，懒式装载和早期装载。在那之前，请阅读一下MSDN这里的关于POCO的文档，以了解Entity Framework 4.0中的POCO支持的细节。

请告知我们你们的想法！

Faisal Mohamood

Entity Framework的Program Manager