【C#】System.Linq，万能的查询语句

最新推荐文章于 2024-05-16 15:16:32 发布
最新推荐文章于 2024-05-16 15:16:32 发布
阅读量885 收藏 6
点赞数 3
分类专栏： ASP.NET
原文链接：https://blog.csdn.net/qq_39108767/article/details/86648448
版权
本文深入讲解了Linq查询的两种语法形式：查询语法和方法语法，通过实例演示了from、select、where等查询子句的使用，以及Select、Where、Join等方法的应用，帮助读者理解和掌握Linq的基本操作。
摘要由CSDN通过智能技术生成

首先是官方文档：

https://docs.microsoft.com/zh-cn/dotnet/api/system.linq?view=netframework-4.7.2
https://docs.microsoft.com/zh-cn/dotnet/api/system.linq.enumerable?view=netframework-4.7.2

合理的使用System.Linq 类库，可以让代码更加高效简洁，对操作继承IEnumerable的数据类型（数组、List、Dictionary等）可以快速高效的做一些操作，比如在字典中根据Value值获取对应的Key，常规方法就是遍历比较，使用Linq库的"FirstOrDefault"或"Whrer"则会更加快捷。

Linq查询有两种形式的语法：查询语法和方法语法

  1. 查询语法：使用查询表达式的形式，类似SQL语句
        var value00 = from item in array1 select item;
  1. 方法语法：使用方法调用的形式
        value00 = array1.Select(item => item);

下面是示例：

一、准备工作

先准备几个测试类

    public class PlayerGroup
    {
        public Player[] players;
    }
 
    public class EnemyGroup
    {
        public Enemy[] enemies;
    }
 
    public class Player
    {
        public Player(string _name, int _level)
        {
            name = _name;
            level = _level;
            attack = level / 2 * 10;
        }
 
        public string name;
        public int level;
        public int attack;
    }
 
    public class Enemy
    {
        public Enemy(string _name, int _level)
        {
            name = _name;
            level = _level;
            attack = level / 2 * 10;
        }
 
        public string name;
        public int level;
        public int attack;
    }

在准备几个测试数组（其他实现了IEnumerable<>接口的系列也可）

int[] array1 = new int[] { 0, 1, 2, 3, 4, };
        int[] array2 = new int[] { 5, 6, 7, 8, 9, };
 
        Player[] array3 = new Player[]
        {
            new Player("p01", 1),
            new Player("p02", 2),
            new Player("p03", 3),
            new Player("p04", 4),
            new Player("p05", 5),
            new Player("p06", 6),
            new Player("p07", 7),
            new Player("p08", 8),
            new Player("p09", 9),
            new Player("p10", 10),
        };
 
        Enemy[] array4 = new Enemy[]
        {
            new Enemy("e01", 6),
            new Enemy("e02", 7),
            new Enemy("e03", 8),
            new Enemy("e04", 9),
            new Enemy("e05", 10),
            new Enemy("e06", 11),
            new Enemy("e07", 12),
            new Enemy("e08", 13),
            new Enemy("e09", 14),
            new Enemy("e10", 15),
        };
 
        PlayerGroup[] array5 = new PlayerGroup[2]
        {
           new PlayerGroup() { players =  new Player[]{ new Player("pm11", 1), new Player("pm12", 1) } },
           new PlayerGroup() { players =  new Player[]{ new Player("pm21", 2), new Player("pm22", 2) } }
        };
 
        EnemyGroup[] array6 = new EnemyGroup[2]
        {
           new EnemyGroup() { enemies =  new Enemy[]{ new Enemy("em11", 2), new Enemy("em12", 2) } },
           new EnemyGroup() { enemies =  new Enemy[]{ new Enemy("em21", 3), new Enemy("em22", 3) } }
        };
 
        int[] array7 = new int[] { 1, 2, 2, 3, 4, 5, 5, 6 };

为了方便查看结果，对序列元素的log做一下处理

    private void TestLog(IEnumerable enumerable)
    {
        if (enumerable == null)
            Debug.Log("enumerable is null");
        else
        {
            string logStr = "";
            foreach (var item in enumerable)
            {
                logStr += " - " + item;
            }
            Debug.Log(logStr);
        }
    }

二、查询语法的查询子句，以及部分对应的方法语法的运算

  1. from:指定要作为数据来源使用的数据集合
        //from:指定要作为数据来源使用的数据集合
        //指定以array1作为数据来源
        var value01 = from item in array1
                      select item;
        TestLog(value01);
        // - 0 - 1 - 2 - 3 - 4
 
        //from可以有多个，每个from子句都指定了一个额外的源数据合集
        //指定array3，array4两个源数据
        var value02 = from item1 in array3
                      from item2 in array4
                      where item1.level == item2.level
                      select item1.name;
        TestLog(value02);
        // - p06 - p07 - p08 - p09 - p10
  1. select:指定对象的哪部分被选择（可以是整个数据项，也可以是其中的一个或几个字段），并将结果序列合并为一个序列
        //指定选择name字段，返回值类型var实际为IEnumerable<string>
        var value03 = from item in array3
                      select item.name;
        TestLog(value03);
        value03 = array3.Select(item => item.name);
        TestLog(value03);
        // - p01 - p02 - p03 - p04 - p05 - p06 - p07 - p08 - p09 - p10
 
        //select:指定选择name和attack字段，返回值类型var实际为IEnumerable<t>，t是匿名类型new{ int level, int attack }
        var value04 = from item in array3
                      where item.level < 5
                      select new { item.level, item.attack };
        TestLog(value04);
        value04 = array3.Select(item => new { item.level, item.attack });
        TestLog(value04);
        // - { level = 1, attack = 0 } - { level = 2, attack = 10 } - { level = 3, attack = 10 } - { level = 4, attack = 20 }
  1. where:对序列的元素进行筛选
        //where:对array1的元素进行筛选，只取level < 3的元素
        var value05 = from item in array1
                      where item < 3
                      select item;
        TestLog(value05);
        value05 = array1.Where(item => item < 3);
        TestLog(value05);
        // - 0 - 1 - 2
  1. let:接受一个表达式的运算，并赋记录结果
        //let:记录两个元素之和
        var value06 = from item1 in array1
                      from item2 in array2
                      let sum = item1 + item2
                      where sum == 10
                      select item1 + "+" + item2 + "=10";
        TestLog(value06);
        // - 1+9=10 - 2+8=10 - 3+7=10 - 4+6=10
  1. orderby:根据一个或多个键对序列中的元素排序
        //orderby:按照level进行排序
        var value07 = from item in array3
                      where item.level <= 5
                      orderby item.level
                      select item.name;
        TestLog(value07);
        // - p01 - p02 - p03 - p04 - p05
  1. group…by…:指定选择的项如何被分组
        //group...by...:按照attack进行分组
        var value08 = from item in array3
                      group item by item.attack;
        TestLog(value08.Select(item => item.Key + ":" + item.Count()));
        // - 0:1 - 10:2 - 20:2 - 30:2 - 40:2 - 50:1
  1. join…on…:联结两个序列，作为一个新的集合
        //join...on...:以array1和array2作为一个新的集合，并取其中array1元素中和array2元素中level相等的元素
        var value09 = from item1 in array3
                      join item2 in array4 on item1.level equals item2.level
                      select item1.level;
        TestLog(value09);
        value09 = array3.Join(array4, item1 => item1.level, item2 => item2.level, (item1, item2) => item1.level);
        TestLog(value09);
        // - 6 - 7 - 8 - 9 - 10
 
        //join...on...
        var value10 = from item1 in array3
                      join item2 in array4 on item1.level equals item2.level
                      select new { item1.level, playerName = item1.name, enemyName = item2.name };
        TestLog(value10);
        value10 = array3.Join(array4, item1 => item1.level, item2 => item2.level, (item1, item2) => new { item1.level, playerName = item1.name, enemyName = item2.name });
        TestLog(value10);
        // - { level = 6, playerName = p06, enemyName = e01 } - { level = 7, playerName = p07, enemyName = e02 } - { level = 8, playerName = p08, enemyName = e03 } - { level = 9, playerName = p09, enemyName = e04 } - { level = 10, playerName = p10, enemyName = e05 }
  1. into:可以记录查询的一部分结果，以便后续继续使用
        //into:可以记录查询的一部分结果，以便后续继续使用
        var value11 = from item1 in array3
                      join item2 in array4 on item1.level equals item2.level
                      into temp
                      from item3 in temp
                      select item3.level;
        TestLog(value11);
        // - 6 - 7 - 8 - 9 - 10

三、方法语法的运算

  1. Select:指定对象的哪部分被选择（可以是整个数据项，也可以是其中的一个或几个字段），并将结果序列合并为一个序列
        //指定选择name字段，返回值类型var实际为IEnumerable<string>
        var value21 = array3.Select(item => item.name);
        TestLog(value21);        // - p01 - p02 - p03 - p04 - p05 - p06 - p07 - p08 - p09 - p10
  1. Where:对序列的元素进行筛选
        //对array1的元素进行筛选，只取level <= 5的元素
        var value22 = array1.Where(item => item < 5);
        TestLog(value22);        // - 0 - 1 - 2 - 3 - 4
  1. Join:联结两个序列，作为一个新的集合
        //以array1和array2作为一个新的集合，并取其中array1元素中和array2元素中level相等的元素
        var value23 = array3.Join(array4, item1 => item1.level, item2 => item2.level, (item1, item2) => item1.level);
        TestLog(value23);        // - 6 - 7 - 8 - 9 - 10
 
        var value24 = array3.Join(array4, item1 => item1.level, item2 => item2.level, (item1, item2) => new { item1.level, playerName = item1.name, enemyName = item2.name });
        TestLog(value24);
        // - { level = 6, playerName = p06, enemyName = e01 } - { level = 7, playerName = p07, enemyName = e02 } - { level = 8, playerName = p08, enemyName = e03 } - { level = 9, playerName = p09, enemyName = e04 } - { level = 10, playerName = p10, enemyName = e05 }
  1. SelectMany:将序列的每个元素投影到 IEnumerable 并将结果序列合并为一个序列
        //筛选array3中的players字段，将每个players值拆散成IEnumerable<Player>，并将所有的IEnumerable<Player>合并为一个序列
        var value25 = array5.SelectMany(group => group.players);
        TestLog(value25);        // - Player - Player - Player - Player
        var value26 = array5.SelectMany(group => group.players, (group, player) => player.name);
        TestLog(value26);        // - pm11 - pm12 - pm21 - pm22
  1. GroupJoin:基于键值等同性对两个序列的元素进行关联，并对结果进行分组。 使用默认的相等比较器对键进行比较

然而并没有搞懂···

        var value27 = array5.GroupJoin(array6, group01 => group01.players.Select(item => item.level), group02 => group02.enemies.Select(item => item.level), (group, groups) => group.players.Select(p => p.name));
        foreach (var item in value27)
        {
            TestLog(item);
            // - pm11 - pm12
            // - pm21 - pm22
        }
  1. Take:返回序列中的前n个对象
        var value28 = array1.Take(3);
        TestLog(value28);        // - 0 - 1 - 2
  1. Skip:跳过序列中的前n个对象
        //Skip:跳过序列中的前n个对象
        var value29 = array1.Skip(3);
        TestLog(value29);        // - 3 - 4
  1. TakeWhile:迭代序列，如果当前项计算结果返回true，就选择该项。在第一次返回false的时候，该项和其余项都被丢弃，不在判断后面的项
        //0返回true，1返回false，所以1及其后面的元素都丢弃
        var value30 = array1.TakeWhile(i => i % 2 == 0);
        TestLog(value30);        // - 0

9.SkipWhile:迭代序列，如果当前项的计算结果返回true，就跳过该项。在第一次返回false的时候，该项和其余项都被选择

        //SkipWhile:迭代序列，如果当前项的计算结果返回true，就跳过该项。在第一次返回false的时候，该项和其余项都被选择
        var value31 = array1.SkipWhile(i => i % 2 == 0);
        TestLog(value31);        // - 1 - 2 - 3 - 4
  1. Concat:连接两个序列
        var value32 = array2.Concat(array1);
        TestLog(value32);        // - 5 - 6 - 7 - 8 - 9 - 0 - 1 - 2 - 3 - 4
  1. OrderBy:根据一个或多个键对序列中的元素排序
        var value33 = value32.OrderBy(i => i);
        TestLog(value33);        // - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9
  1. Reverse:反转序列中的元素
        var value34 = array1.Reverse();
        TestLog(value34);        // - 4 - 3 - 2 - 1 - 0
  1. GroupBy:对序列中的元素分组
        var value35 = array1.GroupBy(i => i < 3);
        foreach (IGrouping<bool, int> item in value35)
        {
            Debug.Log(item.Key);
            TestLog(item);
        }
        //True
        // - 0 - 1 - 2
        //False
        // - 3 - 4
  1. Distinct:去除序列中的重复项
        var value36 = array7.Distinct();
        TestLog(value36);        // - 1 - 2 - 3 - 4 - 5 - 6
  1. Union:返回两个序列的并集
        var value37 = array2.Union(array7);
        TestLog(value37);        // - 5 - 6 - 7 - 8 - 9 - 1 - 2 - 3 - 4
  1. Intersect:返回两个序列的交集
        var value38 = array1.Intersect(array7);
        TestLog(value38);        // - 1 - 2 - 3 - 4
  1. Except:返回第一个序列中不重复的元素减去同样位于第二个序列中的元素
        var value39 = array7.Intersect(array1);
        TestLog(value39);        // - 1 - 2 - 3 - 4
  1. AsEnumerable:将序列作为IEnumerable返回
        var value40 = array1.AsEnumerable();
        Debug.Log(value40.GetType());

19.ToArray:将序列作为数组返回

        var value41 = array1.ToArray();
        Debug.Log(value41.GetType());      //System.Int32[]
  1. ToList:将序列作为List返回
        var value42 = array1.ToList();
        Debug.Log(value42.GetType());       //System.Collections.Generic.List`1[System.Int32]
  1. ToDictionaty:将序列作为Dictionary<TKey,TElement>
        var value43 = array1.ToDictionary(i => i);
        Debug.Log(value43.GetType());   //System.Collections.Generic.Dictionary`2[System.Int32,System.Int32]
  1. ToLookup:将序列作为LookUp<TKey,TElement>
        var value44 = array1.ToLookup(i => i);
        Debug.Log(value44.GetType());       //System.Linq.Lookup`2[System.Int32,System.Int32]
  1. OfType:所返回的序列中元素是指定类型的元素
        var value45 = array1.OfType<int>();
        TestLog(value45);        // - 0 - 1 - 2 - 3 - 4
  1. Cast:将序列中所有的元素强制转换为给定的类型
        var value46 = array1.Cast<string>();
        Debug.Log(value46.GetType());   //System.Linq.Enumerable+<CastIterator>d__34`1[System.String]
  1. SequenceEqual:返回一个布尔值，指定两个序列是否相等
        var value47 = array1.SequenceEqual(array2);
        Debug.Log(value47);         //False

26.1 First:返回序列中第一个匹配的元素。如果没有元素匹配，抛出异常。如果没有给出条件，返回序列的第一个元素

26.2 FirstOrDefault：返回序列中第一个匹配的元素。如果没有元素匹配，返回该类型的默认值。如果没有给出条件，返回序列的第一个元素

        var value48 = array1.First();
        Debug.Log(value48);         //0
        value48 = array1.First(i => i > 2);
        Debug.Log(value48);         //3
        value48 = array1.FirstOrDefault(i => i > 10);
        Debug.Log(value48);         //0

27.1 Last:返回序列中最后一个匹配的元素。如果没有元素匹配，抛出异常。如果没有给出条件，返回序列的最后一个元素
27.2LastOrDefault:返回序列中最后一个匹配的元素。如果没有元素匹配，就返回默认值。如果没有给出条件，返回序列的最后一个元素

        //同上

28.1 Single:返回序列中匹配的单个元素。如果没有元素匹配，或多于一个元素匹配，抛出异常

28.2 SingleOrDefault:返回序列中匹配的单个元素。如果没有元素匹配，返回默认值。如果多于一个元素匹配，抛出异常

        var value49 = array7.Single(i => i == 1);
        Debug.Log(value49);             //1
        //value49 = array7.Single(i => i == 2);
        //Debug.Log(value49);           //报错(InvalidOperationException: Sequence contains more than one matching element)
 
        value49 = array7.SingleOrDefault(i => i == 10);
        Debug.Log(value49);             //0
        //value49 = array7.SingleOrDefault(i => i == 2);
        //Debug.Log(value49);           //报错(InvalidOperationException: Sequence contains more than one matching element)

29.1 ElementAt:返回序列中指定索引处的元素；如果索引超出范围，抛出异常

29.2 ElementAtOrDefault:返回序列中指定索引处的元素；如果索引超出范围，返回默认值

        var value50 = array1.ElementAt(1);
        Debug.Log(value50);             //1
 
        var value51 = array1.ElementAtOrDefault(10);
        Debug.Log(value51);             //0
  1. DefaultIfEmpty:返回指定序列中的元素；如果序列为空，则返回集合中类型参数的默认值
        List<int> array8 = new List<int>();
        var value52 = array8.DefaultIfEmpty();
        TestLog(value52);               // - 0
  1. Range:生成指定范围内的整数的序列。给定一个start整型和count整型，返回序列包含count个整型，其中第一个元素的值为start，之后每个后续元素都比前一个大1
        var value53 = Enumerable.Range(10, 3);
        TestLog(value53);               // - 10 - 11 - 12
  1. Repeat:生成包含一个重复值的序列
        var value54 = Enumerable.Repeat(10, 3);
        TestLog(value54);               // - 10 - 10 - 10
  1. Empty:返回给定类型T的空序列
        var value55 = Enumerable.Empty<int>();
        Debug.Log(value55.Count());     //0
  1. Contains:序列中是否包含给定的元素
        var value56 = array1.Contains(1);
        Debug.Log(value56);     //True

35.1 Count:返回序列中元素的个数(int)。重载可以添加筛选条件，返回满足条件的元素个数

35.2 LongCount:返回序列中元素的个数(long)。重载可以添加筛选条件，返回满足条件的元素个数

        var value57 = array1.Count();
        Debug.Log(value57);     //5
 
        var value58 = array1.LongCount(i => i < 3);
        Debug.Log(value58);     //3
  1. Sum:返回序列中值的总和
        var value59 = array1.Sum();
        Debug.Log(value59);     //10

37.1 Min:返回序列中最小的值

37.2 Max:返回序列中最大的值

        var value60 = array1.Min();
        Debug.Log(value60);     //0
 
        var value61 = array1.Max();
        Debug.Log(value61);     //4
  1. Average:返回序列中的平均值
        var value62 = array1.Average();
        Debug.Log(value62);     //2
  1. Any:序列中是否存在满足条件的元素
        var value63 = array1.Any(i => i > 0);
        Debug.Log(value63);     //True
  1. All:序列中是否全部元素都满足条件
        var value64 = array1.All(i => i > 0);
        Debug.Log(value64);     //False
  1. Append:将一个值追加到序列末尾
        var value65 = array1.Append(10);
        TestLog(value65);     // - 0 - 1 - 2 - 3 - 4 - 10
  1. Aggregate:连续对序列中的各个元素应用给定的函数
        //Aggregate 01
        //对序列应用累加器函数  将指定的种子值用作累加器初始值  并使用指定的函数选择结果值
        //public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector);
 
        //Aggregate 02
        //对序列应用累加器函数  将指定的种子值用作累加器初始值
        //public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
 
        //Aggregate 03
        //对序列应用累加器函数
        //public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func);
 
        //TSource : source的元素类型
        //TAccumulate : 累加器值的类型
        //TResult : 结果值的类型
 
        //source  IEnumerable<TSource> : 要应用累加器的序列IEnumerable<T>
        //seed  TAccumulate : 累加器的初始值
        //func  Func<TAccumulate, TSource, TAccumulate> : 要对每个元素调用的累加器函数
        //resultSelector  Func<TAccumulate, TResult> : 将累加器的最终值转换为结果值的函数
 
        string[] fruits = { "apple", "mango", "orange", "passionfruit", "grape" };
 
        //Aggregate 01 Demo 查找长度最长的字符串
        string longestName =
            fruits.Aggregate("banana", (longest, next) => next.Length > longest.Length ? next : longest, fruit => fruit.ToUpper());
        Debug.Log("longestName : " + longestName);
 
        //Aggregate 02 Demo 查找名字以"e"结尾的的数量
        int count = fruits.Aggregate(0, (total, next) => next.EndsWith("e") ? total + 1 : total);
        Debug.Log("count : " + count);
 
        //Aggregate 03 Demo 颠倒字符串顺序
        string sentence = "the quick brown fox jumps over the lazy dog";
        // Split the string into individual words.
        string[] words = sentence.Split(' ');
        // Prepend each word to the beginning of the new sentence to reverse the word order.
        string reversed = words.Aggregate((workingSentence, next) => next + " " + workingSentence);
        Debug.Log("reversed : " + reversed);
 
        //累加字典Dictionary的Value
        Dictionary<string, int> numDic = new Dictionary<string, int>();
        int totalNum = numDic.Aggregate(0, (total, next) => total += next.Value);
忆水思寒
关注
专栏目录
System.Linq.dll 让.net2.0也可以使用Linq
08-27
LINQ是一种编程模型，它将查询表达式直接集成到C#和Visual Basic等.NET语言中，使得查询数据就像操作对象一样自然。LINQ的查询语法简洁且直观，减少了代码量，提高了可读性。它支持多种查询模式，如查询表达式...
C# System.Linq提供类似SQL语法的高效查询操作
最新发布
book_dw5189的博客
09-08 1117
System.Linq 命名空间通过扩展方法和查询语法为 C# 提供了强大的数据查询和操作能力，使得对数据的处理变得更加直观和灵活。
C#——Linq详解
weixin_45756851的博客
08-04 1万+
Action、Func详解并与lambda表达式结合使用、揭秘linq方法的背后、linq常用的扩展方法
C#中LINQ的使用
シ❤゛甜虾的个人博客
04-14 1577
一、LINQ简介 LINQ(读音link)代表语言集成查询（Language Integrated Query），是.NEt框架的扩展，它允许我们用SQL查询数据库的方式来查询数据的集合，你可以从数据库、程序对象的集合中查询数据 下面一个简单的示例，可以查询数组中小于10的数字并输出。 using System; using System.Collections.Generic; using System.Linq; namespace LINK查询 { class Program { st
C# 中的 LinQ :从基础到最佳实践
SS33SSS的博客
03-20 979
标准查询运算符构成了您将使用 LinQ 执行的许多操作的基础。这些运算符可应用于实现接口的集合，并分为多个类别，例如：IEnumerable<T>过滤 （，WhereOfType)投影 （，SelectSelectMany)分区 （，SkipTake)订购 （， ，OrderByThenByReverse)分组 （，GroupByToLookup)设置操作（前面提到）转换 （， ， ，ToArrayToDictionaryOfTypeCast)
推荐一个强大的动态 LINQ 库：System.Linq.Dynamic.Core
gitblog_00044的博客
03-26 904
推荐一个强大的动态 LINQ 库：System.Linq.Dynamic.Core 项目地址:https://gitcode.com/gh_mirrors/sys/System.Linq.Dynamic.Core 本文将向您介绍一个非常实用的开源项目——，这是一个允许您在运行时构建和执行 LINQ 查询的库。对于那些经常处理复杂数据查询或需要动态生成查询条件的开发者来说，这绝对是一个值得收藏的工具...
c#进阶高级语法之LINQ
xll的博客
08-17 1646
LINQ是.NET Core中提供的简化数据查询的技术。使用该技术可以用几行代码就实现复杂的数据查询。
System.Data.Linq.dll.rar
08-29
在C#或VB.NET中，通过扩展方法，LINQ将查询语句无缝集成到语言中。`System.Data.Linq`命名空间提供了实现LINQ to SQL的核心类，如`DataContext`、`Table<T>`、`EntitySet<T>`等，它们使得与数据库的交互变得简单而...
System.Linq.dll.rar
11-27
System.Linq.dll是.NET框架中一个至关重要的组件，它是C#语言 LINQ（Language Integrated Query，语言集成查询）功能的基础。在C#编程中，LINQ提供了一种优雅且高效的方式来处理数据，无论这些数据源是数组、集合、...
System.Data.SQLite 1.0.112.rar
08-13
System.Data.SQLite.Linq.dll则提供了Language Integrated Query (LINQ)的支持，允许开发人员使用C#或VB.NET的查询表达式语法来编写数据库查询，提高了代码的可读性和可维护性。这使得开发过程更加直观，减少了对SQL...
C#使用linq语句查询数组中以特定字符开头元素的方法
09-03
本篇文章将详细讲解如何使用LINQ语句来查询数组中以特定字符开头的元素。 首先，我们需要了解LINQ的基本概念。LINQ是.NET Framework的一部分，它引入了一种新的查询语法，允许开发者使用类似SQL的表达式在内存中的...
C#中的LINQ
热门推荐
L的博客
10-09 2万+
一：什么是LINQ 二：用法 ——where：查询特定条件 using System; using System.Collections.Generic; using System.Linq; class MainClass { static List<Person> personList = new List<Person>() { new Person(){ Id=1,Name="小明",Age=20,Score=100},
C# using System.Linq
you_are_my_sql的博客
02-22 284
Queryable 类包含语言集成查询 (LINQ) 标准查询运算符，这些运算符对实现 IQueryable) 的对象进行操作。System.Linq 命名空间提供支持使用语言集成查询 (LINQ) 进行查询的类和接口。，这些运算符对实现 IEnumerable) 的对象进行操作。Enumerable 类包含语言集成查询 (LINQ) 标准查询。
C#之Linq讲解
Major_S的博客
05-16 1427
C#之Linq讲解
简单示例中的C# Linq表达式
寒冰屋的专栏
11-10 228
本文通过提供简单的示例来解释Linq表达式编程，以便在需要时轻松地将上下文从C#切换到表达式编程。
System.Linq的使用
ArcherSYM的博客
01-17 300
var sourceIds = bMS_Base_PurbillvouchsList?.Select(t => t.F_ChildOrderId)?.ToList() ?? new List<string>(); var children = db.FindList<BMS_Base_PurbillvouchsEntity>(t => sourceIds.Contains(t.F_ChildOrderId)); ...
C# System.Linq
weixin_30888707的博客
11-03 640
之前一直不知道怎么将vs2008 开发的web 发布到net framework2.0 的iis中运行。今天终于知道 项目--右键--属性 可以实现framework 版本的转变。但是新的问题出现了。 在编译的过程中，use System.Linq 的应用报错。命名空间“System”中不存在类型或命名空间名称“Linq”(是否缺少程序集引用?)如果是3.5版本的framework 添加Syst...
using System.Linq;
06-05
这段代码是C#中的using语句，表示引入命名空间。具体来说，这里引入了System.Linq命名空间，该命名空间中包含了一些与LINQ相关的类和扩展方法。使用LINQ可以方便地对集合进行查询和操作，如筛选、排序、分组等。使用using语句可以使得在代码中直接使用LINQ相关的类和方法，而不需要在每个使用处都加上完整的命名空间前缀。这样可以提高代码的可读性和简洁性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值