出于工作需要，准备把LINQ的相关知识梳理一遍，希望能填补下之前学习漏掉的或是没有注意的地方，也为未来减轻压力~

　　LINQ查询表达式的基本语法很容易掌握，它使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。

　　LINQ的数据源可以是数据库对象或是XML流等，也可以使实现了IEnumerable或者泛型IEnumberable<T>接口的集合对象。

　　LINQ的基本语法包含如下的8个上下文关键字，这些关键字和具体的说明如下：

关键字 说明
from 指定范围变量和数据源
where　　 根据bool表达式从数据源中筛选数据
select 指定查询结果中的元素所具有的类型或表现形式
group 对查询结果按照键值进行分组(IGrouping<TKey,TElement>)
into 提供一个标识符，它可以充当对join、group或select子句结果的引用
orderby 对查询出的元素进行排序(ascending/descending)
join 按照两个指定匹配条件来Equals连接两个数据源
let 产生一个用于存储查询表达式中的子表达式查询结果的范围变量

下面依此总结这8个关键字的常用查询语句写法。

1.from子句

如果要写一个LINQ表达式，就必须是以from子句开头。个人觉得from子句中需要注意的地方就是多个from子句的书写。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Collections;
  6.  
  7. namespace LINQ
  8. {
  9.     /// <summary>
  10.     /// LINQ,重点是感悟from子句中的查询变量的灵活
  11.     /// </summary>
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.             //1单个form子句
  17.             string[] values = { "LINQ学习","LINQ基本语句","from子句","单个from子句"};
  18.             var value = from v in values
  19.                         where v.IndexOf("LINQ") > -1
  20.                         select new { v, v.Length };
  21.             foreach (var n in value)
  22.             {
  23.                 Console.WriteLine("{0},{1}",n.v,n.Length );
  24.             }
  25.             Console.ReadKey(false);
  26.             //2使用LINQ查询ArrayList
  27.             ArrayList gList = new ArrayList();
  28.             gList.Add(new GustInfo {  Name="DebugLZQ", Age=26, Tel="88888888"});
  29.             gList.Add(new GustInfo { Name="博客园",Age=6, Tel ="666666"});
  30.             gList.Add(new GustInfo { Name = "M&MSoft", Age =9, Tel = "55555" });
  31.  
  32.             var query = from GustInfo gust in gList
  33.                         where gust.Age > 9
  34.                         select gust;//范围变量gust制定了数据类型
  35.             foreach (GustInfo g in query)
  36.             {
  37.                 Console.WriteLine("{0} 年龄:{1} 电话:{2}",g.Name,g.Age,g.Tel );
  38.             }
  39.             Console.ReadKey(false);
  40.             //3复合from子句
  41.             List<GustInfo2> gList2 = new List<GustInfo2>()
  42.             {
  43.                 new GustInfo2{ Name="DebugLZQ",Age=26,TelTable=new List<string>(){"8888888","138******"}},
  44.                 new GustInfo2{ Name="博客园",Age=6,TelTable =new List<string>(){"666666","138******"}},
  45.                 new GustInfo2{ Name="M&MSoft",Age=9,TelTable=new List<string>(){"55555","138******"}}
  46.             };
  47.  
  48.             //gust、tel都是查询变量,作用域为当前查询语句！！！
  49.             var query2 = from gust in gList2
  50.                          from tel in gust.TelTable
  51.                          where tel.IndexOf("5555") > -1
  52.                          select gust;
  53.             foreach (var g in query2)
  54.             {
  55.                 Console.WriteLine("{0} 年龄{1}",g.Name,g.Age );
  56.                 foreach (var t in g.TelTable)
  57.                 {
  58.                     Console.WriteLine("电话：{0}",t);
  59.                 }
  60.             }
  61.  
  62.             Console.ReadKey(false);
  63.  
  64.             //4多个from子句
  65.             var query3 = from GustInfo gust in gList
  66.                          where gust.Age > 6
  67.                          from GustInfo2 gust2 in gList2
  68.                          where gust2.Age> 9
  69.                          select new { gust, gust2 };//查询结果定制
  70.             foreach (var g in query3)
  71.             {
  72.                 Console.WriteLine("{0}  {1}", g.gust.Name, g.gust2.Name);
  73.             }
  74.  
  75.             Console.ReadKey(false);
  76.         }
  77.     }
  78. }

程序的运行结果如下：

程序中列举了from子句的用法示例，注意复合from子句和多个from子句的书写，同时需要理解范围变量和数据源变量这两个概念。

2.where子句

where子句，它是LINQ表达式的元素筛选机制，除了开始和结束的位置，它几乎可以出现在LINQ表达式的任意位置上。

在一个LINQ表达式中，可以有where子句，也可以没有；可以有一个，也可以有多个；多个where子句之间的逻辑关系相当于逻辑“与”，每个 where子句可以包含1个或多个bool逻辑表达式，这些条件成为谓词，谓词逻辑之间用的是“&&”“||”等而不是SQL中的and 、or。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_WHERE
  7. {
  8.     /// <summary>
  9.     /// LINQ where子句
  10.     /// </summary>
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             //1常见的where语句
  16.             List<GustInfo> gList = new List<GustInfo>()
  17.             {
  18.                 new GustInfo(){ Name="DebugLZQ", Age=26,Tel="88888888"},
  19.                 new GustInfo(){ Name="cnblogs",Age=6,Tel="666666"},
  20.                 new GustInfo(){ Name="M&MSoft",Age=9,Tel="55555"}
  21.             };
  22.  
  23.             var query = from gust in gList
  24.                         where (gust.Name.Length > 7 || gust.Name.Substring(0, 1) == "M") && gust.Age > 9
  25.                         select new { gust.Name, gust.Age };
  26.             foreach (var g in query)
  27.             {
  28.                 Console.WriteLine("{0},{1}", g.Name, g.Age);
  29.             }
  30.  
  31.             Console.ReadKey(false);
  32.  
  33.             //2.在where子句中使用自定义函数
  34.             var query2 = from GustInfo gust in gList
  35.                          where gust.Name.Length > 5
  36.                          && Check(gust.Name)
  37.                          select gust;
  38.             foreach (var g in query2)
  39.             {
  40.                 Console.WriteLine("{0},{1},{2}", g.Name, g.Age, g.Tel);
  41.             }
  42.             Console.ReadKey(false);
  43.  
  44.             //3.动态谓词的筛选
  45.             //定义动态谓词数组,在实际开发中可以动态获得
  46.             string[] names = { "SB","XXX","***","@@@","一些敏感词"};
  47.  
  48.             var query3 = from GustInfo guest in gList
  49.                          where !names.Contains(guest.Name)
  50.                          select guest;
  51.  
  52.             foreach (var q in query3)
  53.             {
  54.                 Console.WriteLine("{0} 年龄：{1},电话：{2}",q.Name,q.Age,q.Tel );
  55.             }
  56.             Console.ReadKey(false);
  57.         }
  58.  
  59.         //自定义函数
  60.         static bool Check(string name)
  61.         {
  62.             if (name.Substring(0, 1) == "N")
  63.                 return false;
  64.             return true;
  65.         }
  66.     }
  67. }

需要注意一些常用的where子句的写法。程序的运行结果如下：

3.Select子句

在select子句上可以非常灵活的处理查询到的元素，然后再把结果返回。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_select
  7. {
  8.     /// <summary>
  9.     /// LINQ select
  10.     /// 在select子句上，可以非常灵活的处理查询到的元素，然后再把结果返回
  11.     /// </summary>
  12.     class MyGustInfo
  13.     {
  14.         public string Name { get; set; }
  15.         public int Age { get; set; }
  16.     }
  17.     class Program
  18.     {
  19.         static void Main(string[] args)
  20.         {
  21.             List<GustInfo> gList = new List<GustInfo>()
  22.             {
  23.                 new GustInfo(){ Name="DebugLZQ", Age=25, Tel="88888888"},
  24.                  new GustInfo(){ Name="cnblogs", Age=6, Tel="666666"},
  25.                   new GustInfo(){ Name="M&M", Age=9, Tel="55555"}
  26.             };
  27.             var query = from gust in gList
  28.                         where gust.Age >= 9 && gust.Age <= 30
  29.                         select gust.Name.Replace("&", "mm");//select子句灵活应用
  30.             var query2 = from gust in gList
  31.                          where gust.Age >= 9 && gust.Age <= 30
  32.                          select MyProc(gust.Name);
  33.             var query3 = from gust in gList
  34.                          where gust.Age >= 9 && gust.Age <= 30
  35.                          select new { gust.Name,gust.Age};
  36.  
  37.             var query4 = from gust in gList
  38.                          where gust.Age >= 9 && gust.Age <= 30
  39.                          select new MyGustInfo {  Name=gust.Name+"My", Age=gust.Age+1};//对查询结果进行投影
  40.  
  41.             foreach (var v in query)
  42.             {
  43.                 Console.WriteLine(v);
  44.             }
  45.             foreach (var v in query2)
  46.             {
  47.                 Console.WriteLine(v);
  48.             }
  49.             foreach (var v in query3)
  50.             {
  51.                 Console.WriteLine(v.Name+v.Age );
  52.             }
  53.             foreach (var v in query4)
  54.             {
  55.                 Console.WriteLine(v.Name+v.Age );
  56.             }
  57.  
  58.             Console.ReadKey(false);
  59.         }
  60.         static string MyProc(string s)
  61.         {
  62.             return s + "Better";
  63.         }
  64.     }
  65. }

程序的运行结果如下：

4.group子句

根据语法的规定，LINQ表达式必须以from子句开头，以select或group子句结束，所以除了使用select来返回结果外，也可以使用group子句来返回元素分组后的结果。

group子句返回的是一个基于IGrouping<TKey,TElement>泛型接口的对象序列。

语法和SQL的group有点区别，不注意的话可能会写错。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_group
  7. {
  8.     /// <summary>
  9.     /// LINQ group子句
  10.     /// </summary>
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             List<GustInfo> gList = new List<GustInfo>()
  16.             {
  17.                 new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
  18.                 new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
  19.                 new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
  20.                 new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
  21.                 new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
  22.                 new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
  23.             };
  24.  
  25.             var query = from guest in gList
  26.                         group guest by guest.Name.Substring(0, 1);//分组键key是string类型
  27.  
  28.             //遍历键值和键值所属元素
  29.             foreach (IGrouping<string, GustInfo> guestGroup in query)
  30.             {
  31.                 Console.WriteLine("分组键：{0}",guestGroup.Key );
  32.                 foreach (var g in guestGroup)
  33.                 {
  34.                     Console.WriteLine("{0} 年龄：{1}  电话：{2}",g.Name,g.Age,g.Tel );
  35.                 }
  36.             }
  37.             Console.ReadKey(false);
  38.  
  39.             Console.WriteLine("-----------------------------------");
  40.  
  41.             var query2 = from guest in gList
  42.                          group guest by guest.Age > 20;//分组键key是bool类型表达式的结果
  43.  
  44.             foreach (IGrouping<bool, GustInfo> guestGroup in query2)
  45.             {
  46.                 Console.WriteLine("年龄是否大于20  分组键：{0}", guestGroup.Key);
  47.                 foreach (var g in guestGroup)
  48.                 {
  49.                     Console.WriteLine("{0} 年龄：{1}  电话：{2}", g.Name, g.Age, g.Tel);
  50.                 }
  51.             }
  52.             Console.ReadKey(false);
  53.         }
  54.     }
  55. }

程序的运行结果如下：

5.into子句

into子句作为一个临时标识符，用于group、select、join子句中充当其结果的引用。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_into
  7. {
  8.     /// <summary>
  9.     /// LINQ group
  10.     /// </summary>
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             List<GustInfo> gList = new List<GustInfo>()
  16.             {
  17.                 new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
  18.                 new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
  19.                 new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
  20.                 new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
  21.                 new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
  22.                 new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
  23.             };
  24.  
  25.             //1.into用于group子句
  26.             var query = from guest in gList
  27.                         group guest by guest.Name.Substring(0, 1) into grguest
  28.                         orderby grguest.Key descending
  29.                         select grguest;
  30.  
  31.             var query2 = from guest in gList
  32.                         group guest by guest.Name.Substring(0, 1) into grguest
  33.                         orderby grguest.Key ascending
  34.                         select grguest;
  35.  
  36.             //2.select 子句中的into子句
  37.             var query3 = from guest in gList
  38.                          select new { NewName = guest.Name, NewAge = guest.Age } into newguest
  39.                          orderby newguest.NewAge
  40.                          select newguest;
  41.  
  42.             foreach (var guestGroup in query)
  43.             {
  44.                 Console.WriteLine("分组键：{0}",guestGroup.Key );
  45.                 foreach (var g in guestGroup)
  46.                 {
  47.                     Console.WriteLine("{0} 电话:{1}",g.Name,g.Tel );
  48.                 }
  49.             }
  50.             Console.ReadKey(false);
  51.  
  52.             foreach (var newg in query3)
  53.             {
  54.                 Console.WriteLine("{0} 年龄：{1}",newg.NewName,newg.NewAge );
  55.             }
  56.  
  57.             Console.ReadKey(false);
  58.         }
  59.     }
  60. }

程序运行结果如下：

6.orderby子句、thenby子句

LINQ可以按照元素的一个或多个属性对元素进行排序。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_orderby
  7. {
  8.     class Program
  9.     {
  10.         /// <summary>
  11.         /// LINQ orderby (ascending descending)
  12.         /// </summary>
  13.         /// <param name="args"></param>
  14.         static void Main(string[] args)
  15.         {
  16.             List<GustInfo> gList = new List<GustInfo>()
  17.             {
  18.                 new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
  19.                 new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
  20.                 new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
  21.                 new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
  22.                 new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
  23.                 new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
  24.             };
  25.  
  26.             //按照年龄排序
  27.             var query = from guest in gList
  28.                         orderby guest.Age
  29.                         select guest;
  30.             var query1 = from guest in gList
  31.                          orderby guest.Age ascending
  32.                          select guest;
  33.             var query2 = from guest in gList
  34.                          orderby guest.Age descending
  35.                          select guest;
  36.             //按照年龄进行排序，按照名字字数进行次要排序
  37.             var query3 = from guest in gList
  38.                         orderby guest.Age, guest.Name.Length
  39.                         select guest;
  40.             var query4 = from guest in gList
  41.                          orderby guest.Age descending , guest.Name.Length ascending
  42.                          select guest;
  43.             var query5 = from guest in gList
  44.                          orderby guest.Age, guest.Name.Length,guest.Tel
  45.                          select guest;
  46.  
  47.             foreach (var guest in query2)
  48.             {
  49.                 Console.WriteLine("{0} 年龄：{1} 电话：{2}",guest.Name,guest.Age,guest.Tel );
  50.             }
  51.             Console.ReadKey(false);
  52.             foreach (var guest in query4)
  53.             {
  54.                 Console.WriteLine("{0} 年龄：{1} 电话：{2}", guest.Name, guest.Age, guest.Tel);
  55.             }
  56.             Console.ReadKey(false);
  57.         }
  58.     }
  59. }

程序运行结果如下：

7.let子句

let子句用于在LINQ表达式中存储子表达式的计算结果。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_let
  7. {
  8.     /// <summary>
  9.     /// LINQ let用来存子储表达式的计算结果
  10.     /// </summary>
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             List<GustInfo> gList = new List<GustInfo>()
  16.             {
  17.                 new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
  18.                 new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
  19.                 new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
  20.                 new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
  21.                 new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
  22.                 new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
  23.             };
  24.  
  25.             //使用let子句创建范围变量g，并通过g构建查询表达式
  26.             var query = from guest in gList
  27.                         let g = guest.Name.Substring(0, 1)
  28.                         where g == "D" || g == "J"
  29.                         select guest;
  30.             //也可以不使用let，上面的语句等效于下
  31.             var query2 = from guest in gList
  32.                          where guest.Name.Substring(0, 1) == "D" || guest.Name.Substring(0, 1) == "J"
  33.                          select guest;
  34.  
  35.             foreach (var g in query)
  36.             {
  37.                 Console.WriteLine("{0} 年龄：{1} 电话：{2}",g.Name,g.Age,g.Tel );
  38.             }
  39.             Console.ReadKey(false);
  40.             Console.WriteLine("不使用let，等效的语句结果");
  41.             foreach (var g in query2)
  42.             {
  43.                 Console.WriteLine("{0} 年龄：{1} 电话：{2}", g.Name, g.Age, g.Tel);
  44.             }
  45.             Console.ReadKey(false);
  46.         }
  47.     }
  48. }

程序的运行结果如下：

8.join子句

如果一个数据源中元素的某个属性可以跟另外一个数据源的中元素的某个属性进行相等比较，那么这两个数据源可以用join子句进行关联。

join子句使用equals关键字进行相等比较，而不是常用的双等号。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace LINQ_join
  7. {
  8.     class Program
  9.     {
  10.         static void Main(string[] args)
  11.         {
  12.             //定义两个数据源
  13.             List<GustInfo> gList = new List<GustInfo>()
  14.             {
  15.                 new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
  16.                 new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
  17.                 new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
  18.                 new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
  19.                 new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
  20.                 new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
  21.             };
  22.  
  23.             List<GuestTitle> titleList = new List<GuestTitle>()
  24.             {
  25.                 new GuestTitle(){Name="DebugLZQ",Title="Soft Engineer"},
  26.                 new GuestTitle(){Name="DebugLZQ",Title="Team Leader"},
  27.                 new GuestTitle(){Name="Sarah",Title="Test Engineer"},
  28.                 new GuestTitle(){Name="Jerry",Title="Head Master"}
  29.             };
  30.             //1.根据姓名进行内连接
  31.             var query = from guest in gList
  32.                         join title in titleList on guest.Name equals title.Name
  33.                         select new { Name=guest.Name ,Title=title.Title,Age=guest.Age };
  34.  
  35.             foreach (var g in query)
  36.             {
  37.                 Console.WriteLine("{0} {1} 年龄：{2}",g.Name,g.Title ,g.Age );
  38.             }
  39.             Console.ReadKey(false);
  40.  
  41.             //前面的多个from实现相同的作用:与内连接区别在于：这个中间的操作是叉乘获得笛卡尔积
  42.             var query2=from guest in gList
  43.                        from title in titleList
  44.                        where guest.Name==title.Name
  45.                        select new { Name = guest.Name, Title = title.Title, Age = guest.Age };
  46.  
  47.             foreach (var g in query2)
  48.             {
  49.                 Console.WriteLine("{0} {1} 年龄：{2}", g.Name, g.Title, g.Age);
  50.             }
  51.             Console.ReadKey(false);
  52.  
  53.             //2.根据姓名进行分组连接
  54.             //根据名字分组后，得到每个名字下的全部名称
  55.             var query3 = from guest in gList
  56.                          join title in titleList on guest.Name equals title.Name into tgroup
  57.                          select new { Name=guest.Name,Titles=tgroup };
  58.  
  59.             foreach (var g in query3)
  60.             {
  61.                 Console.WriteLine(g.Name);
  62.                 foreach (var g2 in g.Titles)
  63.                 {
  64.                     Console.WriteLine("    {0}",g2.Title );
  65.                 }
  66.             }
  67.             Console.ReadKey(false);
  68.             //3.根据姓名进行左外连接
  69.             //无职务的输出为空缺
  70.             var query4 = from guest in gList
  71.                          join title in titleList on guest.Name equals title.Name into tgroup
  72.                          from subtitle in tgroup.DefaultIfEmpty()
  73.                          select new { Name=guest.Name,Title=subtitle==null?"空缺":subtitle.Title };
  74.             foreach (var g in query4)
  75.             {
  76.                 Console.WriteLine("{0}  {1}  ",g.Name ,g.Title );
  77.             }
  78.             Console.ReadKey(false);
  79.  
  80.         }
  81.     }
  82. }

程序结果如下：

以上就是LINQ的基本子句的常用用法，文字不是很多，因为代码中都有详细的注释说明。其他的一些查询运算符，将在后面几篇博文中陆续总结~~

LINQ的基本语法包含如下的8个上下文关键字，这些关键字和具体的说明如下的更多相关文章

  1. Linq to SQL 语法查询(链接查询，子查询 & in操作 & join，分组统计等)

    Linq to SQL 语法查询(链接查询,子查询 & in操作 & join,分组统计等) 子查询 描述:查询订单数超过5的顾客信息 查询句法: var 子查询 = from c i ...

  2. FreeSql （二十四）Linq To Sql 语法使用介绍

    原本不支持 IQueryable 主要出于使用习惯的考虑,如果继承 IQueryable,编写代码的智能总会提示出现一堆你不想使用的方法(对不起,我有强迫症),IQueryable 自身提供了一堆没法 ...

  3. Linq中常用语法

    using System;using System.Collections.Generic;using System.ComponentModel.Design;using System.Linq;u ...

  4. C#程序集系列04,在程序集包含多个module的场景下理解关键字internal

    本篇在一个程序集包含多个module的场景下体验internal的含义. →查看F盘as文件夹下的文件→删除MainClass.exe→把MyFirstModule和MySecondModule组装到 ...

  5. [转]LINQ To SQL 语法及实例大全

    转载自:http://blog.csdn.net/pan_junbiao/article/details/7015633 LINQ to SQL语句(1)之Where Where操作 适用场景:实现过 ...

  6. LINQ To SQL 语法及实例大全

    http://blog.csdn.net/pan_junbiao/article/details/7015633 http://blog.csdn.net/pan_junbiao/article/de ...

  7. Linq to sql语法

    LINQ to SQL语句(1)之Where Where操作 适用场景:实现过滤,查询等功能. 说明:与SQL命令中的Where作用相似,都是起到范围限定也就是过滤作用的,而判断条件就是它后面所接的子 ...

  8. Linq to Sql语法及实例大全

    LINQ to SQL语句(1)之Where Where操作 适用场景:实现过滤,查询等功能. 说明:与SQL命令中的Where作用相似,都是起到范围限定也就是过滤作用的 ,而判断条件就是它后面所接的 ...

  9. 【转】 LINQ To SQL 语法及实例大全

    LINQ to SQL语句(1)之Where Where操作 适用场景:实现过滤,查询等功能. 说明:与SQL命令中的Where作用相似,都是起到范围限定也就是过滤作用的,而判断条件就是它后面所接的子 ...

随机推荐

  1. 紫书 例题 11-14 UVa 1279 （动点最小生成树）（详细解释）

    这道题写了好久-- 在三维空间里面有动的点, 然后求有几次最小生成树. 其实很容易发现, 在最小生成树切换的时候,在这个时候一定有两条边相等, 而且等一下更大的那条边在最小生成树中,等一下更小的边不在 ...

  2. WPF 一个空的 WPF 程序有多少个窗口

    原文:WPF 一个空的 WPF 程序有多少个窗口 好多小伙伴说 WPF 的程序有五个窗口,但是我尝试使用了 EnumThreadWindows 去获取的时候居然拿到了 10 多个窗口 在 WPF 内部 ...

  3. hdu_1166,线段树单点更新

    在刷线段树,参考自http://www.notonlysuccess.com/index.php/segment-tree-complete/ #include<iostream> #in ...

  4. matplotlib 可视化 —— 定制 matplotlib

    1. matplotlibrc 文件 matplotlib使用matplotlibrc [matplotlib resource configurations] 配置文件来自定义各种属性,我们称之为 ...

  5. Git-如何将已存在的项目提交到git

    1.首先在码云或者github上创建一个不带README.md的项目,然后复制远程库的地址(下面以码云为例): 2.进入本地已存在的项目目录:house  touch README.md //新建说明 ...

  6. django 笔记6 Ajax

    感谢alex~ .Django请求生命周期 输入url 进入 urls(路由系统) 指向 views(视图函数)->(获取模板) 里面的函数 再由函数返回字符串给用户 .路由系统 /index/ ...

  7. UVa 1599 Ideal Path【BFS】

    题意:给出n个点,m条边,每条边上涂有一个颜色,求从节点1到节点n的最短路径,如果最短路径有多条,要求经过的边上的颜色的字典序最小 紫书的思路:第一次从终点bfs,求出各个节点到终点的最短距离, 第二 ...

  8. 51Nod 不重叠的线段（贪心）

    X轴上有N条线段,每条线段有1个起点S和终点E.最多能够选出多少条互不重叠的线段.(注:起点或终点重叠,不算重叠). 例如:[1 5][2 3][3 6],可以选[2 3][3 6],这2条线段互不重 ...

  9. 解决高版本vm打开虚拟机报错

    问题: 打开虚拟机的文件目录,找到.vmx 文件 用记事本打开重命名后的“.vmx.txt”文件 找到行:policy.vm.mvmtid = "52 10 08 ed ff 34 ed d ...

  10. 仿函数(functor)

    仿函数(functor),就是使一个类的使用看上去像一个函数.其实现就是类中实现一个operator(),这个类就有了类似函数的行为,就是一个仿函数类了. In computer programmin ...