Linq笔记

Linq多个字段的 Left join查询：

Var query=from p in AAA

          join q in BBB on new {aa=p.Aa,bb=p.Bb } equals new {q.aa,q,bb } into g  //字段名称要一致，不要再用where条件

          from g1 in g.DefaultOrDefault()

                      select p;

 

Linq多个字段的 Inner join查询：

Var query=from p in AAA

          join q in BBB on new  p.aa equals q.aa into g

          from g1 in g.DefaultOrDefault()

          where p.bb==g.bb

                      select p;

 

Var query=from p in AAA

          join q in BBB on new  p.aa equals q.aa where p.bb.Equals(q.bb)

                      select p;

 

Linq中子查询带条件示例：

var Bcompany = fromq in _unit.BCompanyRepository.GetAll() select q;

var Bcomsuming =from p in _unit.BConsumRepository.GetAll()

                    where new int[] { 0, 3, 8,9 }.Contains(p.TransactionType)

                    select p;

var query = from pin _unit.BCompanyRepository.GetAll()

            where p.CompanyType == 3 &&p.IsConsuming == false && p.ParentCompanyID != null

            select new

            {

                CompanyName = p.CompanyName,

                Amount = Bcomsuming.Where(c=> Bcompany

                       .Where(d => d.ParentCompanyID ==p.CompanyID)    //从最外面一层来的条件

                        .Select(d =>d.CompanyID)

                        .Contains(c.CompanyID?? 0))

                        .Sum(c => c.Amount)

            };

 

 

 

数据在一次调用多次修改/添加时，数据双份修改的错误原因：

Entity在SaveChanges()方法使用时，ObjectContext是在for(foreach)循环外面，导致每次的修改后的值，后面再次循环时又发生一次改变。修改方式是将 ObjectContext放在for(foreach)循环里面，Using ObjectContext对象，对象使用后，会自动断开连接，消除之前循环的数据。

 

 

可空字段的赋值：

CardAmount= CardAmount ?? 0;

 

Linq中group by多个表的字段：

var query = (from p in context.siteInfo

                         from c in context.shopInfo

                         where c.siteID == p.siteID

                         group c by new { c.date, c.siteID, p.lon, p.lat } into g

                         select new site_shopInfo

                         {

                             siteID = (int)g.Key.siteID,

                             Longitude = (double)g.Key.lon,

                             Latitude = (double)g.Key.lat,

                             date = (DateTime)g.Key.date,

                             Totalearning = (int)g.Sum(t => t.earning)

                         }).ToList();

 

 

Linq中对于In与Like的用法：

In:

where(new int?[] {1,2}).Contains(A.a)

where(from p in …...).Contains(A.a)

 

Not in:

where! (new int?[] {1,2}).Contains(A.a)

where(from p in …...).Contains(A.a)

 

Like '%aa%'：

WhereA.a.Contains("aa")

where SqlMethods.Like(A.a, "%aa%")  //引用System.Data.Linq.SqlClient

 

Like '%aa'：

.EndsWith("aa")

whereSqlMethods.Like(A.a, "%aa")

 

Like 'aa%'：

.StartsWith("aa")

whereSqlMethods.Like(A.a, "aa%")

 

Like '%aa%aa%'：

whereSqlMethods.Like(A.a, "%aa%aa%")

 

Linq中SubString与Contains的区别：

SubString():位置和字符都要匹配

Contains(): 位置不用匹配，字符需要匹配

 

 

Linq比较日期部分大小：

WhereEntityFunctions.Diff(p.a???????)

 

 

 

 

Linq中的数据类型转换方式：

int Num =StringUtils.GetDbInt(Name);       //object转换成Int  //Hinlin调用

 

Name =SqlFunctions.StringConvert((decimal)p.Num).Trim();  //Int转换成string  //Linq公共

 //消除存在空格的情况,(有时候数据是对的，但是就是不相等，就是多了空格。)

Amount=SqlFunctions.StringConvert((decimal)p.Num,18,2);  //decimal转string //直接转换会消除小数位

 

 

 

First与Single的使用：

First,返回序列中的第一条记录，如果没有记录，则引发异常

FirstOrDefault,返回序列中的第一条记录，如果序列中不包含任何记录，则返回默认值。

Single,返回序列中的唯一一条记录，如果没有或返回多条，则引发异常。

SingleOrDefault，返回序列中的唯一一条记录，如果序列中不包含任何记录，则返回默认值，如果返回多条，则引发异常。

 

ToList()的使用：

存在循环，ToList()在循环外使用；

不存在循环，当需要用时，再根据情况适用。

 

 

Select new：

Linq中，select查询多个字段时，可以不用select new 实体类，可以直接select new 去查询。

 

 

In与Order by的使用：

Varquery= from A in db.A

                     where ( from B in db.Bselect B.a ).Contains(A.a)

                     orderby A.b ascending, A.c descending

         select A;

 

IsNull()方法的使用：

SQL: where IsNull(A.a, 0)!=0

Linq:  where (A.a == null ? 0 : A.a ) != 0

 

 

子查询：

Var query=from A in db.A

          from B in db.B

          where A.a==B.a

          &&A.c==(fromC in db.C where C.b==B.b select C.c).First()

          select new A;

 

 

into的作用：

可以使用 into上下文关键字创建一个临时标识符，

以便将 group、join 或select 子句的结果存储到新的标识符中。

此标识符本身可以是附加查询命令的生成器。

在 group 或 select子句中使用新标识符的用法有时称为“延续”。

类似于：

Select C.a1 from (select A.aas a1,B.a as a2 from A join B on A.a=B.a)as C

中的 "C"。

 

Case when的用法：

Varquery=from A in db.A

                  select new

                 {

                bb=(A.b==null ? 0 : A.b),

                 cc=(A.c!=null ? A.c : 0 )

     };

 

 

Join的用法：

Var query=from A in db.A

         join Bin db.B on A.aequalsB.a

          where A.c==""

          select new

          { ……};

 

说明：select new后面可以不跟对象，便于对查询出的数据类型不做限制，

           即查询的数据原来是什么类型，就是什么类型。

            select new后面跟对象的要求：对数据类型严格限制，避免出现数据溢出等错误。