刚刚接触EF，总结了一些在实际工作中的心德经验，与大家分享一下。
一、Excression表达式树
表达式目录树在LINQ中用于表示分配给类型为Expression<TDelegate>的变量的Lambda表达式。还可用于创建动态LINQ查询。
System.Linq.Expressions命名空间提供用于手动生成表达式目录树的API。Expression类包含创建特定类型的表达式目录树节点的静态工厂方法，例如，ParameterExpression（表示一个已命名的参数表达式）或 MethodCallExpression（表示一个方法调用）。编译器生成的表达式目录树的根始终在类型Expression<TDelegate>的节点中，其中TDelegate是包含至多五个输入参数的任何TDelegate委托；也就是说，其根节点是表示一个lambda表达式。
以下例子是EF3.5中运行的，相同的代码在VS2008 EF3.5中是可以正常运行的。在4.5中会抛如下异常。
纠结万分后找到解决方法，代码如下：
IQueryable<Person集> custs = db.Person集;
//创建一个参数c
ParameterExpression param =
Expression.Parameter(typeof(Person集), "c");
Expression left = Expression.Property(param,
typeof(Person集).GetProperty("Age"));
Expression right = Expression.Constant();
Expression filter = Expression.Equal(left, right);
//Expression pred = Expression.Lambda(filter, param);
////Where(c=>c.City=="London")
//Expression expr = Expression.Call(typeof(Queryable), "Where",
// new Type[] { typeof(Person集) },
// Expression.Constant(custs), pred);
////生成动态查询
//IQueryable<Person集> query = db.Person集.AsQueryable()
// .Provider.CreateQuery<Person集>(expr);
var result = db.Person集.Where(Expression.Lambda<Func<Person集, bool>>(filter, param));
通过实体的导航属性的字段的条件过滤，动态生成多个查询条件并带有导航属性
IQueryable<Position集> cities = db.Position集;
ParameterExpression param = Expression.Parameter(typeof(Position集), "c");
Expression left = Expression.Property(param, typeof(Position集).GetProperty("Person集")); //先得到导航属性Person集
Expression leftproperty = Expression.Property(left, "age"); //再得到Person集.Name
Expression right = Expression.Constant();
Expression filter = Expression.Equal(leftproperty, right);
left = Expression.Property(param, typeof(Position集).GetProperty("Company集"));
leftproperty = Expression.Property(left, "Telephone");
right=Expression.Constant("");
Expression filter1 = Expression.Equal(leftproperty, right);
var result = db.Position集.Where(Expression.Lambda<Func<Position集, bool>>(filter, param))
.Where(Expression.Lambda<Func<Position集,bool>>(filter1,param));
其实原理很简单，只是根据相应的条件生成多个leftproperty和right就可以了。
以下的各种用法，大家自己对照着修改吧。
1.Select
下面例子说明如何使用表达式树依据 IQueryable 数据源构造一个动态查询，查询出每个顾客的ContactName，并用GetCommand方法获取其生成SQL语句。
//依据IQueryable数据源构造一个查询
IQueryable<Customer> custs = db.Customers;
//组建一个表达式树来创建一个参数
ParameterExpression param =
Expression.Parameter(typeof(Customer), "c");
//组建表达式树:c.ContactName
Expression selector = Expression.Property(param,
typeof(Customer).GetProperty("ContactName"));
Expression pred = Expression.Lambda(selector, param);
//组建表达式树:Select(c=>c.ContactName)
Expression expr = Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof(Customer), typeof(string) },
Expression.Constant(custs), pred);
//使用表达式树来生成动态查询
IQueryable<string> query = db.Customers.AsQueryable()
.Provider.CreateQuery<string>(expr);
//使用GetCommand方法获取SQL语句
System.Data.Common.DbCommand cmd = db.GetCommand(query);
Console.WriteLine(cmd.CommandText);
生成的SQL语句为：
SELECT [t0].[ContactName] FROM [dbo].[Customers] AS [t0]
2.Where
下面一个例子是“搭建”Where用法来动态查询城市在伦敦的顾客。
IQueryable<Customer> custs = db.Customers;
//创建一个参数c
ParameterExpression param =
Expression.Parameter(typeof(Customer), "c");
//c.City=="London"
Expression left = Expression.Property(param,
typeof(Customer).GetProperty("City"));
Expression right = Expression.Constant("London");
Expression filter = Expression.Equal(left, right);
Expression pred = Expression.Lambda(filter, param);
//Where(c=>c.City=="London")
Expression expr = Expression.Call(typeof(Queryable), "Where",
new Type[] { typeof(Customer) },
Expression.Constant(custs), pred);
生成动态查询
IQueryable<Customer> query = db.Customers.AsQueryable()
.Provider.CreateQuery<Customer>(expr);
生成的SQL语句为：
SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0
-- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London]
3.OrderBy
本例既实现排序功能又实现了过滤功能。
IQueryable<Customer> custs = db.Customers;
//创建一个参数c
ParameterExpression param =
Expression.Parameter(typeof(Customer), "c");
//c.City=="London"
Expression left = Expression.Property(param,
typeof(Customer).GetProperty("City"));
Expression right = Expression.Constant("London");
Expression filter = Expression.Equal(left, right);
Expression pred = Expression.Lambda(filter, param);
//Where(c=>c.City=="London")
MethodCallExpression whereCallExpression = Expression.Call(
typeof(Queryable), "Where",
new Type[] { typeof(Customer) },
Expression.Constant(custs), pred);
//OrderBy(ContactName => ContactName)
MethodCallExpression orderByCallExpression = Expression.Call(
typeof(Queryable), "OrderBy",
new Type[] { typeof(Customer), typeof(string) },
whereCallExpression,
Expression.Lambda(Expression.Property
(param, "ContactName"), param));
生成动态查询
IQueryable<Customer> query = db.Customers.AsQueryable()
.Provider.CreateQuery<Customer>(orderByCallExpression);
下面一张截图显示了怎么动态生成动态查询的过程
生成的SQL语句为：
SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0 ORDER BY [t0].[ContactName] -- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London]
4.Union
下面的例子使用表达式树动态查询顾客和雇员同在的城市。
//e.City
IQueryable<Customer> custs = db.Customers;
ParameterExpression param1 =
Expression.Parameter(typeof(Customer), "e");
Expression left1 = Expression.Property(param1,
typeof(Customer).GetProperty("City"));
Expression pred1 = Expression.Lambda(left1, param1);
//c.City
IQueryable<Employee> employees = db.Employees;
ParameterExpression param2 =
Expression.Parameter(typeof(Employee), "c");
Expression left2 = Expression.Property(param2,
typeof(Employee).GetProperty("City"));
Expression pred2 = Expression.Lambda(left2, param2);
//Select(e=>e.City)
Expression expr1 = Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof(Customer), typeof(string) },
Expression.Constant(custs), pred1);
//Select(c=>c.City)
Expression expr2 = Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof(Employee), typeof(string) },
Expression.Constant(employees), pred2);
//生成动态查询
IQueryable<string> q1 = db.Customers.AsQueryable()
.Provider.CreateQuery<string>(expr1);
IQueryable<string> q2 = db.Employees.AsQueryable()
.Provider.CreateQuery<string>(expr2);
并集
var q3 = q1.Union(q2);
生成的SQL语句为：
SELECT [t2].[City]
FROM (
SELECT [t0].[City] FROM [dbo].[Customers] AS [t0]
UNION
SELECT [t1].[City] FROM [dbo].[Employees] AS [t1]
) AS [t2]
详情见：http://www.cnblogs.com/lyj/archive/2008/03/25/1122157.html
http://blog.csdn.net/going1981/article/details/8003245?reload
二、Dynamic.cs及LinqKit
Dynamic.cs其实也没有什么特殊的奥秘，不过是使用了c#3.0提供的扩展方法，扩展了DynamicQueryable的固有函数。使得where，orderby等可以直接将string作为参数，然后再把传入的字符串进行分析，最终通过System.Linq.Expressions.Expression来实现动态Lambda 。倒是从这里我们可以更好的体会到扩展方法的含义。
在 LINQ 中每一個條件查詢都是用 AND 接起來的，如果要串接 OR 的話必須使用 LINQKit.PredicateBuilder。
假設說用迴圈組合 OR 查詢的話就必須用到 LINQKit，因為沒辦法一行就寫完。
LINQ to SQL 串接 OR 查詢的話就會寫成這樣：
var q = from ks in db.Member select ks;
var predicate = PredicateBuilder.False<Member>();
predicate = predicate.Or(x => x.Name.Contains("oo"));
predicate = predicate.Or(x => x.Name.Contains("pp"));
//查詢名稱包含"oo"或"pp"的使用者
q = from ks in q.Where(predicate)
select ks;
var model = q.ToList();
但如果要用在 LINQ to Object 時上面那段程式會發生型別錯誤的問題。
這是因為查詢 IQueryable 時 .Where() 裡面接的是 Expression，而查詢 IEnumerable 時要接的是 Func。
因此需要用 .Compile() 將 Expression 轉成 Func 才行。
var list = new List<string> { "Microsoft", "Google", "Apple" };
var predicate = PredicateBuilder.False<string>();
predicate = predicate.Or(x => x.Contains("oo"));
predicate = predicate.Or(x => x.Contains("pp"));
var q = from ks in list.Where(predicate.Compile())
select ks;
下面是写了注释后的PredicateExtensions，说不清楚构造函数的True和False具体是怎么起作用的，但结果就是我的注释那样，在复合查询写条件时很重要（不过目前全写AND就完成复合查询了，我还没搞多关键词OR的那种）
/// <summary>
/// 构造函数使用True时：单个AND有效，多个AND有效；单个OR无效，多个OR无效；混合时写在AND后的OR有效
/// 构造函数使用False时：单个AND无效，多个AND无效；单个OR有效，多个OR有效；混合时写在OR后面的AND有效
/// </summary>
public static class PredicateExtensions
{
public static Expression<Func<T, bool>> True<T>() { return f => true; } public static Expression<Func<T, bool>> False<T>() { return f => false; } public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
{
var invokedExpression = Expression.Invoke(expression2, expression1.Parameters.Cast<Expression>()); return Expression.Lambda<Func<T, bool>>(Expression.Or(expression1.Body, invokedExpression), expression1.Parameters);
} public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
{ var invokedExpression = Expression.Invoke(expression2, expression1.Parameters.Cast<Expression>()); return Expression.Lambda<Func<T, bool>>(Expression.And(expression1.Body, invokedExpression), expression1.Parameters);
}
}
PS：赋上一段自己写的LinqKit代码方便大家参考，以及一些Linq其它知识。
public EFTestEntities db = new EFTestEntities();
/// <summary>
/// 利用LinqKit类动态生成查询条件
/// </summary>
/// <returns></returns>
public IEnumerable<Person集> 返回人员列表()
{
//构造函数使用True时：单个AND有效，多个AND有效；单个OR无效，多个OR无效；混合时写在AND后的OR有效
//构造函数使用False时：单个AND无效，多个AND无效；单个OR有效，多个OR有效；混合时写在OR后面的AND有效
var predicate =PredicateBuilder.True<Person集>();
predicate = predicate.And(p => p.Age > || p.Age < );
predicate = predicate.And(p => p.Name.Contains("张") || p.Name.Contains("吕"));
//与之等效的SQL语句
//select * from [dbo].[Person集]
//where (Age>30 or Age<28) and (Name like '%张%' or Name like '%吕%') var predicate1 = PredicateBuilder.False<Person集>();
predicate1 = predicate1.Or(p => p.Age > );
predicate1 = predicate1.Or(p => p.Age < && p.Name.Contains("张"));;
predicate1 = predicate1.Or(p => p.Name.Contains("吕"));
//与之等效的SQL语句
//select * from [dbo].[Person集]
//where Age>30 or (Age<28
//and Name like '%张%') or Name like '%吕%' //提供對應至 SQL Server 函式的方法。 只有 LINQ to SQL 查詢才支援 SqlMethods 類別中的方法。
//predicate=predicate.Or(p=>SqlMethods.Like(p.Name,"张")); //LINQ to SQL 串接 OR 查詢的話就會寫成這樣
//var list = db.Person集.Where(predicate); //但如果要用在 LINQ to Object 時上面那段程式會發生型別錯誤的問題。错误：LINQ to Entities 不支持 LINQ 表达式节点类型“Invoke”。
//這是因為查詢 IQueryable 時 .Where() 裡面接的是 Expression，而查詢 IEnumerable 時要接的是 Func。
//因此需要用 .Compile() 將 Expression 轉成 Func 才行。
var list = db.Person集.Where(predicate.Compile());
var list1 = db.Person集.Where(predicate1.Compile()); //追踪生成SQL
//System.Linq.Enumerable+WhereEnumerableIterator`1[Demo.Data.Person集]
//string sql = list.AsQueryable().ToString(); //SELECT [Extent1].[Name] AS [Name]FROM [dbo].[Person集] AS [Extent1]
//var result = from p in db.Person集 select p.Name;
//string sql = result.AsQueryable().ToString(); return list;
//return list1;
} /// <summary>
/// 返回的人员及职位_Lambda表达示联合查询（不建议大家用Lambda方式写联合查询，可读性很差，五六个表的话，光打.出来属性就得打好多个.容易蒙圈）
/// </summary>
/// <returns></returns>
public IQueryable 返回Lambda联合查询()
{
var list = db.Person集.Join(db.Position集, p => p.ID, m => m.Person_ID, (p, m) => new { p, m })
.Join(db.Company集, p => p.m.Company_ID, c => c.ID, (p, c) => new { p, c })
.Where(t => t.p.p.Sex == "");
return list;
}
三、EF查询小技巧
有时我们的实体只需要显示，无需更新，所以为了提高性能，我们不需要实体被EF context追踪。此时可以使用NoTracking的查询来得到实体，这样实体的状态会是Detached（分离式）状态。
db.Person集.Where(c => c.Name == "张智超").AsNoTracking();
在使用Entity Framework做查询的时候，如果只需要显示，而不用保存实体，那么可以用AsNoTracking()来获取数据。
这样可以提高查询的性能。 代码如下：
var context = new Entities(connectStr); var contentlist = context.Set<Content>().AsQueryable().AsNoTracking();
但是如果取到数据后，要对数据做修改并保存，则无法反映到数据库里。 如：
var context = new Entities(connectStr); var contentlist = context.Set<Content>().AsQueryable().AsNoTracking(); var content = contentlist.Where(o => o.Id == ).FirstOrDefault(); content.Id = ; context.SaveChanges();
虽然修改后对数据库进行了Commit，再次读取后发现这条数据的Id还是18。
另外如果对通过AsNoTracking得到的数据做删除处理，则会报错。 如：
var context = new Entities(connectStr); var contentlist = context.Set<Content>().AsQueryable().AsNoTracking(); var content = contentlist.Where(o => o.Id == ).FirstOrDefault(); context.Set<Content>().Remove(content); context.SaveChanges();
执行后会抛出System.InvalidOperationException异常
四、LinqPad功能简介
LINQPAD是一款用于LINQ运算和测试的工具，功能丰富，操作简单。
界面中可大致分为四个分隔窗格：
一、左上部为数据源连接部分，点击添加连接[Addconnection]可以创建一个数据库连接，数据源种类很多，可以添加LinqtoSql，也可以是WCF服务，甚至可以是其它数据源。
二、右边部分就是查询窗口，是写代码LINQ语句、的部分，可以选择写代码的语言与所要查询的数据库，还可以选择数据库查询分析器类似。
三、左下部分是一些教学示例和保存的查询
四、右下部分就是查询结果窗口
五、查询结果窗口的选项卡是很激动人心。（包括：Result，表达式，SQL语句，MSIL代码）
本文使用Customers表中的数据为例，在语言列表中可选择：
1、C#Expression（用于进行LinqSql查询）
from c in Customers select c
2、C#Statement（用于C#语句查询，其中的Dump可以显示查询结果）
var p=from c in Customers select c;
p.Dump();
3、C#Program（用于支持方法和类型的查询，须定义Main方法，此方法中生成的SQL不能看到where查询条件，也不能看到Lambda表达示）
voidMain()
{
var p=from c in Customers select c;
p.Dump();
}
4、SQL查询语句（传统的SQL查询语法）
select * from customer
5、其中在前3种方法中，查询的数据库表默认为表名后面加S，这点在LINQPad中要注意
6、在使用时推荐使用语句模式C#Statement。
六、LinqPad可以添加外部插件引用
点击左上角菜单栏的Query菜单选择Query Properties，或按快捷键F4出现添界面。
选择要添加的DLL文件OK即可。目前只掌握这一项功能，其它的有待研究。
添加成功后可直接用调用其引用文件的方法。（我调用的是支持动态拼接Linq语言的）如下图
结果集如下图：
可查看生成不同的查询语言
1.Lambda表达示
2.SQL语句
3.IL（不太清楚具体的用途）
IL_0001: ldarg.0 IL_0002: call LINQPad.User.TypedDataContext.get_Person闆唖 IL_0007: call PredicateBuilder.True IL_000C: ldtoken LINQPad.User.Person集 IL_0011: call System.Type.GetTypeFromHandle IL_0016: ldstr "p" IL_001B: call System.Linq.Expressions.Expression.Parameter IL_0020: stloc.0 // CS$0$0000 IL_0021: ldloc.0 // CS$0$0000 IL_0022: ldtoken LINQPad.User.Person集.Age IL_0027: call System.Reflection.FieldInfo.GetFieldFromHandle IL_002C: call System.Linq.Expressions.Expression.Field IL_0031: ldc.i4.s 1E IL_0033: box System.Int32 IL_0038: ldtoken System.Int32 IL_003D: call System.Type.GetTypeFromHandle IL_0042: call System.Linq.Expressions.Expression.Constant IL_0047: call System.Linq.Expressions.Expression.GreaterThan IL_004C: ldloc.0 // CS$0$0000 IL_004D: ldtoken LINQPad.User.Person集.Age IL_0052: call System.Reflection.FieldInfo.GetFieldFromHandle IL_0057: call System.Linq.Expressions.Expression.Field IL_005C: ldc.i4.s 1C IL_005E: box System.Int32 IL_0063: ldtoken System.Int32 IL_0068: call System.Type.GetTypeFromHandle IL_006D: call System.Linq.Expressions.Expression.Constant IL_0072: call System.Linq.Expressions.Expression.LessThan IL_0077: call System.Linq.Expressions.Expression.OrElse IL_007C: ldc.i4.1 IL_007D: newarr System.Linq.Expressions.ParameterExpression IL_0082: stloc.1 // CS$0$0001 IL_0083: ldloc.1 // CS$0$0001 IL_0084: ldc.i4.0 IL_0085: ldloc.0 // CS$0$0000 IL_0086: stelem.ref IL_0087: ldloc.1 // CS$0$0001 IL_0088: call System.Linq.Expressions.Expression.Lambda IL_008D: call PredicateBuilder.And IL_0092: ldtoken LINQPad.User.Person集 IL_0097: call System.Type.GetTypeFromHandle IL_009C: ldstr "p" IL_00A1: call System.Linq.Expressions.Expression.Parameter IL_00A6: stloc.0 // CS$0$0000 IL_00A7: ldloc.0 // CS$0$0000 IL_00A8: ldtoken LINQPad.User.Person集.Name IL_00AD: call System.Reflection.FieldInfo.GetFieldFromHandle IL_00B2: call System.Linq.Expressions.Expression.Field IL_00B7: ldtoken System.String.Contains IL_00BC: call System.Reflection.MethodBase.GetMethodFromHandle IL_00C1: castclass System.Reflection.MethodInfo IL_00C6: ldc.i4.1 IL_00C7: newarr System.Linq.Expressions.Expression IL_00CC: stloc.2 // CS$0$0002 IL_00CD: ldloc.2 // CS$0$0002 IL_00CE: ldc.i4.0 IL_00CF: ldstr "寮�" IL_00D4: ldtoken System.String IL_00D9: call System.Type.GetTypeFromHandle IL_00DE: call System.Linq.Expressions.Expression.Constant IL_00E3: stelem.ref IL_00E4: ldloc.2 // CS$0$0002 IL_00E5: call System.Linq.Expressions.Expression.Call IL_00EA: ldloc.0 // CS$0$0000 IL_00EB: ldtoken LINQPad.User.Person集.Name IL_00F0: call System.Reflection.FieldInfo.GetFieldFromHandle IL_00F5: call System.Linq.Expressions.Expression.Field IL_00FA: ldtoken System.String.Contains IL_00FF: call System.Reflection.MethodBase.GetMethodFromHandle IL_0104: castclass System.Reflection.MethodInfo IL_0109: ldc.i4.1 IL_010A: newarr System.Linq.Expressions.Expression IL_010F: stloc.2 // CS$0$0002 IL_0110: ldloc.2 // CS$0$0002 IL_0111: ldc.i4.0 IL_0112: ldstr "鍚�" IL_0117: ldtoken System.String IL_011C: call System.Type.GetTypeFromHandle IL_0121: call System.Linq.Expressions.Expression.Constant IL_0126: stelem.ref IL_0127: ldloc.2 // CS$0$0002 IL_0128: call System.Linq.Expressions.Expression.Call IL_012D: call System.Linq.Expressions.Expression.OrElse IL_0132: ldc.i4.1 IL_0133: newarr System.Linq.Expressions.ParameterExpression IL_0138: stloc.1 // CS$0$0001 IL_0139: ldloc.1 // CS$0$0001 IL_013A: ldc.i4.0 IL_013B: ldloc.0 // CS$0$0000 IL_013C: stelem.ref IL_013D: ldloc.1 // CS$0$0001 IL_013E: call System.Linq.Expressions.Expression.Lambda IL_0143: call PredicateBuilder.And IL_0148: call System.Linq.Queryable.Where IL_014D: call LINQPad.Extensions.Dump