一个无聊的博客

肥宅快乐每一天

0%

C# Linq

发表于 更新于 分类于
本文字数： 13k 阅读时长 ≈ 12 分钟

LINQ(Language Integrated Query) 语言集成查询，是 .net 框架的扩展，它允许我们用 SQL 查询数据库的方式来查询数据的集合

扩展方法

Select

返回指定类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class LinqTest
{
    public void SelectTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var list1 = UserList;
        var list2 = UserList.Select(x => x.UserName);
        var list3 = UserList.Select(x => new
        {
            id = x.UserId,
            name = x.UserName
        });
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Where

查询特定条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class LinqTest
{
    public void WhereTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var list1 = UserList.Where(x => x.Age >= 40);
        var list2 = UserList.Where(x => x.UserName = "李四" && x.PassWord = "lisi123");
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

OfType

查询特定数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class LinqTest
{
    public List<object> Main(string[] args)
    {
        List<object> List = new List<object>();

        List.Add(1);
        List.Add(2);
        List.Add(3);
        List.Add("4");
        List.Add("5");
        List.Add(6);

        var list = List.OfType<string>();

        return list;
    }
}

最后返回 [ “4”, “5” ]

Join

将一个集合与另一个集合通过指定键合并，返回合并后的集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class LinqTest
{
    public void JoinTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40, RoleId = "1" });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34, RoleId = "2" });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48, RoleId = "3" });

        List<RoleInfo> RoleList = new List<RoleInfo>();

        RoleList.Add(new RoleInfo { RoleId = "1", UserName = "开发人员"});
        RoleList.Add(new RoleInfo { RoleId = "2", UserName = "管理员"});
        RoleList.Add(new RoleInfo { RoleId = "3", UserName = "用户"});

        var result = UserList.Join(RoleList, x => x.RoleId , p => p.RoleId, (x,p) =>
        {
            id = x.UserId,
            name = x.UserName,
            pwd = x.PassWord,
            role = p.RoleName
        });
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
    public string RoleId;
}

public class RoleInfo
{
    public string RoleId;
    public string RoleName;
}

GroupJoin

将一个集合与另一个集合通过指定键分组

1

OrderBy

对集合排序，默认是从小到大排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LinqTest
{
    public void OrderByTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result = UserList.OrderBy(x => x.Age);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Reverse

反转集合中元素的顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class LinqTest
{
    public void ReverseTest()
    {
        List<string> List = new List<string>();

        List.Add("1");
        List.Add("2");
        List.Add("3");
        List.Add("4");
        List.Add("5");
        List.Add("6");

        var list = personList.AsEnumerable().Reverse();
    }
}

GroupBy

自身分组查询

1

Any 和 All

判断集合中是否满足某个/条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class LinqTest
{
    public void AnyOrAllTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result1 = UserList.Any(x => x.Age > 40);
        var result2 = UserList.All(x => x.Age > 40);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Any 是判断列表里是否有符合条件的元素，任意一个元素满足条件则返回true，否则返回 false

All 是判断列表里的每一个元素是否都符合条件，全部符合返回 true 有不符合的不论有几个都返回 false

Skip

跳过指定个元素查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LinqTest
{
    public void SkipTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result = UserList.Skip(1);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Take

只查询指定个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LinqTest
{
    public void TakeTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result = UserList.Skip(2);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Sum、Average、Max、Min

计算集合中指定数字类型数据的 总和、平均值、最大值、最小值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class LinqTest
{
    public void MathTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        //总和
        var sum = UserList.Sum(x => x.Age);
        //平均值
        var avg = UserList.Average(x => x.Age);
        //最大值
        var max = UserList.Max(x => x.Age);
        //最小值
        var min = UserList.Min(x => x.Age);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Concat

连接两个相同类型集合，合并为一个集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class LinqTest
{
    public void ConcatTest()
    {
        List<UserInfo> UserList_1 = new List<UserInfo>();

        UserList_1.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList_1.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });

        List<UserInfo> UserList_2 = new List<UserInfo>();
        UserList_2.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result = UserList_1.Concat(UserList_2);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Distinct

从集合中去除掉重复的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LinqTest
{
    public void DistinctTest()
    {
        List<int> List = new List<int>();

        List.Add(1);
        List.Add(1);
        List.Add(2);
        List.Add(3);
        List.Add(5);
        List.Add(5);
        List.Add(5);

        var result = List.Distinct();
    }
}

使用 Distinct 去重类中某个字段需要实现 IEqualityComparer 接口

ElementAt

得到集合中指定索引的元素，与[]作用相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class LinqTest
{
    public void ElementAtTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        //注意是下标、索引
        var result = UserList.ElementAt(2);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Count

得到集合中满足指定条件的元素个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class LinqTest
{
    public void CountTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result1 = UserList.Count(x => x.Age >= 40);
        //没有条件就是获取所有元素个数的总和
        var result2 = UserList.Count();
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

First/Single 和 Last

得到集合中第一个/最后一个元素(如果集合中包含多个元素，使用 Single 会报错)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class LinqTest
{
    public void FirstOrLastTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var value1 = UserList.First(x => x.Age >= 40);
        var value2 = UserList.Last(x => x.Age <= 40);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

Single 和 First 的区别

Single: 确定只符合条件的结果只有一个值；否则报错，如果有多个值则报 Sequence contains more than one matching element, 如果没有符合的则报 Sequence contains no matching element

SingleOrDefault: 在确定的条件下，只有一个或者 0 个值；如果一个以上的值符合条件 则报错。

First: 在确定条件下，至少有一个值；否则报 Sequence contains no matching element 错误。

FirstOrDefault: 在确定条件下，可以有 0 个包括 0 个以上的值。

ToDictionary

将集合转换为字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LinqTest
{
    public void ToDictionaryTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var result = UserList.ToDictionary(x => x.UserId);
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

ToList

将集合转换为 list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class LinqTest
{
    public void ToDictionaryTest()
    {
        List<UserInfo> UserList = new List<UserInfo>();

        UserList.Add(new UserInfo { UserId = "user001", UserName = "张三", PassWord = "zhangsan113", Age = 40 });
        UserList.Add(new UserInfo { UserId = "user002", UserName = "李四", PassWord = "lisi123", Age = 34 });
        UserList.Add(new UserInfo { UserId = "user003", UserName = "翠花", PassWord = "cuihua.12138", Age = 48 });

        var tmp = UserList.ToDictionary(x => x.UserId);
        var result = tmp.Values.ToList();
    }
}

public class UserInfo
{
    public string UserId;
    public string UserName;
    public string PassWord;
    public int Age;
}

SequenceEqual

判断两个集合是否相等

1
2
3
4
5
6
7
8
9
10
11
12
13
public class LinqTest
{
    public void SequenceEqualTest()
    {
        List<int> list1 = new List<int>() { 1, 2, 3 };
        List<int> list2 = new List<int>() { 3, 1, 2 };

        list1 = list1.OrderBy(temp => temp).ToList();
        list2 = list2.OrderBy(temp => temp).ToList();

        var result = list1.SequenceEqual(list2);
    }
}

欢迎关注我的其它发布渠道