Linq中join & group join & left join 的用法

Linq中join & group join & left join 的用法

2013-01-30 11:12 12154人阅读 评论(0) 收藏 举报

 分类：

C#（14） 

文章转自：http://www.cnblogs.com/c-jquery-linq-sql-net-problem/archive/2011/01/17/LINQ_Inner_Join_Group_Join_Left_Join.html

咱们在作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查询表达式中用的不是不少。

 

 

# Linq获取两个List或数组的差集交集

 

List<int> list1 = new List<int>();
list1.Add(1);
list1.Add(2);
list1.Add(3);
List<int> list2 = new List<int>();
list2.Add(3);
list2.Add(4);
list2.Add(5);
//获得的结果是4,5 即减去了相同的元素。
List<int> list3 = list2.Except(list1).ToList();
foreach (int i in list3)
{
    MessageBox.Show(i.ToString());
}

合并两个数组,并去掉重复元素,而后排序(C#)

List<int> numbers1 = new List<int>() { 5, 4, 1, 3, 9, 8, 6, 7, 12, 10 };
List<int> numbers2 = new List<int>() { 15, 14, 11, 13, 19, 18, 16, 17, 12, 10 };
var newQuerty = numbers1.Concat(
from n in numbers2
where !numbers1.Contains(n)
select n
).OrderBy(n=>n);

合并两个数组，并去除合并后的重复数据， 并排序

            int[] A={1,2,2,3,4,5,6,6,6};
            int[] B={2,2,2,3,7,8,9,5};

            List<int> list = new List<int>(A);
            list.AddRange(B);

            list.Sort();

            //去除重复项
            foreach (int i in list.Distinct<int>())
            {
                Console.WriteLine(i);
            }

C# 取两个数组的相同元素

以往咱们都是确定绞尽脑汁，确定什么循环，元素大小，什么因素都考虑进去。可是如今采用Linq能够很好的解决这个问题。找出两个或多个数组的相同项。 代码至关简单： usingSystem; usingSystem.Collections.Generic; usingSystem.Linq; usingSystem.Text;   namespaceTest4_03 {    classProgram     {        staticvoidMain(string[] args)         {            string[] names = {"Adams","Arthur","Buchanan","Tsbuchis","ShCian","FuchsiaLinda","DecheChen","Lotheer","FindLanciCade","SorchLand","JiangZheng","MisiiLoda","Gtod","Dfac","Lama","BakCades","Losangle","ZheWQ","GehengDahaLothi","ToryLandey","DakaLothy","BthLanda","MenNorth","Fith","FoxMain","DontM","Saobba","Del","Sala","Ghero","BhthLaPhda"};            IEnumerable<string> skip = names.Skip(10);            IEnumerable<string> take = names.Take(11);              //取出两个序列中交集部分，按理论应该输出JiangZheng            IEnumerable<string> intersect = skip.Intersect(take);              foreach(varsinintersect)             {                Console.WriteLine(s);             }            Console.ReadKey();         }     } }

 

C# 获取两个数组集合的差集，交集

今天在作一个树形选择节点时，遇到一个问题，属性节点是记录了相关的ID值，第一次呢所有对这些ID进行处理，可是接下来再次选择就要分状况了，原先选择的ID若是不在新选择的集合中那么剔除掉，不然，原先ID不传入函数处理，新ID传入函数处理： 好比原来①选择的ID是：1,2,3,4                下次：1,2,3,4,5，   那么这时候5要处理，1,2,3,4维持原样。               ②选择ID是：1,3                          下次： 3,4,5           那么这时候4,5 要处理，3 维持原样。1剔除。               ③选择ID是：1,2,3,4,5                  下次：3,4,5             那么这时候3,4,5都维持原样，1,2剔除。               ④选择ID是：1,2                           下次：3,4,5             那么这时候3,4,5处理，1,2剔除。   简化一下数学模型： 你们发现没其实这就是一个数学的概念，集合的差集，那么咱们怎么处理呢？ 假设前次选择的集合为A，后次选择为B 获得要处理的很简单：B-A （B与A的差集）就是要处理的集合元素，为何呢？根据概念可知哈！ 那么获得不作处理的怎么办呢？ 不要处理的必然是B的子集，那么怎么获得呢？ 出来啦既是：B-(B-A)    这是为何呢？ B-A  就是要处理的，而维持原样的就是固然就是:B-(B-A)， 那么剔除的集合呢？ A-(B-(B-A))    如何用C#表示呢，我这里就不用什么循环之类的了，我用的是NET3.5 那就好办了，用Linq处理： 俺这里特殊点，右键获得的树形集合（lstSource）包含了其余信息，先获取ID集合再说：  var m_ilAllSelect = lstSource.Select(r => r.ID).AsEnumerable();//新选择的列表 ///////下面开始处理了 List<int> m_ilNewSelect = m_ilAllSelect.ToList();//新选择列表 List<int> m_ilExcept = m_ilNewSelect.Except(m_mcuids).ToList(); //二者的不一样之处 List<int> m_iExceptAfterAndNew = m_ilNewSelect.Except(m_ilExcept).ToList();//新选择列表与差集比较，则是新选择中的旧的   为了简化给你们，这里的A表明旧集合，B表明新集合,这里的集合都是List<int>泛型列表。 那么要处理的就是 B.Except(A), 维持原样的：B( B.Except(A)), 剔除的：A.Except(B( B.Except(A))), 不要问我这个Except方法啥意思？看MSDN吧，google也行啦！ 固然我实际的源码比这更细致点，至此解决集合的差集的知识点就这些了！