关于ado.net entity framework 性能比较网上也有很多，这里我只是初步的介绍下ado.net entity framework使用不同的方法查询数据的不同性能

第一部分：重复查询单个实体

第一种：Linq To Entitiess

代码如下：

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　(from　c　in　context.Customers　where　c.CustomerID　==　"ALFKI"　select　c).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为6.2秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　"ALFKI")).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}
查询使用时间为6.2秒左右

第三种：使用EntityKey 来查询

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　"ALFKI"))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为1秒，没错是一秒

总结：

前两种方法查询所使用的时间都差不多为6.2秒，时间比较长，但是使用第三种方法查询数据仅仅使用了1秒，为什么会相差那么多，区别在于前两种方法每次查询都要从数据库中查找，1000次查询每次的查询时间都一样，但是第三种方法只有第一次是从数据库中查数据，后面的999次都是在context通过主键直接取数据，速度当然会快很多啦，EF4.0之前的实体当含有外键引用时是自动生成对象引用的，而EF4.0现在多了一个外键ID，这样我们可以很方便的通过外键来查询数据

第二部分：查询不同是实体
第一种：Linq To Entitiess

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where(c　=>　c.CustomerID　==　key).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.68秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　key)).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.5秒左右

第三种：使用EntityKey 来查询

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　key))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询时间为0.18秒左右

总结：

通过比较第三种方法仍然比前两种来的快，查询效率更高

使用EntityKey来查询数据比其他两种方法来的更快，而且不是快一点点，而是相差有好几倍，这里的比较并没有使用存储过程来比较查询，但是从这里我们可以看出，在平常的应用中如果知道实体的主键尽量用主键来查询

Over the last few months I've been making a list of cool extension methods that I plan to sit down and implement when I get some free time (not sure when that is... but at least I can still have fun coming up with the ideas!)  Two of the scenarios I added to my extension method list were easy methods to automate generating JSON (JavaScript Object Notation) or XML serialization strings for any .NET object. 

Simple Scenario: The ToJSON() extension method

Assume I had a Person object defined like below (note: I'm using the new automatic properties feature to implement it):

I'd like to then be able to initialize a collection of Person objects and programmatically retrieve a JSON string representation of them by just calling a ToJSON() extension method on it like below:

This would work just like the built-in ToString() method on the Object class in .NET today - except that it would generate a JSON-format representation of the collection that I could use for AJAX scenarios on the client:

Note: Clicking on the hour-glass in the debugger above allows us to bring up the Text Visualizer in VS to see a clean version of the JSON serialization:

This string format could then be used within JavaScript on the client to instantiate an appropriate JavaScript object that represents my collection (note: ASP.NET AJAX has a built-in JavaScript library to support this).

Implementing the ToJSON Extension Method

Implementing a basic ToJSON() extension method is pretty simple.  All I needed to-do was use the JavaScriptSerializer class in the System.Web.Script.Serialization namespace, and define two extension methods like below. One of the methods serializes an object graph any levels deep, the other is an overloaded version that allows you to optionally constrain how deep it recurses (for example: ToJSON(2) would serialize only 2 levels deep in the object graph).

Note that the ToJSON() extension methods above are defined for type "Object" - which means they can be used with all objects in .NET (not just collections).  This means that in addition to calling .ToJSON() on collections like I did above, I could also have called ToJSON() on individual Person objects, as well as any other .NET datatype.

To use the extension method, all I need to-do is add a using statement at the top of my program that references the namespace it was defined within:

VS 2008 then takes care of providing intellisense and compile time support for it to all objects:

Note: In addition to the JavaScriptSerializer class, .NET 3.5 also now includes a new System.Runtime.Serialization.DataContractJsonSerializer class that you can use for JSON serialization/deserialization.

Summary

Hopefully the above sample provides a simple example of how you can easily encapsulate useful functionality into extension methods.  Overtime I expect that we'll start to see some nice utility libraries come out that provide helpful extension methods like above. 

I'd be curious to see suggestions for other common scenarios you think should be packaged up into re-usable extension methods (feel free to use the comments of this post to suggest them).  We can then figure out how to get a good CodePlex project created that bundles up some of them together into one library to easily use.