C#小技巧---Linq的使用

2022/9/13 14:19:01

本文主要是介绍C#小技巧---Linq的使用,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1.基本介绍

LINQ(Language Integrated Query)即语言集成查询。

LINQ是一组语言特性和API,使得你可以使用统一的方式编写各种查询。用于保存和检索来自不同数据源的数据,从而消除了编程语言和数据库之间的不匹配,以及为不同类型的数据源提供单个查询接口。

LINQ总是使用对象,因此你可以使用相同的查询语法来查询和转换XML、对象集合、SQL数据库、ADO.NET数据集以及任何其他可用的LINQ提供程序格式的数据。

LINQ to Object 多用于映射数据库的查询,LINQ to XML 用于查询 XML 元素数据。使用 LINQ 查询的前提是对象必须是一个 IEnumerable 集合

LINQ主要包含以下三部分:

LINQ to Objects      主要负责对象的查询。

LINQ to XML           主要负责XML的查询。

LINQ to ADO.NET   主要负责数据库的查询。

  LINQ to SQL

  LINQ to DataSet

  LINQ to Entities

2.Linq的操作语法

    LINQ查询时有两种语法可供选择:查询表达式语法(Query Expression)和方法语法(Fluent Syntax)。

   2.1  查询表达式语法

from<range variable> in <IEnumerable<T> or IQueryable<T> Collection>
<Standard Query  Operators> <lambda expression>
<select or groupBy operator> <result   formation>

Linq查询表达式

约束:Linq表达式必须以from子句开头,以select或group语句结束

关键字   功能
from... in.. 指定要查询的数据源以及范围变量,多个from子句则表示从多个数据源查找数据。注意:C#编译器会把“复合from子句”的查询表达式转换为SelectMany()扩展方法。
join…in…on…equals… 指定多个数据源的关联方式
let 引入用于存储查询表达式中子表达式结果的范围变量。通常能达到层次感会更好,使代码更易于阅读。
orderby、descending 指定元素的排序字段和排序方式。当有多个排序字段时,由字段顺序确定主次关系,可指定升序和降序两种排序方式
where 指定元素的筛选条件。多个where子句则表示了并列条件,必须全部都满足才能入选。每个where子句可以使用谓词&&、||连接多个条件表达式。
group 指定元素的分组字段。
select 指定查询要返回的目标数据,可以指定任何类型,甚至是匿名类型。(目前通常被指定为匿名类型)
into

提供一个临时的标识符。该标识可以引用join、group和select子句的结果。

1)        直接出现在join子句之后的into关键字会被翻译为GroupJoin。(into之前的查询变量可以继续使用)

2)        select或group子句之后的into它会重新开始一个查询,让我们可以继续引入where, orderby和select子句,它是对分步构建查询表达式的一种简写方式。(into之前的查询变量都不可再使用)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

案例:查询一个整数数组中的偶数

 int[] ints = { 1, 2, 4, 7, 8, 10 };
 var result = from i in ints where i % 2 == 0 select i;

       取出数组中平方值大于平均值的数字: 

 int[] ints = { 1, 2, 4, 7, 8, 10 };
 var result = from i in ints
                   let squared = Math.Pow(i, 2)
                   let average = ints.Average()
                   where squared > average
                   select i;

    LINQ to XML 的示例,假如我们有如下 XML 文件:

<?xml version="1.0" encoding="utf-8" ?> 
<Employees>
  <Employee>
    <EmpId>1</EmpId>
    <Name>Hobe</Name>
    <Sex>男</Sex>
  </Employee>
 <Employee>
    <EmpId>2</EmpId>
    <Name>Lily</Name>
    <Sex>女</Sex>
  </Employee>
 <Employee>
    <EmpId>3</EmpId>
    <Name>Jack</Name>
    <Sex>男</Sex>
  </Employee>
</Employees>

使用 LINQ to XML 查询所有含有指定节点值的元素:

引用命名空间:using System.Xml.Linq;

   XElement xelement = XElement.Load("Employees.xml");
   var els = from el in xelement.Elements("Employee")
                 where el.Element("Sex").Value == "男"
                 select el;
    foreach (XElement item in els)
    {
          string id = item.Element("EmpId").Value;
          string name = item.Element("Name").Value;
          Console.WriteLine($"id:{id},姓名:{name},性别:男");
    }

 2.2  方法语法

方法语法(也称为流利语法)主要利用System.Linq.Enumerable类中定义的扩展方法和Lambda表达式方式进行查询,类似于如何调用任何类的扩展方法。

案例:

 int[] ints = { 1, 2, 4, 7, 8, 10 };
 var result = ints.Where(i => i % 2 == 0).ToArray();

查询数组中偶数的元素及其在数组中的索引

 int[] ints = { 1, 2, 4, 7, 8, 10 };
 var res = ints.Select((item, index) => new { Item = item, Index = 
               index });
  var result = res.Where(p => p.Item % 2 == 0).Select(p => p);
  foreach (var item in result)
  {
       Console.WriteLine($"item:{item.Item},index:{item.Index}");
  }

3.集合的一些Linq操作

3.1 Except取差集

LINQ 的 Except 方法用来取差集,即取出集合中与另一个集合所有元素不同的元素。

 int[] first = { 1, 2, 3, 4 };
 int[] second = { 0, 2, 3, 5 };
 var result = first.Except(second);
 // result = { 1, 4 }

注意 Except 方法会去除重复元素:

 int[] second = { 0, 2, 3, 5 };
 int[] third = { 1, 1, 1, 2, 3, 4 };
 var result = third.Except(second);
 // result = { 1, 4 }

自定义类型或复合类型取差集,此时需要自定义类型实现IEquatable<T>接口

  public class User : IEquatable<User>
    {
        public int UserID { get; set; }
        public string Name { get; set; }
        public string Sex { get; set; }

        public bool Equals([AllowNull] User other)
        {
            return Name == other.Name;
        }

        public override int GetHashCode()
        {
            return Name?.GetHashCode() ?? 0;
        }
    }
  var list1 = new List<User>
            {
               new User{UserID=1, Name = "User1",Sex="Male"},
               new User{UserID=2, Name = "User2",Sex="Female"},
            };

            var list2 = new List<User>
            {
               new User{ UserID=2, Name = "User2",Sex="Female"},
               new User{ UserID=3, Name = "User3",Sex="Female"},
            };

            var result = list1.Except(list2).ToList();
            result.ForEach(u => Console.WriteLine(u.Name));
            // 输出:User1

3.2 SelectMany集合降维

SelectMany 可以把多维集合降维,比如把二维的集合平铺成一个一维的集合。

 var collection = new int[][]
                      {
                         new int[] {1, 2, 3},
                         new int[] {4, 5, 6},
                       };
   var result = collection.SelectMany(x => x);
   // result = [1, 2, 3, 4, 5, 6] 

举个更贴合实际应用的例子。例如有如下实体类(一个部门有多个员工):

  class Department
    {
        public Employee[] Employees { get; set; }
    }

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

此时,我们拥有一个这样的数据集合:

 var departments = new[]
                             {
                                new Department()
                                {
                                    Employees = new []
                                    {
                                        new Employee { Name = "Bob" },
                                        new Employee { Name = "Jack" }
                                    }
                                },
                                new Department()
                                {
                                    Employees = new []
                                    {
                                        new Employee { Name = "Jim" },
                                        new Employee { Name = "John" }
                                    }
                                }
                             };

现在我们可以使用 SelectMany 把各部门的员工查询到一个结果集中:

var allEmployees = departments.SelectMany(x => x.Employees);
foreach (var emp in allEmployees)
{
   Console.WriteLine(emp.Name);
}
// 依次输出:Bob Jack Jim John

3.3 SelectMany笛卡尔积运算

SelectMany 不光适用于单个包含多维集合对象的降维,也适用于多个集合之前的两两相互操作,比如进行迪卡尔积运算。比如我们有这样两个集合:

var list1 = new List<string> { "a1", "a2" };
var list2 = new List<string> { "b1", "b2", "b3" };

现在我们需要把它进行两两组合

var result = list1.SelectMany(x => list2.Select(y => $"{x}{y}"));
// result = ["a1b1", "a1b2", "a1b3", "a2b1", "a2b2", "a2b3"]

如何对 N 个集合进行迪卡尔积运算呢,比如有这样的集合数据:

var arrList = new List<string[]>
{
    new string[] { "a1", "a2" },
    new string[] { "b1", "b2", "b3" },
    new string[] { "c1" },
    // ...
};

下面是一个使用 SelectMany 的实现,需要用到递归:

 static void Main(string[] args)
        {
            var arrList = new List<string[]>
            {
                new string[] { "a1", "a2" },
                new string[] { "b1", "b2", "b3" },
                new string[] { "c1" },
                // ...
            };
            var result = Recursion(arrList, 0, new List<string>());
            result.ForEach(x => Console.WriteLine(x));
        }

        static List<string> Recursion(List<string[]> list, int start, List<string> result)
        {
            if (start >= list.Count)
                return result;

            if (result.Count == 0)
                result = list[start].ToList();
            else
                result = result.SelectMany(x => list[start].Select(y => x + y)).ToList();

            result = Recursion(list, start + 1, result);

            return result;
        }

返回结果

 

 

 类似这种集合的迪卡尔积运算操作,也可以用 LINQ to Object 来代替 SelectMany 实现:

result = result.SelectMany(x => list[start].Select(y => x + y)).ToList();
// 等同使用扩展方法:
result = (from a in result from b in list[start] select a + b).ToList();

3.4 Aggregate聚合

Aggregate 扩展方法可以对一个集合依次执行类似累加器的操作,就像滚雪球一样把数据逐步聚集在一起。比如实现从 1 加到 10,用 Aggregate 扩展方法就很方便:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sum = numbers.Aggregate((prevSum, current) => prevSum + current);
// sum = 55

再来看一个字符串的例子加深理解:

string[] stringList = { "Hello", "World", "!" };
string joinedString = stringList.Aggregate((prev, current) => prev + " " + current);
// joinedString = "Hello World !"

Aggregate 还有一个重载方法,可以指定累加器的初始值。我们来看一个比较综合的复杂例子。

假如我们有如下 1-12 的一个数字集合:

现在我们想做如下计算:

  • 计算集合元素的总数个数

  • 计算值为偶数的元素个数

  • 收集每第 4 个元素

var result = items.Aggregate(new { Total = 0, Even = 0, FourthItems = new List<int>() },
    (accum, item) =>
    new
    {
        Total = accum.Total + 1,
        Even = accum.Even + (item % 2 == 0 ? 1 : 0),
        FourthItems = (accum.Total + 1) % 4 == 0 ? new List<int>(accum.FourthItems) { item } : accum.FourthItems
    }
);

// result:
// Total = 12
// Even = 6
// FourthItems = [4, 8, 12]

3.5 Join关联查询

和 SQL 查询一样,LINQ 同样支持 Inner Join、Left Join、Right Join、Cross Join 和 Full Outer Join,有时候你可能看到不同的写法,其实是同一个意思,比如 Left Outer Join 就是 Left Join,Join 是 Inner Join 省略了 Inner 等。

var first = new List<string>() { "a","b","c" }; // 左边
var second = new List<string>() { "a", "c", "d" }; // 右边

Inner Join

var result = from f in first
              join s in second on f equals s
              select new { f, s };
// 等同使用扩展方法:
var result = first.Join(second,
    f => f,
    s => s,
    (f, s) => new { f, s });

// result: {"a","a"}
//         {"c","c"}

Left Join

var result = from f in first
            join s in second on f equals s into temp
            from t in temp.DefaultIfEmpty()
            select new { First = f, Second = t };
// 或者:
var result = from f in first
            from s in second.Where(x => x == f).DefaultIfEmpty()
            select new { First = f, Second = s };

// 等同使用扩展方法:
var result = first.GroupJoin(second,
        f => f,
        s => s,
        (f, s) => new { First = f, Second = s })
    .SelectMany(temp => temp.Second.DefaultIfEmpty(),
        (f, s) => new { First = f.First, Second = s });

// result: {"a","a"}
//         {"b", null}
//         {"c","c"}

Right Join

var result = from s in second
            join f in first on s equals f into temp
            from t in temp.DefaultIfEmpty()
            select new { First = t, Second = s };
// 其它和 Left Join 类似

// result: {"a","a"}
//         {"c","c"}
//         {null,"d"}

Cross Join

var result = from f in first
            from s in second
            select new { f, s };

// result: {"a","a"}
//         {"a","c"}
//         {"a","d"}
//         {"b","a"}
//         {"b","c"}
//         {"b","d"}
//         {"c","a"}
//         {"c","c"}
//         {"c","d"}

Full Outer Join

var leftJoin = from f in first
            join s in second on f equals s into temp
            from t in temp.DefaultIfEmpty()
            select new { First = f, Second = t };
var rightJoin = from s in second
            join f in first on s equals f into temp
            from t in temp.DefaultIfEmpty()
            select new { First = t, Second = s };
var fullOuterJoin = leftJoin.Union(rightJoin);

根据多个键关联

在 SQL 中,表与表进行关联查询时 on 条件可以指定多个键的逻辑判断,用 and 或 or 连接。但 C# 的 LINQ 不支持 and 关键字,若要根据多键关联,需要把要关联的键值分别以相同的属性名放到匿名对象中,然后使用 equals 比较两个匿名对象是否相等。示例:

var stringProps = typeof(string).GetProperties();
var builderProps = typeof(StringBuilder).GetProperties();
var query =
    from s in stringProps
    join b in builderProps
    on new { s.Name, s.PropertyType } equals new { b.Name, b.PropertyType }
    select new
    {
        s.Name,
        s.PropertyType
    };

3.6 Zip拉链

Zip 扩展方法操作的对象是两个集合,它就像拉链一样,根据位置将两个系列中的每个元素依次配对在一起。其接收的参数是一个 Func 实例,该 Func 实例允许我们成对在处理两个集合中的元素。如果两个集合中的元素个数不相等,那么多出来的将会被忽略。

示例:

int[] numbers = { 3, 5, 7 };
string[] words = { "three", "five", "seven", "ignored" };
IEnumerable<string> zip = numbers.Zip(words, (n, w) => n + "=" + w);

foreach (string s in zip)
{
    Console.WriteLine(s);
}

输出:

3=three
5=five
7=seven

3.7 ToLookUp索引式查找

ToLookup 扩展方法返回的是可索引查找的数据结构,它是一个 ILookup 实例,所有元素根据指定的键进行分组并可以按键进行索引。这样说有点抽象,来看具体示例:

string[] array = { "one", "two", "three" };
// 根据元素字符串长度创建一个查找对象
var lookup = array.ToLookup(item => item.Length);

// 查找字符串长度为 3 的元素
var result = lookup[3];
// result: one,two

再来一个示例:

int[] array = { 1,2,3,4,5,6,7,8 };
// 创建一个奇偶查找(键为 0 和 1)
var lookup = array.ToLookup(item => item % 2);

// 查找偶数
var even = lookup[0];
// even: 2,4,6,8

// 查找奇数
var odd = lookup[1];
// odd: 1,3,5,7

3.8 Distinct去重

简单类型的集合调用 Distinct 方法使用的是默认的比较器,Distinct 方法用此比较器来判断元素是否与其它元素重复,但对于自定义类型要实现去重则需要自定义比较器。示例:

public class IdEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y) => x.Id == y.Id;
    public int GetHashCode(Person p) => p.Id;
}

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var people = new List<Person>();
        var distinct = people.Distinct(new IdEqualityComparer());
    }
}

3.9 字典转换

ToDictionary 扩展方法可以把集合 IEnumerable<TElement> 转换为 Dictionary<TKey, TValue> 结构的字典,它接收一个 Func<TSource, TKey> 参数用来返回每个元素指定的键与值。示例:

IEnumerable<User> users = GetUsers();
Dictionary<int, User> usersById = users.ToDictionary(x => x.Id);

上面 ToDictionary 返回的字典数据中的值是整个元素,你也可以通过它的第二个参数来自定义字典的值。示例:

Dictionary<int, string> userNamesById = users.ToDictionary(x => x.Id, x => x.Name);

你也可以为转换的字典指定其键是否区分大小写,即自定义字典的 IComparer,示例:

Dictionary<string, User> usersByCaseInsenstiveName = users.ToDictionary(x =>x.Name,
    StringComparer.InvariantCultureIgnoreCase);

var user1 =usersByCaseInsenstiveName["liam"];
var user2 =usersByCaseInsenstiveName["LIAM"];
user1 == user2; // true

注意,字典类型要求所有键不能重复,所以在使用 ToDictionary 方法时要确保作为字典的键的元素属性不能有重复值,否则会抛出异常。

3.10 其他常见方法

  Range 和 Repeat

  Range 和 Repeat 用于生成简单的数字或字符串系列。示例:

// 生成 1-100 的数字,即结果为 [1, 2, ..., 99, 100]
var range = Enumerable.Range(1, 100);

// 生成三个重复的字符串“a”,即结果为 ["a", "a", "a"]
var repeatedValues = Enumerable.Repeat("a", 3);

Any 和 All

Any 用来判断集合中是否存在任一一个元素符合条件,All 用来判断集合中是否所有元素符合条件。示例:

var numbers = new int[] {1, 2, 3, 4, 5 };
bool result = numbers.Any(); // true
bool result = numbers.Any(x => x == 6); // false
bool result = numbers.All(x => x > 0); // true
bool result = numbers.All(x => x > 1); // false

Concat 和 Union

Concat 用来拼接两个集合,不会去除重复元素,示例:

List<int> foo = newList<int> { 1, 2, 3 };
List<int> bar = newList<int> { 3, 4, 5 };
// 通过 Enumerable 类的静态方法
var result = Enumerable.Concat(foo, bar).ToList(); // 1,2,3,3,4,5
// 通过扩展方法
var result = foo.Concat(bar).ToList(); // 1,2,3,3,4,5

Union 也是用来拼接两个集合,与 Concat 不同的是,它会去除重复项,示例:

var result = foo.Union(bar); // 1,2,3,4,5

GroupBy 分组

GroupBy 扩展方法用来对集合进行分组,下面是一个根据奇偶进行分组的示例:

var list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var grouped = list.GroupBy(x => x % 2 == 0);
// grouped: [1, 3, 5, 7, 9] 和 [2, 4, 6, 8]

还可以根据指定属性进行分组:

 

public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
}

var people = new List<Person>();
var query = people
    .GroupBy(x => x.Age)
    .Select(g => { Age = g.Key, Count = g.Count() });

DefaultIfEmpty 空替换

在上面的关联查询中我们使用了 DefaultIfEmpty 扩展方法,它表示在没有查询到指定条件的元素时使用元素的默认值代替。其实 DefaultIfEmpty 还可以指定其它的默认值,示例:

var chars = new List<string>() { "a", "b", "c", "d" };
chars.Where(s => s.Length > 1).DefaultIfEmpty().First(); // 返回 null
chars.DefaultIfEmpty("N/A").FirstOrDefault(); // 返回 "a"
chars.Where(s => s.Length > 1).DefaultIfEmpty("N/A").FirstOrDefault(); // 返回 "N/A"

SequenceEqual 集合相等

SequenceEqual 扩展方法用于比较集合系列各个相同位置的元素是否相等。示例:

int[] a = new int[] {1, 2, 3};
int[] b = new int[] {1, 2, 3};
int[] c = new int[] {1, 3, 2};

bool result1 = a.SequenceEqual(b); // true
bool result2 = a.SequenceEqual(c); // false

 

参考链接:https://www.cnblogs.com/dotnet261010/p/8279256.html,https://mp.weixin.qq.com/s/echHLYV9s65oS-1u1NnEVw

var result = from f in first
            from s in second
            select new { f, s };

// result: {"a","a"}
//         {"a","c"}
//         {"a","d"}
//         {"b","a"}
//         {"b","c"}
//         {"b","d"}
//         {"c","a"}
//         {"c","c"}
//         {"c","d"}


这篇关于C#小技巧---Linq的使用的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程