linq 和lamba表达式

一、什么是Linq(what)
二、Linq的优点(why)
三、Linq查询的步骤(how)
四、查询基本操作
五、結合實例代碼(具體聯繫用linqtosql來寫的增刪改查)
一．什么是Linq(what)
.net的设计者在类库中定义了一系列的扩展方法
来方便用户操作集合对象
这些扩展方法构成了LINQ的查询操作符
这一系列的扩展方法，比如：
Where，Max，Select，Sum，Any，Average，All，Concat等
都是针对IEnumerable的对象进行扩展的
也就是说，只要实现了IEnumerable接口，就可以使用这些扩展方法  //其实引用using system.linq就好了
Linq是语言集成查询（Language Integrated Query）的简称，是visual Studio 2008和.NET Framework 3.5版本中一项突破性的创新，它在对象领域和数据领域之间架起了一座桥梁。
Linq支持各种数据源：
1、ADO.NET DataSet
2、XML文档
3、SQL Server数据库
4、更多。。。
二、Linq的优点(why)
IEnumerable接口是LINQ特性的核心接口
　　　　　　　　只有实现了IEnumerable接口的集合
　　　　　　　　才能执行相关的LINQ操作，比如select,where等
传统的SQL查询
1 select FirstName,LastName,* from Customers
2 where city = 'Shanghai'
3 order by district
简单的字符串表示，没有编译时类型检查，没有IDE的智能感知支持。
以上例子只是针对SQL，针对不同的数据源，例如XML文档、各种WEB服务等我们还要学习不同的查询方法。
•    Linq查詢為什麼要把from放到前面
IDE智能感知支持(智能提示)
三、Linq查询的步骤(how)
所有的Linq查询操作都由以下三个不同的操作组成：
•    获得数据源
•    创建查询
•    执行查询
数据源
•    想要使用Linq进行查询，数据源必须支持IEnumerable或IEnumerable(T)泛型接口或派生接口（如泛型的IQueryable(T)接口。
查询执行
•    查询变量本身只是存储查询命令。实际的查询执行会延迟在foreach语句中循环访问变量时发生。此概念称为“延迟执行”。
•    强制立即执行，可以通过以下两个方法，使得Linq立即执行查询
　　    执行聚合函数（Count、Max、Average、First）
四、查询基本操作
 1、from子句
      用于获取数据源
1 var queryAllCustomers=
2       from cust in Customers
3       select cust;
2、复合from子句
 
 1 //数据源
 2 IList<Student> students = new List<Student>
 3 {
 4     new Student{ Name="Kevin", Score=new List<int>{89,93,88,78}},
 5     new Student{ Name="Jackie",Score=new List<int>{92,87,83,91}},
 6     new Student{ Name="Helen",Score=new List<int>{53,76,72,62}}
 7 };
 8
 9 //使用复合from子句查询命令
10 var getStudent =
11         from student in students
12         from score in student.Score
13         where score > 90
14         select new { Name=student.Name,Score=score};
 
3、使用let子句扩展范围变量
    用于创建查询自身的范围变量
 
 1 string[] strings ={
 2                  "I am a new Student.",
 3                  "You are a talent"
 4                  };
 5
 6 var query = from sentences in strings
 7             let words = sentences.Split(' ')
 8             from word in words
 9             let w = word.ToLower()
10             where w[0] == 'a' || w[0] == 'e' || w[0] == 'i' || w[0] == 'o' ||
                     w[0] == 'u'
11             select word;
12
13 foreach (var word in query)
14 {
15     Console.Write(word + ",");
16 }
 
4、where子句
 1 //数据源
 2 int[] arr = { 0, 3, 2, 1, 9, 6, 8, 7, 4, 5 };
 3
 4 //使用Where子句查询的查询语句
 5 var query = from a in arr
 6             where a < 5 && a % 2 == 0
 7             select a;
 8
 9 //执行查询
10 foreach (var a in query)
11 {
12     Console.WriteLine(a);
13 }
 5、orderby子句
1 var query = from a in arr
2             where IsEven(a)
3             orderby a ascending
4             select a;
接着上个例子的演示，本例是一个升序的排序。
1 var query = from a in arr
2             where IsEven(a)
3             orderby a descending
4             select a;
本例是一个降序的排序。
6、group子句
 
 1 //数据源
 2 string[] fruits = { "apple", "banana", "peach", "orange", "melon", "lemon" };
 3
 4 //分组查询的查询语句
 5 var query = from f in fruits
 6             group f by f[0];
 7
 8 //执行查询
 9 foreach (var letters in query)
10 {
11     Console.WriteLine("words that start with letter:" + letters.Key);
12     foreach (var word in letters)
13     {
14         Console.WriteLine(word);
15     }
16 }
 
1 var query = from f in fruits
2             group f by f[0] into g
3             where g.Key == 'p' || g.Key == 'b'
4             select g;
 7、join子句
1）内部连接
1 var innerJoinQuery =
2              from category in categories
3              join prod in products on category.ID equals prod.CategoryID
4                      select new { ProductName = prod.Name, Category = category.Name };
2）分组连接
1 var innerGroupJoinQuery =
2              from category in categories
3              join prod in products on category.ID equals prod.CategoryID
4              into prodGroup
5              select new { CategoryName = category.Name, Products = prodGroup };
 3）左外部连接
1 var leftOuterJoinQuery =
2              from category in categories
3              join prod in products on category.ID equals prod.CategoryID
4              into prodGroup
5                      from prod in prodGroup.DefaultIfEmpty()
6                      select new { CatName = category.Name, ProdName = prod.Name };
 8、equals关键字
•    join子句执行同等连接。换句话说，只能基于两个键之间的相等关系进行匹配。
•    为了表明所有连接都是同等连接，join子句使用equals关键字而不是==运算符
9、select子句（选择、投影）
select子句可以指定将在执行查询时产生的值的类型。该子句的结果将基于前面所有子句的计算结果以及select子句本身中的所有表达式。
查询表达式必须以select子句或group子句结束

Linq To Sql中实现Left Join与Inner Join使用Linq语法与lambda表达式

当前有两个表，sgroup与sgroupuser，两者通过gKey关联，而sgroup表记录的是组，而sgroupuser记录是组中的用户，因此在sgroupuser中不一定有数据。需要使用Left Join获取数据：

Linq语法如下:

var sg = (from g in dc.sgroup
                     join gu in dc.sgroupuser on g.gKey equals gu.gKey into l
                     from lgu in l.DefaultIfEmpty()
                      select new { g, lgu }).ToList();

Lambda表达式如下：

var sg = dc.sgroup.GroupJoin(dc.sgroupuser, g => g.gKey, gu => gu.gKey, (g, gu) => new { g, gu }).Select(o=>o).ToList() ;

注意:

    Linq 与Lambda表达式取出的结果有所不同.Linq取出的结果的记录数与Sql中的Left Join的结果相同,而Lambda表达式取出的记录数是sgroup表中的记录数,sgroupuser对应的记录是以对象集合存在于结果中

附:

下面是Inner Join:

Linq语法如下:

var sg = (from g in dc.sgroup
                    join gu in dc.sgroupuser on g.gKey equals gu.gKey                  
                    select new { g, gu }).ToList();

Lambda表达式如下：

var sg = dc.sgroup.Join(dc.sgroupuser, g => g.gKey, gu => gu.gKey, (g, gu) => new { g, gu }).Select(o=>o).ToList() ;

注意:

   上面最后都用到了ToList()方法 , 用ToList()是为了一次性将数据取到本地.

 闲言碎语
近期比较忙，但还是想写点什么，就分享一些基础的知识给大家看吧，希望能帮助一些linq新手，如果有其它疑问，可以进右上角群，进行交流探讨，谢谢。
开门见山
读这篇文章之前，我先说下，每一种搜索结果集，我都以三种方式变现出来，为啦更好的理解，希望不要嫌我啰嗦。
1.简单的linq语法
 
            //1
            var ss = from r in db.Am_recProScheme
                     select r;
            //2
            var ss1 = db.Am_recProScheme;
            //3
            string sssql = "select * from Am_recProScheme";
 
2.带where的查询
 
            //1
            var ss = from r in db.Am_recProScheme
                     where r.rpId > 10
                     select r;
            //2
            var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
            //3
            string sssql = "select * from Am_recProScheme where rpid>10";
 
3.简单的函数计算（count，min，max，sum）
 
            //1
            ////获取最大的rpId
            //var ss = (from r in db.Am_recProScheme
            //          select r).Max(p => p.rpId);
            ////获取最小的rpId
            //var ss = (from r in db.Am_recProScheme
            //          select r).Min(p => p.rpId);
            //获取结果集的总数
            //var ss = (from r in db.Am_recProScheme                  
            //         select r).Count();
            //获取rpId的和
            var ss = (from r in db.Am_recProScheme
                      select r).Sum(p => p.rpId);


            //2
            //var ss1 = db.Am_recProScheme.Max(p=>p.rpId);
            //var ss1 = db.Am_recProScheme.Min(p => p.rpId);
            //var ss1 = db.Am_recProScheme.Count() ;
            var ss1 = db.Am_recProScheme.Sum(p => p.rpId);
            Response.Write(ss);

            //3
            string sssql = "select max(rpId) from Am_recProScheme";
                   sssql = "select min(rpId) from Am_recProScheme";
                   sssql = "select count(1) from Am_recProScheme";
                   sssql = "select sum(rpId) from Am_recProScheme";
 
4.排序order by desc/asc
 
            var ss = from r in db.Am_recProScheme
                     where r.rpId > 10
                     orderby r.rpId descending  //倒序
                     //  orderby r.rpId ascending   //正序
                     select r;

            //正序
            var ss1 = db.Am_recProScheme.OrderBy(p => p.rpId).Where(p => p.rpId > 10).ToList();
            //倒序
            var ss2 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).ToList();

            string sssql = "select * from Am_recProScheme where rpid>10 order by rpId [desc|asc]";
 
5.top(1)
 
            //如果取最后一个可以按倒叙排列再取值
            var ss = (from r in db.Am_recProScheme                     
                      select r).FirstOrDefault();

            //（）linq to ef 好像不支持 Last()
            var ss1 = db.Am_recProScheme.FirstOrDefault();
            //var ss1 = db.Am_recProScheme.First();          

            string sssql = "select top(1) * from Am_recProScheme";
 
6.跳过前面多少条数据取余下的数据
 
            //1
            var ss = (from r in db.Am_recProScheme
                      orderby r.rpId descending
                      select r).Skip(10); //跳过前10条数据，取10条之后的所有数据   
            //2  
            var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
            //3
            string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";
 
7.分页数据查询
 
            //1
            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 Take(10): 数据从开始获取，获取指定数量（10）的连续数据
            var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
            //3
            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";
 
8.包含，类似like '%%'
 
            //1
            var ss = from r in db.Am_recProScheme
                     where r.SortsText.Contains("张")
                     select r;
            //2
            var ss1 = db.Am_recProScheme.Where(p => p.SortsText.Contains("张")).ToList();
            //3
            string sssql = "select * from Am_recProScheme where SortsText like '%张%'";
 
9.分组group by
 
            //1
            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
            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
            var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
            foreach (var t in ss2)
            {
                Response.Write(t.Key + "--" + t.Min(p => p.rpId));
            }
            //4
            string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";
 
10.连接查询
 
            //1
            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;
            //2
            var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
            //3
            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";
 
11.sql中的In
 
            //1
            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);
            }
            //2
            string st = "select * from Am_recProScheme where rpId in(24,25,26)";
 

 

egg:例子

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Collections;

namespace fuck
{
    public delegate int del(int i);
    public delegate bool Mydetext();
    class Program
    {
        //聲明委託變量
        public Mydetext mytext;
        static void Main(string[] args)
        {
            #region 例子一
            //聲明委託變量
            del myDelegate = x => x * x; //lambda表達式也就是匿名委託的原理  
            //聲明委託變量
            del myDelegatetwo = delegate(int x)
                {
                    return x * x;
                };
            int i = myDelegate(5);
            int j = myDelegatetwo(5); //j = 25
            Console.WriteLine(i);
            Console.WriteLine(j);
            #endregion

            #region 例子二
            //聲明委託變量
            if (new Program() { mytext = new Mydetext(delegate() { Console.Write("Hello "); return false; }) }.mytext())
            {
                Console.Write("Hello ");
            }
            else
            {
                Console.WriteLine("World");
            }
            if (new Func<bool>(() => { Console.Write("Hello "); return false; }).Invoke())
            {
                Console.Write("Hello ");
            }
            else
            {
                Console.WriteLine("World");
            }
            if (new Program() { mytext = new Mydetext(() => { Console.Write("Hello "); return false; }) }.mytext())
            {
                Console.Write("Hello ");
            }
            else
            {
                Console.WriteLine("World");
            }
            #endregion

            #region 例子三
            List<int> ls = new List<int>();
            ls.Add(1);
            ls.Add(9);
            ls.Add(5);
            ls.Add(7);
            var chaojie = ls.Select((m, index) => new { m, index }).OrderByDescending(n => n.m).Take(1);
            //try 下面的和上面的效果是一樣子的   //這裡是這樣子理解的聲明一個匿名委託 return new { m, index };可以理解為查詢出m,和index
            var chaojietwo = ls.Select(delegate(int m,int index) { return new { index, m }; }).OrderByDescending(n => n.m).Take(1);
            //在這裡其實就是ls.Select(new {})  和例子四很像   delegate(int m,int index)的參數順序決定是值,還是索引/第一個是值,第二個是索引
            foreach (var w in chaojietwo)
            {
                Console.WriteLine("索引" + w.index + ",值" + w.m);
            }
            #endregion

            #region 例子四
            Dictionary<int,string> alt=new Dictionary<int,string>();
            alt.Add(1,"一");
            alt.Add(9,"九");
            alt.Add(5,"五");
            alt.Add(7,"七");
            var query = from qy in alt
                        select new {qy.Key,qy.Value };
            foreach (var q in alt)
            {
                Console.WriteLine("鍵" + q.Key + ",值" +q.Value);
            }
            #endregion

            #region 例子五
            List<double> list = new List<double>();
            list.Add(2.55);
            list.Add(4.45);
            list.Add(12.35);
            list.Add(18.35);
            list.Add(17.35);
            list.Add(19.35);
            list.Add(6.355);
            list.Add(7.95);
            list.Add(4.35);
            var v = list.Select((m, index) => new { m, index }).OrderByDescending(n => n.m).Take(1);
            foreach (var w in v)
            {
                Console.WriteLine("索引"+w.index+",值"+w.m);
            }
            List<double> list2 = new List<double>();
            list2.Add(2.55);
            list2.Add(4.45);
            list2.Add(18.35);
            list2.Add(17.35);
            list2.Add(19.35);
            list2.Add(6.355);
            list2.Add(7.95);
            list2.Add(4.35);
            //其實這兩個是一個樣子的
            //var lt2 = list2.Where(a=>a==2.55);
            //lt2也可以寫成
            var lt2 = list2.Where(delegate(double ls11) { return ls11==2.55;});


           // var lt3 = (from z in list2
                      // select z).Where(y=>y>3);
            //其實下面這個和上面這個也是一樣子的
            var lt3 = (from z in list2
                       select z).Where(delegate(double y) { return y > 3; });
            Console.WriteLine("條件一");
            foreach (var w in lt2)
            {
                Console.WriteLine("值"+w);
            }
            Console.WriteLine("條件二");
            foreach (var w in lt3)
            {
                Console.WriteLine("值" + w);
            }
            #endregion

   #region 例子六
            //list去除掉重复行
            List<int> qls = new List<int>();
            qls.Add(1);
            qls.Add(1);
            qls.Add(3);
            qls.Add(2);
            qls.Add(4);
            qls.Add(3);
            for (int p = 0; p < qls.Count; p++)
            {
                int counts = -1;
                for (int q = 0; q < qls.Count; q++)
                {
                    if (qls[p] == qls[q])
                    {
                        counts=counts+1;
                    }
                    if (counts == 1)
                    {
                        qls.Remove(qls[p]);
                        counts=counts-1;
                    }
                }
            }

//两行效果是一样的
            var qlstry = qls.OrderBy(p=>p);//进行排序

             IEnumerable<int> qlstry = qls.OrderBy(p => p);
            foreach (var ww in qlstry)
            {
                Console.WriteLine("值" + ww);
            }
            #endregion
            Console.ReadKey();
           
        }
    }
}
效果

例子六 效果是  1234

在公司的讲课

關於linq的最簡單例子
例子1
            var ss = from r in Am_recProScheme
                     select r;
            string sssql = "select * from Am_recProScheme";
例子2
            var ss = from r in Am_recProScheme
                     where r.rpId > 10
                     select r;          
            string sssql = "select * from Am_recProScheme where rpid>10";

關於linq的最簡單例子

簡單函數count min max sum 的應用

例子3      var ss = (from r in Am_recProScheme

                     select r).Max(p=>p.rpId);

           var ss = (from r in Am_recProScheme

                     select r).Sum(p=>p.rpId);

           var ss = (from r in Am_recProScheme

                     select r).Min(p=>p.rpId);

 

            string sssql = "select Max(reId) from Am_recProScheme";

            string sssql = "select Sum(reId) from Am_recProScheme";

            string sssql = "select Min(reId) from Am_recProScheme";

簡單order by應用

例子4            

             var ss = from r in Am_recProScheme

                     where r.rpId > 10

                     order by r.reId desc

                     select r;

                      

           

           string sssql = "select * from Am_recProScheme where rpid>10 order by rpId desc"



關於linq的最簡單例子

簡單函數like,in的應用

例子3       var ss = from r in Am_recProScheme

                     where r.SortsText.Contains("張");

                     select r;

            string sssql = "select * from Am_recProScheme where r.SortsText like '%張%'";

           

            var ss = from r in Am_recProScheme

                     where （new int[]{24,25,26}）.Contains(r.rpId);

                     select r;

            string sssql = "select * from Am_recProScheme where r.rpId in (24,25,26)";

 

簡單查詢出某幾列應用

例子4            

             var ss = from r in Am_recProScheme

                      where r.rpId > 10

                     order by r.rpId desc

                     select new {r.rpId,r.rpName};

                      

           

           string sssql = "select rpId,rpName from Am_recProScheme where rpid>10 order by rpId desc"



關於linq的最簡單例子

簡單函數連表查詢的應用

我们在做SQL查询的时候经常会用到Inner Join,Left Join，连接方式的概念方面我想也不用给予太多解释，

我们今天的重点是让大家熟悉LINQ是如何使用Join来实现常用的表连接的。

创建测试用类：

class Customer
{
    public int CustomerId { get; set; }

    public string Name { get; set; }

    public int Age { get; set; }

}

class Product
{
    public int ProductId { get; set; }

    public string Name { get; set; }

    public string Origin { get; set; }

}

class Order
{
    public int OrderId { get; set; }

    public int CustomerId { get; set; }

    public List<Product> Products { get; set; }
}

我们用以下例子来熟悉 Join 关键字的用法。

1.Inner Join:

CreateEntities();
var query = from c in customers
            join o in orders on c.CustomerId equals o.CustomerId
            where o.OrderId == 2
            select c;
foreach (var customer in query)
{
    Console.WriteLine("Id:{0}, Name:{1}", customer.CustomerId, customer.Name);
}

　

运行结果：

　　Id:1, Name:CA 　　

　上面这个是常见的内连接的例子，和SQL语法也很相似，但有以下几点要注意：

(1).连接条件： c.CustomerId equals o.CustomerId 只能使用 equals 不能用 =,==,等于 等表示。
以为LINQ的设计者认为 几乎所有的连接条件都是 = 条件不会出现 >,<,!= 等情况因此使用了个关键字来描述表连接条件。

(2).条件顺序：c.CustomerId equals o.CustomerId ，range variable: c 和b之前的顺序不能颠倒。

 

2.Group Join:

也许大家对Group Join的概念不太了解，没关系让我们通过例子来认识它：

CreateEntities();
var query = from c in customers
            join o in orders on c.CustomerId equals o.CustomerId into os
            select new { c, os };
foreach (var item in query)
{
    Console.WriteLine("Customer Id:{0}, Name:{1}", item.c.CustomerId, item.c.Name);
    foreach (var o in item.os)
    {
        Console.WriteLine("--Order Id:{0}", o.OrderId);
    }
}


结果：

Customer Id:1, Name:CA
--Order Id:1
--Order Id:2
Customer Id:2, Name:CB
--Order Id:4
Customer Id:3, Name:CC
--Order Id:3
Customer Id:4, Name:CD
Press any key to continue . . .

以上查询返回的结果：和Group By 返回的结果非常的相似：一个KEY对象对应一个集合。

要实现Group Join我们要引入一个关键字：into

但使用时要注意一下几点：

(1).使用into 关键字后 join 后面的 range variable：o 在后面的表达式块中就失去了作用域。

(2).range variable：os 通常情况下都是IEnumerable<T>类型的。

3.Left Join:

　Left Join 我们在SQL里经常用到，让我们来看看LINQ里怎么实现它：

CreateEntities();
var query = from c in customers
            join o in orders on c.CustomerId equals o.CustomerId into os
            from o2 in os.DefaultIfEmpty(
                new Order { OrderId = 0, CustomerId = 0, Products = new List<Product>() })
            select new { c, o2 };
foreach (var item in query)
{
    Console.WriteLine("Customer Id:{0}, Name:{1}--Order Id:{0}",
        item.c.CustomerId, item.o2.OrderId);
}

结果：

Customer Id:1, Name:1--Order Id:1
Customer Id:1, Name:2--Order Id:1
Customer Id:2, Name:4--Order Id:2
Customer Id:3, Name:3--Order Id:3
Customer Id:4, Name:0--Order Id:4
Press any key to continue . . .

我们可以看到Left Outer Join 的语法进一步的复杂化了，结果也有细微的不同。

(1).从语法上：

from o2 in os.DefaultIfEmpty(
                new Order { OrderId = 0, CustomerId = 0, Products = new List<Product>() })

主要区别在于以上者1句语句。查询方法DefaultIfEmpty 用于定义当查询记录为空时，预定义默认值。再从其集合中取出子元素。

(2).从结果上: 我们在遍历查询结果时可以发现Left Join相似于Inner Join结果都是“平面”的，然而Group Join返回的结果具有层次性。

 

题外：

由于C#是面向对象的，往往会通过对象与对象间的外系来实现数据间关系。有时表达2个之间的关系也可以不使用Join关键字，

因此Join关键字其实在实际LINQ查询表达式中用的不是很多。

2015-03-25



以下是linq連表的例子   相當於左連接
            var ls = (from i in gt.vendor_login
                  join j in gt.vendor on i.vendor_id equals j.vendor_id
                  into AAA
                  from j in AAA.DefaultIfEmpty()
                  select new myclass { AA = i.vendor_id, BB = j != null ? j.vendor_name_full : null }).ToList();
 
             // 相當於內連接
             var ls = (from i in gt.vendor_login
                  fromj in gt.vendor on i.vendor_id equals j.vendor_id
                   select new myclass { AA = i.vendor_id, BB = j != null ? j.vendor_name_full : null }).ToList();
          //類似於內連接
          ls = (from i in gt.vendor_login
                  from j in gt.vendor
                  where i.vendor_id==j.vendor_id
                  select new { i, j }).ToList().ConvertAll<VendorLoginQuery>(w => new VendorLoginQuery { login_id = w.i.login_id, vendor_id = w.i.vendor_id, login_ipfrom = w.i.login_ipfrom, login_createdate = w.i.login_createdate, vendor_name_full = w.j.vendor_name_full }).Skip(10).Take(100).ToList();