int[] number = { 2, 4, 6, 8, 10 }; //获取数据源
IEnumerable<int> lowNum = from n in number //创建并存储查询，不会执行操作
                          where n < 8
                          select n;
foreach (var val in lowNum) //执行查询
{
    Console.Write("{0} ", val);
}

// Linq语法：
  var data=from a in db.Areas select a ;
// Lamda语法：
  var data=db.Areas;
// sql语法：
  string sqlStr=" SELECT * FROM Areas  ";

// Linq语法：
  var data=from a in db.orderInfo where a.orderId > 20 select a ;
// Lamda语法：
  var data=db.orderInfo.Where( t=>t.orderId > 20 ) ;
// sql语法：
  string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ";

// Linq语法：
  var data=( from a in db.orderInfo select a ).Max( p=>p.orderId ) ;//查询该表中最大编号Id
  var data=( from a in db.orderInfo select a ).Min( p=>p.orderId ) ;//查询该表中最小编号Id
  var data=( from a in db.orderInfo select a ).Count() ;//查询该表数据总条数
  var data=( from a in db.orderInfo select a ).Sum( p=>p.orderMoney ) ;//查询该表中所有消费额的总数（求和）
  
// Lamda语法：
  var data=db.orderInfo.Max( t=>t.orderId );//查询该表中最大编号Id
  var data=db.orderInfo.Min( t=>t.orderId );//查询该表中最小编号Id
  var data=db.orderInfo.Count();//查询该表数据总条数
  var data=db.orderInfo.Sum( t=>t.orderMoney );//查询该表中所有消费额的总数（求和）
  
// sql语法：
  string sqlStr=" SELECT MAX(orderId) FROM orderInfo ";
  string sqlStr=" SELECT MIN(orderId) FROM orderInfo ";
  string sqlStr=" SELECT COUNT(*) FROM orderInfo ";
  string sqlStr=" SELECT SUM(orderMoney ) FROM orderInfo ";

// Linq语法：
  var data=from a in db.orderInfo where a.orderId > 20 orderby a.orderId descending select a ;//倒序排序，升序可用ascending关键字
  
// Lamda语法：
  // 情况一，根据单字段排序： OrderByDescending
  var data=db.orderInfo.OrderByDescending( t=>t.orderId ).Where( t=>t.orderId > 20 ) .ToList();// 升序可用OrderBy关键字
  // 情况二，根据多字段主次排序：OrderBy == ThenBy
  var priceMonthEntities = priceMonthApp.GetList().OrderBy(t => t.F_Year).ThenBy(t => t.F_Month).ToList();//先按年升序，再按月升序
  
// sql语法：
  string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ORDER BY orderId DESC  ";//倒序排序，升序可用ASC关键字

// Linq语法：  取集合中第一个记录
var ss = (from r in db.Am_recProScheme
          select r).FirstOrDefault();
// Lamda语法： 
var ss1 = db.Am_recProScheme.FirstOrDefault();
//var ss1 = db.Am_recProScheme.First();   
// Sql语法：       
string sssql = "select top(1) * from Am_recProScheme";


//    取最后一个记录，先倒序排列再取值 ，实例如下：
lists.Reverse();  // 先对集合进行倒序
var s2 = lists.FirstOrDefault();
MessageBox.Show(s2.ToString());

//1 Linq语法：
var ss = (from r in db.Am_recProScheme
          orderby r.rpId descending
          select r).Skip(10); //跳过前10条数据，取10条之后的所有数据   
//2 Lamda语法：  
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
//3 Sql语法：
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";

//1 Linq语法：
var ss = (from r in db.Am_recProScheme
          orderby r.rpId descending
          select r).Take(10); // 截取前10条数据  
//2 Lamda语法：  
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Take(10).ToList();
//3 Sql语法：
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum<=10";

【参考1：】
// Linq语法：
  var data=( from a in db.orderInfo select a ) .Skip((pageIndex-1) * pageSize).Take(pageSize).ToList();
// Lamda语法： pageIndex:当前页码，pageSize：分页数据显示条数
  var data=db.orderInfo.Skip((pageIndex-1)* pageSize).Take(pageSize).ToList();  
// sql语法：
  string sqlStr="SELECT TOP pageSize * FROM orderInfo WHERE orderId NOT IN(SELECT TOP( ( pageIndex - 1) * pageSize) orderId FROM orderInfo)";

【参考2：】
// 1 Linq语法：
var ss = (from r in db.Am_recProScheme
          where r.rpId > 10
          orderby r.rpId descending
          select r).Skip(10).Take(10); //取第11条到第20条数据
          
//2 Lamda语法：   Take(10): 数据从开始获取，获取指定数量（10）的连续数据
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
//3 Sql语法：
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";

【参考1：】
// Linq语法：
  var data= from a in db.orderInfo orderby a.orderId descending 
            group a by a.orderType into s select new{
            s.key,//分组字段
            s.sMoney=s.Sum(a=>a.orderMoney),//分组后算出总的消费额
            s.maMoney=s.Max(a=>a.orderMoney),//分组后算出最大的消费额
            s.miMoney=s.Min(a=>a.orderMoney)//分组后算出最小的消费额
            };
// Lamda语法：
  //使用GroupBy关键字进行分组查询（单个字段）
  var data=db.orderInfo.GroupBy(p => p.recType).Select(t=>t.Key).ToList();
  //使用GroupBy关键字进行分组查询（多个字段）
  var data=db.orderInfo.GroupBy(p =>new{ p.recType,p.orderId}).Select(t=>new{ recType=t.Key.recType,orderId=t.Key.orderId}).ToList();
  
// sql语法：
  string sqlStr="SELECT orderType , SUM(orderMoney), MAX(orderMoney), MIN(orderMoney) FROM orderInfo GROUP BY orderType";


【参考2】
//1 Linq语法：
var ss = from r in db.Am_recProScheme
         orderby r.rpId descending
         group r by r.recType into n
         select new
         {
             n.Key,  //这个Key是recType
             rpId = n.Sum(r => r.rpId), //组内rpId之和
             MaxRpId = n.Max(r => r.rpId),//组内最大rpId
             MinRpId = n.Min(r => r.rpId), //组内最小rpId
         };
foreach (var t in ss)
{
    Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
}
//2 Linq语法：
var ss1 = from r in db.Am_recProScheme
         orderby r.rpId descending
         group r by r.recType into n
         select n;
foreach (var t in ss1)
{
    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//3 Lamda语法：
var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
foreach (var t in ss2)
{
    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//4 sql语法：
string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";

// Linq语法：  使用Contains关键字进行模糊匹配
  var data= from a in db.orderInfo where a.orderId.Contains(1) select a;
// Lamda语法：  使用Contains关键字进行模糊匹配
  var data=db.orderInfo.Where(t=>t.F_UserId.Contains("1")).ToList();
// sql语法：   使用like关键字进行模糊匹配
  string sqlStr="SELECT * FROM orderInfo WHERE orderId LIKE '%12%'";

【实例1：】
// Linq语法：
  var data= from a in db.orderInfo where (new int?[2213,43311,32422]).Contains(a.orderId) select a ; 
// Lamda语法：
  var data=db.orderInfo.Where(t=>(new int?[2213,43311,32422]).Contains(t.orderId)).ToList();
// sql语法：
  string sqlStr="SELECT * FROM orderInfo WHERE orderId IN (2213,43311,32422)";

【实例2：】
// Linq语法：
var ss = from p in db.Am_recProScheme
                  where (new int?[] { 24, 25,26 }).Contains(p.rpId)
                  select p;
foreach (var p in ss)
{
    Response.Write(p.Sorts);
}

// sql语法：
string st = "select * from Am_recProScheme where rpId in(24,25,26)";

【参考1】
// Linq语法：
var ss = from r in db.Am_recProScheme
         join w in db.Am_Test_Result on r.rpId equals w.rsId
         orderby r.rpId descending
         select r;
// Lamda语法：
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
// sql语法：
string sssql = "SELECT r.* FROM Am_recProScheme AS r INNER JOIN Am_Test_Result AS t ON r.[rpId] = t.[rsId] ORDER BY r.[rpId] DESC";


【参考2】
//Linq
var ss = from r in db.Am_recProScheme
         join w in db.Am_Test_Result on r.rpId equals w.rsId
         orderby r.rpId descending
         select r;
         
//Lambda
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();

//SQL
string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";

//客户类
public class Customer
    {
        public int id { get; set; }
        public string name { get; set; }
        public string email { get; set; }
    }
    //联系方式类
  public class CustomerContact
    {
        public int ccid { get; set; }
        public int CustomerId { get; set; }//客户的id，外键
        public string Phone { get; set; }
        public string Address { get; set; }
    }
   //模拟数据
           public static List<Customer> GetCustomer()//客户
        {
            List<Customer> list = new List<Customer>();
            list.Add(new Customer { id = 1, name = "刘德华",  email = "ldh@net.cn" });
            list.Add(new Customer { id = 2, name = "张学友",  email = "zxy@net.cn" });
            list.Add(new Customer { id = 3, name = "黎明",  email = "lm@net.cn" });
            list.Add(new Customer { id = 4, name = "郭富城",  email = "gfc@net.cn" });
            list.Add(new Customer { id = 4, name = "古天乐",  email = "gtl@net.cn" });
            return list;
        }
        public static List<CustomerContact> GetCustomerContact()//联系人
        {
            List<CustomerContact> list = new List<CustomerContact>();
            list.Add(new CustomerContact { ccid = 1,CustomerId=1, Phone="13566769988",Address="北京"});
            list.Add(new CustomerContact { ccid = 2, CustomerId = 1, Phone = "13566769986", Address = "天津" });
            list.Add(new CustomerContact { ccid = 3, CustomerId =2, Phone = "13677889900", Address = "香港" });
            list.Add(new CustomerContact { ccid = 4, CustomerId = 8, Phone = "13677889332", Address = "上海" });
            return list;
        }

// 1. 左连接
var LeftJoin = from cusetomer in GetCustomer()
                join cc in GetCustomerContact()
                on cusetomer.id equals cc.CustomerId 
                // 内连接的基础上， 加入这行代码就实现类左连接
                into JoinCC from cc in JoinCC.DefaultIfEmpty()
                select new
                {
                    CustomerName = cusetomer.name,
                    phone = cc != null ? cc.Phone : null
                };

// 2. 右连接：
//         右链接跟左链接相反，只需要改一下顺序就可以了。
 var LightJoin = from cc in GetCustomerContact()
                 join cusetomer in GetCustomer()
                 on cc.CustomerId equals cusetomer.id 
                 // 内连接的基础上， 加入这行代码就实现类左连接
                 into JoinCC from cusetomer in JoinCC.DefaultIfEmpty()
                select new
                {
                    phone = cc.Phone,
                    CustomerName =cusetomer != null ? cusetomer.name : null,
                };
// 3. 内连接：
var InnerJoin = from cc in GetCustomerContact()
                 join cusetomer in GetCustomer()
                 on cc.CustomerId equals cusetomer.id 
                 select new
                 {
                     phone = cc.Phone,
                     CustomerName = cusetomer.name
                 };
// 3-2 内连接：  多个条件关联的join 
var whiteDiagList = (from r1 in diagControlList
        where r1.ControlRelation == 1
        join r2 in args.DiagList on new { code = r1.DiagCode, name = r1.DiagName }
        equals new{code=r2.DiagCode,name=r2.DiagName}
        select r1).ToList<DiagControlModel>();

// 1. 左连接：
var LMLeftJoin = GetCustomer().GroupJoin(GetCustomerContact(), 
 a => a.id, b => b.CustomerId, (a, b) =>new { a,b })
     .SelectMany(c=>c.b.DefaultIfEmpty(), (c, b) 
     =>new { CustomerName= c.a.name,Phone=b!=null?b.Phone:null });

// 2. 右连接：参考左连接，两个集合对调位置就行了

// 3. 内连接：
var LMInnerJoin = GetCustomer().Join(GetCustomerContact(), a => a.id, b => b.CustomerId
, (a, b) => new { CustomerName = a.name, Phone = b.Phone });

List<string> ListA = new List<string>();
List<string> ListB = new List<string>();
List<string> ListResult = new List<string>();

ListResult = ListA.Distinct().ToList();//去重
ListResult = ListA.Except(ListB).ToList();//差集
ListResult = ListA.Union(ListB).ToList();  //并集
ListResult = ListA.Intersect(ListB).ToList();//交集

    public class ItemModel
    {
        public string ItemCode { get; set; }
        public string ItemName { get; set; }
    }

public class ItemModelComparer : IEqualityComparer<ItemModel>
{
        //比较
        public bool Equals(ItemModel x, ItemModel y)
        {
            bool checkFlag = true;

            if (Object.ReferenceEquals(x, y))
            {
                checkFlag = true;
            }
            else if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
            {
                checkFlag = false;
            }
            else
            {
                if (x.ItemCode == y.ItemCode) //若Model有多个条件则需要添加。例如 if(x.ItemCode==y.ItemCode && x.Other==y.Other)
                {
                    checkFlag = true;
                }
                else
                {
                    checkFlag = false;
                }
            }

            return checkFlag;

        }
    
        //实现获取哈希值
        public int GetHashCode(ItemModel model)
        {
            if (Object.ReferenceEquals(model, null)) return 0;
            int hashNurse = model.ItemCode.GetHashCode(); 

//            若两个集合有多个关联条件，则哈希值也需要进行计算
//            int hashOther=model.Other.GetHashCode();
//           int resultHash=hashNurse^hashOther;
//            return resultHash;

            return hashNurse;
        }
    
    }

List<ItemModel> ListA = new List<ItemModel>();
List<ItemModel> ListB = new List<ItemModel>();
List<ItemModel> ListResult = new List<ItemModel>();

ListResult = ListA.Distinct(new ItemModelComparer()).ToList();//去重
ListResult = ListA.Except(ListB, new ItemModelComparer()).ToList();//差集
ListResult = ListA.Union(ListB, new ItemModelComparer()).ToList();  //并集
ListResult = ListA.Intersect(ListB, new ItemModelComparer()).ToList();//交集