C# Linq Join,GroupJoin使用

一，Join使用(等同于SQL语句的内连接，条件必须相等)

List<person> pp = new List<person>() {
                new person() { age=11,isread=true,name="1isi"},
                new person() { age=21,isread=true,name="2isi"},
                new person() { age=31,isread=true,name="3isi"},
                new person() { age=41,isread=true,name="4isi"},
                new person() { age=51,isread=true,name="5isi"},
};

List<int> pp2 = new List<int>() { 11, 31 };

var ppres2 = pp.Join(pp2, p => p.age, n => n, (p, n) => new { p, n }).Select(o => o.p);

得到的结果就是：pp里面的age=11和age=31的结果；

 List<person> pp3 = new List<person>() {
                new person() { age=11,name="1isi"},
                new person() { age=21,name="2isiX"},
};

var ppres3 = pp.Join(pp3, p => new { p.age, p.name }, n => new { n.age, n.name }, (p, n) => new { p, n }).Select(o => o.p);

得到的结果就是：pp里面的age=11的结果；age=21不满足因为name="2isiX"与pp里面的name不一致，必须同时满足age和name都一致才可以。

DataTable dt = new DataTable();
            dt.Columns.Add("prizename");
            dt.Columns.Add("point");
            dt.Columns.Add("number");
            dt.Columns.Add("totalpoint");
            dt.Columns.Add("prizeid");
            for (int i = 0; i < 10; i++)
            {
                DataRow dr2 = dt.NewRow();
                dr2["prizename"] = "娃娃"+i;
                dr2["point"] = 10;
                dr2["number"] = 1 + i;
                dr2["totalpoint"] = 10;
                dr2["prizeid"] = "001" + i;
                dt.Rows.Add(dr2);
            }

            DataTable dt2 = new DataTable();
            dt2.Columns.Add("prizename");
           
            DataRow dr = dt2.NewRow();
            dr["prizename"] = "娃娃2";
            dt2.Rows.Add(dr);

             dr = dt2.NewRow();
            dr["prizename"] = "娃娃4";
            dt2.Rows.Add(dr);

             dr = dt2.NewRow();
            dr["prizename"] = "娃娃7";
            dt2.Rows.Add(dr);


            var dtres = dt.AsEnumerable().Join(dt2.AsEnumerable(), 
                p => p.Field<string>("prizename"), 
                n => n.Field<string>("prizename"),
                (p, n) => new { p, n }).Select(o=>o.p).ToList();

得到的结果就是：dt里面的prizename= “娃娃2”;prizename= “娃娃4”;prizename= “娃娃7”;的整行数据。

当然也可以筛选出dt里面同时满足多列数据的结果集：可以参照ppres3 的写法；

二，GroupJoin使用(等同于SQL语句的左连接left join)

  List<person> pp = new List<person>() {
                new person() { age=11,isread=true,name="1isi"},
                new person() { age=21,isread=true,name="2isi"},
                new person() { age=31,isread=true,name="3isi"},
                new person() { age=41,isread=true,name="4isi"},
                new person() { age=51,isread=true,name="5isi"},
            };


            List<stdu> stu = new List<stdu>()
            {
                new stdu() { name = "1isi", teacher = "001" },
                new stdu() { name = "3isi", teacher = "002" }
            };

            var stures = pp.GroupJoin(stu, p => p.name, n => n.name,
                (p, t) => new { age=p.age, name=p.name, teachers=t.Select(k=>k.teacher).FirstOrDefault() });

            //Group Join的标准表达式写法：
            var stures = from a in pp
                                    join b in stu
                                    on a.name equals b.name into t
                                    select new
                                    {
                                        ID = a.name,
                                        Content = a.age,
                                        teacher = string.Join(",", t.Select(x => x.teacher.ToString()).ToArray())
                                    };

得到的结果为：

{ age=11,isread=true,name="1isi",teacher = "001"},
{ age=21,isread=true,name="2isi",teacher = null},
{ age=31,isread=true,name="3isi",teacher = "002"},
{ age=41,isread=true,name="4isi",teacher = null},
{ age=51,isread=true,name="5isi",teacher = null},

是把2个集合的数据拼接一起组成一个新的数据集。

---

C# List left join

public class Test1
{
public int ID { get; set; }
public string Name { get; set; }
}

public class Test2
{
public int ID { get; set; }
public int Age { get; set; }
}

//添加集合

List<Test1> test1 = new List<Test1>();
List<Test2> test2 = new List<Test2>();

test1.Add(new Test1() { ID = 1, Name = "zbb" });
test1.Add(new Test1() { ID = 2, Name = "czf" });

test2.Add(new Test2() { ID = 1, Age = 33 });

//左连接

var result = from l in test1
join r in test2 on l.ID equals r.ID into temp
from lr in temp.DefaultIfEmpty()
select new { l.ID, l.Name, Age = temp.Select(T => T.Age).FirstOrDefault() };

// 返回结果
ID Name Age
1   zbb    33
2   czf     0

---

C# List.Join方法

最近在研究C#泛型集合的时候发现了List.Join方法，这个方法与C#中的string.Join方法还有js中的join方法不一样，不是根据分隔符链接字符串，而是根据两个对象关联起来生成新的数据。

List.Join方法更像SQL 中的JOIN连接，该方法是根据两个泛型集合之间的关系，将这两个集合合并后获取新的集合。而SQL的JOIN 则是根据两个或多个表中的列之间的关系，从这些表中查询数据。（PS:具体可以参考微软官方MSDN的说明)

这是整理后的官方范例代码（代码在控制台应用程序中运行）：

/*宠物主人*/
class Person
{
    public string Name { get; set; }
}
/*宠物*/
class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}
static void Main(string[] args)
{
    /*宠物主人*/
    Person magnus = new Person { Name = "Hedlund, Magnus" };
    Person terry = new Person { Name = "Adams, Terry" };
    Person charlotte = new Person { Name = "Weiss, Charlotte" };

    /*宠物*/
    Pet barley = new Pet { Name = "Barley", Owner = terry };
    Pet boots = new Pet { Name = "Boots", Owner = terry };
    Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
    Pet daisy = new Pet { Name = "Daisy", Owner = magnus };

    /*宠物主人列表集合*/
    List<Person> people = new List<Person> { magnus, terry, charlotte };
    /*宠物列表集合*/
    List<Pet> pets = new List<Pet> { barley, boots, whiskers, daisy };

    /*          
     * Create a list of Person-Pet pairs where 
     * each element is an anonymous type that contains a
     * Pet's name and the name of the Person that owns the Pet.
     * 创建一个包含 "主人-宠物" 这样对应对象的列表
     * ，其中每个对象元素都是包含宠物名字和宠物主人名字的匿名类型
    */            
    var query = people.Join(pets, person => person, pet => pet.Owner
    , (person, pet) => new { OwnerName = person.Name, Pet = pet.Name });

    /*循环输出最终结果 格式：宠物主人名-宠物名*/
    foreach (var obj in query)
    {
        Console.WriteLine("{0} - {1}", obj.OwnerName, obj.Pet);
    }

    Console.ReadKey();
}

最终控制台输出的结果如下：

下面使用SQL语句JOIN连接查询，从而模拟出List.Join方法的同等效果，其中有Person和Pet这两张表，根据Pet宠物表的PID关联Person宠物主人表的ID。

Person表数据如下：

id	Name
1	Hedlund, Magnus
2	Adams, Terry
3	Weiss, Charlotte

Pet表数据如下：

id	Name	pid
1	Daisy	1
2	Barley	2
3	Boots	2
4	Whiskers	3

查询语句如下：

SELECT P.Name+' - '+PT.Name AS '宠物主人 - 宠物名称'
FROM Person AS P JOIN Pet AS PT 
ON P.Id=PT.PID

查询结果如下：

宠物主人 - 宠物名称
Hedlund, Magnus - Daisy
Adams, Terry - Barley
Adams, Terry - Boots
Weiss, Charlotte - Whiskers

最终结果和上面使用List.Join方法获取的一模一样吧。

---

C# LINQ两个List联合查询

两个LIST解构相同，但数据不一致，现在需要挑选出不同的数据。

 //新数据
 private List<HrRyxxData> hrRyxxDatas = new List<HrRyxxData>();
 //缓存的数据
 private List<HrRyxxData> hrRyxxCacheDatas;

计算新数据相比于老数据来说，那些数据有了变化，返回一个List.
List中每个元素是一个tuple，tuple中两个项，第一个是新数据，第二个是老数据。

新数据（hrRyxxDatas）被做了添加、修改，但不删除。
老数据（hrRyxxCacheDatas），也就是上次的“新数据”。
对比后，得到最新更新的数据。

 private List<(HrRyxxData, HrRyxxData)> tupleList;
        /// <summary>
        /// 差异数据
        /// </summary>
        public List<(HrRyxxData, HrRyxxData)> ChangedData
        {
            get
            {
                if (tupleList == null)
                {
                    var changedData = (from newData in hrRyxxDatas
                                       join oldData in hrRyxxCacheDatas
                                       on newData.UID equals oldData.UID into var2Grp
                                       from grp in var2Grp.DefaultIfEmpty()
                                       select new
                                       {
                                           New = newData,
                                           Old = grp
                                       })
                              .Where(a => a.Old == null
                                  || a.New.XM != a.Old.XM
                                  || a.New.XBM != a.Old.XBM
                                  || a.New.BZLBM != a.Old.BZLBM
                                  || a.New.DQZTM != a.Old.DQZTM
                                  || a.New.SZDWH != a.Old.SZDWH)
                              .ToDictionary(x => x.New, x => x.Old);

                    tupleList = new List<(HrRyxxData, HrRyxxData)>();
                    foreach (var item in changedData)
                    {
                        tupleList.Add((item.Key, item.Value));
                    }
                }
                return tupleList;
            }
        }

数据处理。

 HrRyxxObject hrRyxxObject = new HrRyxxObject();
 foreach ((var NewData, var OldData) in hrRyxxObject.ChangedData)
{
     Console.WriteLine("NewData:==>"+NewData?.ToString());
     Console.WriteLine("OldData:" + OldData?.ToString());
}

使用tuple，命名tuple.