Linq

最新推荐文章于 2025-12-03 21:54:37 发布

原创最新推荐文章于 2025-12-03 21:54:37 发布 · 202 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#linq #c# #数据库 #sql

Linq

所有常用用法汇总介绍整理，来自于 LINQ之路系列博客导航 - Life a Poem - 博客园 (cnblogs.com)

通用示例为

string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };

Where：返回符合给定条件的elements子集(Where支持第二个可选参数为index位置)
```
var query = names.Where((n, i) => i % 2 == 0);
```

Take & Skip：返回开始的N个元素，忽略剩下的元素；忽略开始的N个元素，返回之后的元素

// 假设用户在一个图书数据库中查找包含"mercury"的所有图书
    // 如果查找结果包含100条记录，下面的查询会返回前面20条
    IQueryable<Book> query = dataContext.Books
        .Where(b => b.Title.Contains("mercury"))
        .OrderBy(b => b.Title)
        .Take(20);

    // 下面的查询则返回第21到40行数据(第2页)
    IQueryable<Book> query = dataContext.Books
        .Where(b => b.Title.Contains("mercury"))
        .OrderBy(b => b.Title)
        .Skip(20).Take(20);
    }

TakeWhile & SkipWhile：遍历输入，返回每一个元素，直到遇到一个不符合的，忽略剩下的；遍历输入，忽略每一个元素，直到遇到一个不符合的，返回剩下的
```
int[] numbers = { 3, 5, 2, 234, 4, 1 };
    var takeWhileSmall = numbers.TakeWhile(n => n < 100); // { 3, 5, 2 }
    var skipWhileSmall = numbers.SkipWhile(n => n < 100); // { 234, 4, 1 }
```

Distinct：去除重复

char[] distinctLetters = "HelloWorld".Distinct().ToArray();
    string s = new string(distinctLetters); // HeloWrd

Select：转换每一个元素，个数一样

string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
    IEnumerable<string> query = names
        .Select((s, i) => i + "=" + s); // { "0=Tom", "1=Dick", ... }

SelectMany：转换元素，个数不一样，多层Select

string[] fullNames = { "Anne Williams", "John Fred Smith", "Sue Green" };
    IEnumerable<string> query = fullNames.SelectMany(name => name.Split());
    foreach (string name in query)
        Console.Write(name + "|"); // Anne|Williams|John|Fred|Smith|Sue|Green|

OrderBy & OrderByDescending：升序排列；降序排列

ThenBy & ThenByDescending：前一次排序相同键值元素重新升序排列；降序排列

string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
   
   //按姓名长度进行排序
   IEnumerable<string> query = names.OrderBy(s => s.Length);
   // Result: { "Jay", "Tom", "Mary", "Dick", "Harry" };
   
 //Jay和Tom、Mary和Dick，除非我们添加额外的ThenBy运算符
   IEnumerable<string> query = names.OrderBy(s => s.Length).ThenBy(s => s);
   // Result: { "Jay", "Tom", "Dick", "Mary", "Harry" };

GroupBy：读取每一个元素，放入一个临时列表中，key相同的元素会被放入同一个子列表中

string[] files = Directory.GetFiles("c:\\temp");
    IEnumerable<IGrouping<string, string>> query =
        files.GroupBy(file => Path.GetExtension(file));

    foreach (IGrouping<string, string> grouping in query)
    {
        Console.WriteLine("Extension: " + grouping.Key);
        foreach (string filename in grouping)
            Console.WriteLine(" - " + filename);
    }
    
    // Result:
    Extension: .pdf
     - chapter03.pdf
     - chapter04.pdf
    Extension: .doc
     - todo.doc
     - menu.doc
     - Copy of menu.doc
    ...

First & FirstOrDefault：第一个元素

Last & LastOrDefault：最后一个元素

int[] numbers = { 1, 2, 3, 4, 5 };

    int firstEven = numbers.First(n => n % 2 == 0);     // 2
    int lastEven = numbers.Last(n => n % 2 == 0);       // 4
    
    int firstBigError = numbers.First(n => n > 10); // Exception
    int firstBigNumber = numbers.FirstOrDefault(n => n > 10); // 0

ElementAt & ElementOrDefault：特定位置元素

int[] numbers = { 1, 2, 3, 4, 5 };
    int third = numbers.ElementAt(2);       // 3
    
    int tenthError = numbers.ElementAt(9);  // Exception
    int tenth = numbers.ElementAtOrDefault(9);  // 0

Count & LongCount：返回元素个数；返回元素个数(64-bit整数)
Min & Max：返回最小元素；返回最大元素
Sum & Average：求和；求平均数
Contains：包含
Any：任意元素满足条件返回true
All：所有元素满足条件返回true
SequenceEqual：比较两个sequence，若他们拥有相同元素、相同顺序，返回true

Concat & Union：两个sequence所有元素；两个sequence所有元素，去重

int[] seq1 = { 1, 2, 3 }, seq2 = { 3, 4, 5 };
    IEnumerable<int> concat = seq1.Concat(seq2); // { 1, 2, 3, 3, 4, 5 }
    IEnumerable<int> union = seq1.Union(seq2); // { 1, 2, 3, 4, 5 }

Intersect & Except：两个sequence都存在元素；第一个sequence有，第二个sequence没有的所有元素

int[] seq1 = { 1, 2, 3 }, seq2 = { 3, 4, 5 };
    IEnumerable<int>
    commonality = seq1.Intersect(seq2), // { 3 }
    difference1 = seq1.Except(seq2), // { 1, 2 }
    difference2 = seq2.Except(seq1); // { 4, 5 }

Zip：同步遍历两个sequence，返回的sequence基于在每一个元素对上应用lambda表达式

int[] numbers = { 3, 5, 7 };
    string[] words = { "three", "five", "seven", "ignored" };
    IEnumerable<string> zip = numbers.Zip (words, (n, w) => n + "=" + w);
 
    // 产生的sequence包含如下元素
    // 3=three
    // 5=five
    // 7=seven

OfType & Cast：接收一个非泛型集合，返回一个泛型集合，前者遇到不能转换的会忽略，后者会抛异常

DateTime offender = DateTime.Now;
    ArrayList classicList = new ArrayList(); // in System.Collections
    classicList.Add(offender);
    IEnumerable<int>
    sequence2 = classicList.OfType<int>(), // OK - ignores offending DateTime
    sequence3 = classicList.Cast<int>(); // Throws exception

ToArray & ToList & ToDictionary：

Repeat & Range：只能操作int整数，前者重复某个数值，后者是索引和元素个数

foreach (int i in Enumerable.Repeat(5, 3))
        Console.Write(i + ""); // 5 5 5
    foreach (int i in Enumerable.Range(5, 5))
        Console.Write(i + ""); // 5 6 7 8 9

隐式类型变量 var

自动属性

简化定义字段和属性

注意：定义自动属性时，必须同时提供get和set关键字，所以不能定义只读或者只写的自动属性

class Person
    {
        private string firstName = string.Empty;
        public string FirstName
        {
            get { return firstName; }
            set { firstName = value; }
        }
    }
//-------------------------------------------------------
    class Person
    {
        public string FirstName { get; set; }
    }

匿名类型

相当于临时的自定义类，来封装一些数据

var data = new { Name = "Hello", Age = 1 };
    Debug.LogFormat("{0},{1}", data.Name,data.Age);

匿名类型的相等语义，Equals重写时基于值，==重写时基于引用

static void AnonymousTypeEqualityTest()
    {
        // 构建两个匿名类型，拥有相同的名称/值对
        var worker1 = new { FirstName = "Harry", SecondName = "Folwer", Level = 2 };
        var worker2 = new { FirstName = "Harry", SecondName = "Folwer", Level = 2 };

        // Equals测试
        if (worker1.Equals(worker2))
            Console.WriteLine("worker1 equals worker2");
        else
            Console.WriteLine("worker1 not equals worker2");

        // ==测试
        if (worker1 == worker2)
            Console.WriteLine("worker1 == worker2");
        else
            Console.WriteLine("worker1 != worker2");

        // Type Name测试
        if (worker1.GetType().Name == worker2.GetType().Name)
            Console.WriteLine("we are both the same type");
        else
            Console.WriteLine("we are different types");
    }

拓展方法

Lambda表达式

对象初始化器

public class Point
    {
        public int X { get; set; }
        public int Y { get; set; }
    }
 
    static void ObjectInitSyntax()
    {
        // 手动初始化各属性
        Point aPoint = new Point();
        aPoint.X = 10;
        aPoint.Y = 20;
 
        // 使用新的对象初始化语法进行初始化
        Point bPoint = new Point { X = 10, Y = 20 };
    }

查询运算符

string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
        
    var list = names
        .Where(n => n.Contains("a"))
        .OrderBy(n => n.Length)
        .Select(n => n.ToUpper());

    foreach (string name in list) Debug.Log(name);

子查询

string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
    // 获取所有长度最短的名字(注意：可能有多个)
    IEnumerable<string> outQuery = names
        .Where(n => n.Length == names     

            .OrderBy(n2 => n2.Length)
            .Select(n2 => n2.Length).First());      // Tom, Jay"