EF经验分享

刚刚接触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

EF经验分享_jimmyzzc的更多相关文章

【原创经验分享】WCF之消息队列
最近都在鼓捣这个WCF,因为看到说WCF比WebService功能要强大许多,另外也看了一些公司的招聘信息,貌似一些中.高级的程序员招聘,都有提及到WCF这一块,所以,自己也关心关心一下,虽然目前工作 ...
【原创经验分享】JQuery（Ajax）调用WCF服务
最近在学习这个WCF,由于刚开始学不久,发现网上的一些WCF教程都比较简单,感觉功能跟WebService没什么特别大的区别,但是看网上的介绍,就说WCF比WebService牛逼多少多少,反正我刚 ...
（转）CMOS Sensor的调试经验分享
CMOS Sensor的调试经验分享我这里要介绍的就是CMOS摄像头的一些调试经验. 首先,要认识CMOS摄像头的结构.我们通常拿到的是集成封装好的模组,一般由三个部分组成:镜头.感应器和图像信号处 ...
关于启用 HTTPS 的一些经验分享（二）
转载: 关于启用 HTTPS 的一些经验分享(二) 几天前,一位朋友问我:都说推荐用 Qualys SSL Labs 这个工具测试 SSL 安全性,为什么有些安全实力很强的大厂家评分也很低?我认为这个 ...
关于启用 HTTPS 的一些经验分享（一）
转载: 关于启用 HTTPS 的一些经验分享(一) 随着国内网络环境的持续恶化,各种篡改和劫持层出不穷,越来越多的网站选择了全站 HTTPS.就在今天,免费提供证书服务的 Let's Encrypt ...
Expression Blend4经验分享：文字公告无缝循环滚动效果
这次分享一个类似新闻公告板的无缝循环滚动效果,相信很多项目都会应用到这个效果.之前我也百度了一下,网上的一些Silverlight的文字或图片滚动效果,都是一次性滚动的,如果要做到无缝循环滚动,多数要 ...
Expression Blend4经验分享：自适应布局浅析
今天分享一下Blend制作自适应分辨率布局的经验,大家先看下效果图: 这是一个标准的三分天下的布局,两侧的红色区域是背景区域,是用来干吗的呢,下面简单的分析一下,大家就明白了. 1.拿到一个项目,进行 ...
Expression Blend4经验分享：制作一个简单的图片按钮样式
这次分享如何做一个简单的图片按钮经验在我的个人Silverlight网页上,有个Iphone手机的效果,其中用到大量的图片按钮 http://raimon.6.gwidc.com/Iphone/de ...
Expression Blend4经验分享：制作一个简单的文字按钮样式
首先在Grid里放一个TextBlock,对象时间线窗口的结构树如下右键点击grid,选择构成控件会弹出构成控件的对话框,选择你要构成的控件类型,控件名称,控件样式存储位置这里我们选择butto ...

随机推荐

'@P0' 附近有语法错误
问题出在ibatis中的某个orm配置文件,查看你的某些sql语句,尤其是用到#和$等进行赋值的,区分开到底是用#还是$ eg: select top $pagefrom$ id from tb_bo ...
HDU 4121 Xiangqi 我老了？
Xiangqi Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Sub ...
EasyUI datagrid组件绑定有转义字符的json数据出错
最近项目中一个页面的datagrid出现了莫名其妙的问题, 首先是分页数据的第二页和第三页不能展示,过了一天后第一页也出不来了, 默认首页不出来导致后续分页处理无法进行, 整个数据都不出来了,最后只能 ...
Linux-wget/tar/ln 函数
1. 获取软件包,可以使用wget的方式, ubuntu可以使用apt-get source来获取源代码 wget 是一个在网络上进行下载的简单而强大的自由软件,支持HTTP,HTTPS,FTP协议, ...
将Excel中数据导入数据库（三）
上篇文章将Excel中数据导入数据库时,将从Excel读入的数据均转换成了数据库相应字段的类型,其实这是没有必要的,因为对于数据库各种类型的插入,均可以字符串格式插入.比如表WQ_SWMSAR_A字段 ...
ICE学习——异步1
ICE的AMI和AMD: AMI:指的是客户端的调用.一般有一个代理类,一个回调类. 从服务端返回的数据在回调类中的ice_response函数中. AMD:指的是服务端对客户端的调用分派.一般进行业 ...
com学习（一）GUID 和接口
话说在 doc(Word) 复合文件中,已经解决了保存 xls(Excel) 数据的问题了.那么,接下来又要解决另一个问题:当 WORD 程序读取复合文件,遇到了 xls 数据的时候,它该如何启动 E ...
对.Net系统架构改造的一点经验和教训
如果你对项目管理.系统架构有兴趣,请加微信订阅号"softjg",加入这个PM.架构师的大家庭在互联网行业,基于Unix/Linux的网站系统架构毫无疑问是当今主流的架构解决方案 ...
统计Crash工具—Crashlytics
官网:https://www.crashlytics.com/login 步骤: 注意:有时候再次运行,或者换了Crashlytics账号之后,获取不到Crash信息,其实你需要把plist文件里的K ...
ViewPager撤消左右滑动切换功能
ViewPager取消左右滑动切换功能最近做项目要求某种情况下ViewPager不能滑动,那么我们只需要重写这个方法就可以禁止ViewPager滑动 IndexViewPager.java: imp ...

EF经验分享_jimmyzzc

EF经验分享_jimmyzzc的更多相关文章

随机推荐

热门专题