重学c#系列——linq(3) [二十九]

前言

继续介绍一些复杂的linq。

正文

groupjoin 这个函数:

有department

public class Deployment
{
    public string Id { get; set; }

    public Deployment(string id)
    {
        Id = id;
    }
}

有Employee:

public class Employee
{
    public string DepartmentId { get; set; }

    public string Name { get; set; }

    public Employee(string name, string deploymentId)
    {
        Name = name;
        DepartmentId = deploymentId;
    }
}

现在要实现Deployment和Employee,一对多的关系:

List a = new List()
{
    new Deployment("1"),
    new Deployment("2"),
};

List e = new List()
{
    new Employee("张三","1"),
    new Employee("李四","1"),
    new Employee("王五","2"),
};

如果我们使用join的话,那么就是:

Deployment("1") Employee("张三","1")
Deployment("1") Employee("李四","1")
Deployment("2") Employee("王五","2")

就是这种平铺的关系。然后再使用group by。

Deployment("1")
   Employee("张三","1")
   Employee("李四","1")
Deployment("2")
   Employee("王五","2")

现在有一个函数可以直接到达这种效果,那么就是groupjoin:

static void Main(string[] args)
{
    List a = new List()
    {
        new Deployment("1"),
        new Deployment("2"),
    };

    List e = new List()
    {
        new Employee("张三","1"),
        new Employee("李四","1"),
        new Employee("王五","2"),
    };

    var  c = a.GroupJoin(e, deployment => deployment.Id,
        employee => employee.DepartmentId,
        (department, exployees) =>(department.Id, exployees)
       );

    Console.ReadKey();
}

重学c#系列——linq(3) [二十九]插图

其实可以看到这个exployees,最终运行时是一个Igroup类型,这和join还有group by不同之处。

然后这里写一下join和group by的。

static void Main(string[] args)
{
    List a = new List()
    {
        new Deployment("1"),
        new Deployment("2"),
        new Deployment("3")
    };

    List e = new List()
    {
        new Employee("张三","1"),
        new Employee("李四","1"),
        new Employee("王五","2"),
    };

    var f = from a1 in a
        join e1 in e on a1.Id equals e1.DepartmentId into temps
        from tt in temps.DefaultIfEmpty()
        select (a1.Id, (a1.Id, tt));
    var d = from f1 in f
        group f1 by f1.Id; 

    Console.ReadKey();
}

重学c#系列——linq(3) [二十九]插图1

这里要说明的就是groupjoin 是一个左连接。

上面用的是linq的查询表达式,因为join 方法其实是inner join。

对于表达式来说其实最终还是生成方法而已,IL 来说没有表达式这回事,可以理解为c#的语法糖。

看下如果上述的linq用方法来怎么写吧。

其实还是用的是groupjoin:

重学c#系列——linq(3) [二十九]插图2

这里可以看出,其实上述这个linq表达式就是groupjoin 然后用selectmany拆开,然后在用group再聚合。。

如果你只需要获取每个部门下的员工,用groupjoin 效率是更高的。

当然这里主要是说明linq 的表达式最终都是方法,语法糖而已。表达式是为了让我们更加清晰的去描述。

如果写一些复杂的linq,那么最好去用linq表达式。通过如果是groupjoin 就能实现的,就没必要去使用,这可能效率更低。

这里提到了selectmany,那么就讲述一下selectmany。 group by 是聚合,那么selectmany就是拆分。

public class BasketballTeam
{
    public string Name { get; set; }

    public string[] TeamMember;
}

static void Main(string[] args)
{
    List list = new List();
    BasketballTeam basketballTeam = new BasketballTeam();
    basketballTeam.Name = "无敌球队";
    basketballTeam.TeamMember = new string[] { "张三", "李四", "王五" };
    BasketballTeam basketballTeam1 = new BasketballTeam();
    basketballTeam1.Name = "小新球团";
    basketballTeam1.TeamMember = new string[] { "张嘛子", "李老帽", "王七三" };
    list.Add(basketballTeam);
    list.Add(basketballTeam1);
    var a = list.SelectMany(u=> u.TeamMember, (u,s)=> u.Name + " " + s);

    foreach (var item in a)
    {
        Console.WriteLine(item);
    }
    Console.ReadKey();
}

selectMany 就是用来处理集合的集合的,是一个展开过程。

上面代码是遍历一组球队的全部成员。

重学c#系列——linq(3) [二十九]插图3

有兴趣可以去看下代码,其实都能猜到,就是两个foreach 循环的封装。

下面介绍一下c# 匿名类型对linq使用:

重学c#系列——linq(3) [二十九]插图4

如果临时使用,那么可以使用匿名类型。

匿名类型其实不是说真的匿名,其实是编译的时候会生成一个类。

如果两者完全一样,那么将会生成一个类,如果只要有一点结构不同,那么会生成两个类。

重学c#系列——linq(3) [二十九]插图5

因为上面一致,所以赋值。

重学c#系列——linq(3) [二十九]插图6

顺序不一致,依然生成不同的类。

不过现在元组替代了匿名类型,因为元组在方法外部也可以使用。

然后值得注意的是匿名类型是引用类型,而元组是值类型,如果经常拷贝且内存超过128位就用匿名,否则就是元组。

其实不用纠结元组和匿名,就是元组的功能比匿名强,但是因为元组是值类型,如果经常赋值拷贝的话那么肯定是引用类型更好,所以匿名类型这时候才是用武之地。

下一节查询表达式,也是linq的终章。后面一张就是异步(并行和并发),这个考虑在汇编系列之后,因为介绍task实现原理,需要用到il,用到il就需要一些汇编知识。

文章来源于互联网:重学c#系列——linq(3) [二十九]

THE END
分享
二维码