C# Linq源码分析之Take（四）

最新推荐文章于 2024-01-10 20:18:53 发布
最新推荐文章于 2024-01-10 20:18:53 发布
阅读量1k 收藏
点赞数
分类专栏： .Net C#基础 .Net Core 文章标签： c# linq 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43263355/article/details/132535598
版权
.Net Core 同时被 3 个专栏收录
35 篇文章 3 订阅
订阅专栏
C#基础
27 篇文章 1 订阅
订阅专栏
.Net
23 篇文章 1 订阅
订阅专栏

概要

本文主要对Take的优化方法进行源码分析，分析Take在配合Select，Where等常用的Linq扩展方法使用时候，如何实现优化处理。

本文涉及到Select, Where和Take和三个方法的源码分析，其中Select, Where, Take更详尽的源码分析，请参考我之前写的文章。

源码分析

我们之前对Take的源码分析，主要是真对数据序列对象直接调用的Take方法的情况。本文介绍的Take优化方法，主要是针对多个Linq方法配合使用的情况，例如xx.Where.Select.Take或者xx.Select.Take的情况。

Take的优化方法，是定义在Take.SpeedOpt.cs文件中，体现在下面的TakeIterator方法中，Take方法对TakeIterator方法的具体调用方式，请参考C# Linq源码分析之Take方法

private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
 {
     Debug.Assert(source != null);
     Debug.Assert(count > 0);

     return
         source is IPartition<TSource> partition ? partition.Take(count) :
         source is IList<TSource> sourceList ? new ListPartition<TSource>(sourceList, 0, count - 1) :
         new EnumerablePartition<TSource>(source, 0, count - 1);
 }

该优化方法的基本逻辑如下：

  1. 如果source序列实现了IPartition接口，则调用IPartition中的Take方法；
  2. 如果source序列实现了IList接口，则返回ListPartition对象；
  3. 返回EnumerablePartition对象。

案例分析

Select.Take

该场景模拟我们显示中将EF中与数据库关联的对象，转换成Web前端需要的对象，并分页的情况。

将Student对象中的学生姓名和考试成绩取出后，并分页，Student类的定义和初始化请见附录。

 studentList.Select(x => new {
                x.Name, x.MathResult
            }).take(3).ToList();

在这里插入图片描述

执行流程如上图所示：

  1. 进入Select方法后返回一个SelectListIterator对象，该对象存储了source序列数据和selector；
  2. 进入Take方法后， 因为SelectListIterator实现了IPartition接口，因此可以调用自己的Take方法，使用source，selector和count（Take方法的参数）实例化SelectListPartitionIterator对象；
  public IPartition<TResult> Take(int count)
{
    Debug.Assert(count > 0);
    int maxIndex = _minIndexInclusive + count - 1;
    return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new SelectListPartitionIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, maxIndex);
}
  1. 进入ToList方法后，根据下面的代码，因为SelectListPartitionIterator对象实现了IPartition接口，而IPartition又继承了IIListProvider接口，所以listProvider.ToList()被执行。
   public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
        {
if (source == null)
 {
     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
 }

 return source is IIListProvider<TSource> listProvider ? listProvider.ToList() : new List<TSource>(source);
}

listProvider.ToList() 被执行，即SelectListPartitionIterator对象内定义的ToList()方法被执行，该ToList方法可以将
Selecxt的投影操作，Take的取值操作同时执行，代码如下：

 public List<TResult> ToList()
{
    int count = Count;
    if (count == 0)
    {
        return new List<TResult>();
    }

    List<TResult> list = new List<TResult>(count);
    int end = _minIndexInclusive + count;
    for (int i = _minIndexInclusive; i != end; ++i)
    {
        list.Add(_selector(_source[i]));
    }

    return list;
}
  1. 如果Take的取值为0，直接返回空List，不会进行Select操作；
  2. 按照Take中指定的Count，取到相应的元素，再进行投影操作；
  3. 返回操作结果。

这样，源List序列source，Linq只遍历和一次，就同时完成了投影和过滤两个操作，实现了优化。

附录

Student类

public class Student {
    public string Id { get; set; }
    public string Name { get; set; }
    public string Classroom { get; set; }
    public int MathResult { get; set; }
}

IIListProvider接口

internal interface IIListProvider<TElement> : IEnumerable<TElement>
{
    TElement[] ToArray();
    List<TElement> ToList();
    int GetCount(bool onlyIfCheap);
}

IPartition接口

internal interface IPartition<TElement> : IIListProvider<TElement>
{

    IPartition<TElement> Skip(int count);

    IPartition<TElement> Take(int count);

    TElement? TryGetElementAt(int index, out bool found);

    TElement? TryGetFirst(out bool found);

    TElement? TryGetLast(out bool found);
}

SelectListPartitionIterator类

 private sealed class SelectListPartitionIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>
{
    private readonly IList<TSource> _source;
    private readonly Func<TSource, TResult> _selector;
    private readonly int _minIndexInclusive;
    private readonly int _maxIndexInclusive;

    public SelectListPartitionIterator(IList<TSource> source, Func<TSource, TResult> selector, int minIndexInclusive, int maxIndexInclusive)
    {
        Debug.Assert(source != null);
        Debug.Assert(selector != null);
        Debug.Assert(minIndexInclusive >= 0);
        Debug.Assert(minIndexInclusive <= maxIndexInclusive);
        _source = source;
        _selector = selector;
        _minIndexInclusive = minIndexInclusive;
        _maxIndexInclusive = maxIndexInclusive;
    }

    public override Iterator<TResult> Clone() =>
        new SelectListPartitionIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, _maxIndexInclusive);

    public override bool MoveNext()
    {
        // _state - 1 represents the zero-based index into the list.
        // Having a separate field for the index would be more readable. However, we save it
        // into _state with a bias to minimize field size of the iterator.
        int index = _state - 1;
        if (unchecked((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive) && index < _source.Count - _minIndexInclusive))
        {
            _current = _selector(_source[_minIndexInclusive + index]);
            ++_state;
            return true;
        }

        Dispose();
        return false;
    }

    public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
        new SelectListPartitionIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector), _minIndexInclusive, _maxIndexInclusive);

    public IPartition<TResult> Skip(int count)
    {
        Debug.Assert(count > 0);
        int minIndex = _minIndexInclusive + count;
        return (uint)minIndex > (uint)_maxIndexInclusive ? EmptyPartition<TResult>.Instance : new SelectListPartitionIterator<TSource, TResult>(_source, _selector, minIndex, _maxIndexInclusive);
    }

    public IPartition<TResult> Take(int count)
    {
        Debug.Assert(count > 0);
        int maxIndex = _minIndexInclusive + count - 1;
        return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new SelectListPartitionIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, maxIndex);
    }

    public TResult? TryGetElementAt(int index, out bool found)
    {
        if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive) && index < _source.Count - _minIndexInclusive)
        {
            found = true;
            return _selector(_source[_minIndexInclusive + index]);
        }

        found = false;
        return default;
    }

    public TResult? TryGetFirst(out bool found)
    {
        if (_source.Count > _minIndexInclusive)
        {
            found = true;
            return _selector(_source[_minIndexInclusive]);
        }

        found = false;
        return default;
    }

    public TResult? TryGetLast(out bool found)
    {
        int lastIndex = _source.Count - 1;
        if (lastIndex >= _minIndexInclusive)
        {
            found = true;
            return _selector(_source[Math.Min(lastIndex, _maxIndexInclusive)]);
        }

        found = false;
        return default;
    }

    private int Count
    {
        get
        {
            int count = _source.Count;
            if (count <= _minIndexInclusive)
            {
                return 0;
            }

            return Math.Min(count - 1, _maxIndexInclusive) - _minIndexInclusive + 1;
        }
    }

    public TResult[] ToArray()
    {
        int count = Count;
        if (count == 0)
        {
            return Array.Empty<TResult>();
        }

        TResult[] array = new TResult[count];
        for (int i = 0, curIdx = _minIndexInclusive; i != array.Length; ++i, ++curIdx)
        {
            array[i] = _selector(_source[curIdx]);
        }

        return array;
    }

    public List<TResult> ToList()
    {
        int count = Count;
        if (count == 0)
        {
            return new List<TResult>();
        }

        List<TResult> list = new List<TResult>(count);
        int end = _minIndexInclusive + count;
        for (int i = _minIndexInclusive; i != end; ++i)
        {
            list.Add(_selector(_source[i]));
        }

        return list;
    }

    public int GetCount(bool onlyIfCheap)
    {
        // In case someone uses Count() to force evaluation of
        // the selector, run it provided `onlyIfCheap` is false.

        int count = Count;

        if (!onlyIfCheap)
        {
            int end = _minIndexInclusive + count;
            for (int i = _minIndexInclusive; i != end; ++i)
            {
                _selector(_source[i]);
            }
        }

        return count;
    }
}

SelectListIterator类 Select.cs

 private sealed partial class SelectListIterator<TSource, TResult> : Iterator<TResult>
 {
     private readonly List<TSource> _source;
     private readonly Func<TSource, TResult> _selector;
     private List<TSource>.Enumerator _enumerator;

     public SelectListIterator(List<TSource> source, Func<TSource, TResult> selector)
     {
         Debug.Assert(source != null);
         Debug.Assert(selector != null);
         _source = source;
         _selector = selector;
     }

     private int CountForDebugger => _source.Count;

     public override Iterator<TResult> Clone() => new SelectListIterator<TSource, TResult>(_source, _selector);

     public override bool MoveNext()
     {
         switch (_state)
         {
             case 1:
                 _enumerator = _source.GetEnumerator();
                 _state = 2;
                 goto case 2;
             case 2:
                 if (_enumerator.MoveNext())
                 {
                     _current = _selector(_enumerator.Current);
                     return true;
                 }

                 Dispose();
                 break;
         }

         return false;
     }

     public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
         new SelectListIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
 }

Select.SpeedOpt.cs

private sealed partial class SelectListIterator<TSource, TResult> : IPartition<TResult>
 {
      public TResult[] ToArray()
      {
          int count = _source.Count;
          if (count == 0)
          {
              return Array.Empty<TResult>();
          }

          var results = new TResult[count];
          for (int i = 0; i < results.Length; i++)
          {
              results[i] = _selector(_source[i]);
          }

          return results;
      }

      public List<TResult> ToList()
      {
          int count = _source.Count;
          var results = new List<TResult>(count);
          for (int i = 0; i < count; i++)
          {
              results.Add(_selector(_source[i]));
          }

          return results;
      }

      public int GetCount(bool onlyIfCheap)
      {
          // In case someone uses Count() to force evaluation of
          // the selector, run it provided `onlyIfCheap` is false.

          int count = _source.Count;

          if (!onlyIfCheap)
          {
              for (int i = 0; i < count; i++)
              {
                  _selector(_source[i]);
              }
          }

          return count;
      }

      public IPartition<TResult> Skip(int count)
      {
          Debug.Assert(count > 0);
          return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
      }

      public IPartition<TResult> Take(int count)
      {
          Debug.Assert(count > 0);
          return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, 0, count - 1);
      }

      public TResult? TryGetElementAt(int index, out bool found)
      {
          if (unchecked((uint)index < (uint)_source.Count))
          {
              found = true;
              return _selector(_source[index]);
          }

          found = false;
          return default;
      }

      public TResult? TryGetFirst(out bool found)
      {
          if (_source.Count != 0)
          {
              found = true;
              return _selector(_source[0]);
          }

          found = false;
          return default;
      }

      public TResult? TryGetLast(out bool found)
      {
          int len = _source.Count;
          if (len != 0)
          {
              found = true;
              return _selector(_source[len - 1]);
          }

          found = false;
          return default;
      }
  }
懒人Ethan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#linq里的Skip和Take处理分页笔记
大海的王者是自由
09-25 3242
C#的linq中Take() 和Skip() 在做分页处理的时候，先后顺序问题。
全面分析c# LINQ
09-07
C# LINQ，全称Language Integrated Query，是.NET框架中的一项重要特性，旨在提供一种在各种数据源（如数据库、XML文档、数组等）上进行统一查询的语言集成方式。通过LINQ，开发者可以使用类似SQL的语法在C#代码中...
C# Linq源码分析之Take（五）
weixin_43263355的博客
09-06 853
本文在的基础上继续从源码角度分析Take的优化方法，主要分析Where.Select.Take的使用案例。
C# Linq源码分析之Take方法
weixin_43263355的博客
08-11 1732
基本功能是从序列source中，返回指定个数count的相邻元素。
C# Linq源码分析之Take （一）
weixin_43263355的博客
08-14 939
新的Take重载方法不再接收整数参数，而是接收一个Range类型的参数。它可以从序列中返回指定范围的连续元素。注意：该方法只能在.Net 6 或更高版本中使用，我们之前用的.Net 4.7， 4.8或.Net Core 3.1中，都不支持该方法。
.NET(C#) Linq Take和TakeWhile的使用
weixin_42098295的博客
02-23 382
Linq是Language Integrated Query的简称，它是微软在.NET Framework 3.5里面新加入的特性，用以简化查询查询操作。本文主要介绍.NET(C#) 中Linq的Take和TakeWhile操作符。 原文地址：.NET(C#) Linq Take和TakeWhile的使用 ...
c# Linq常用的小技巧
08-18
C# Linq 作为一个强大的数据查询语言，已经成为 C# 开发者的必备技能之一。在日常开发中，我们经常需要对数据进行处理和查询，而 Linq 就是一个非常实用的工具。下面我们将总结一些常用的 Linq 技巧，帮助大家更好地...
爆方便_C#linq映射实体_
10-01
在.NET框架中，C# LINQ（Language Integrated Query，语言集成查询）是一种强大的查询机制，它使得在C#代码中处理数据集变得极其简洁。这个名为"爆方便_C#linq映射实体_"的工具专注于简化C# LINQ实体映射的过程，...
C# LINQ 两者方法示例
10-08
C# LINQ（Language Integrated Query，语言集成查询）是.NET框架的一个强大特性，它为C#程序员提供了一种优雅的方式来处理数据，无论这些数据来自数组、集合、数据库还是XML文档。在C# LINQ中，有两种主要的方法来...
LINQ Take和Skip
qingfeng45697的专栏
09-17 501
Take和Skip 假定需要数据集中销售量位于前5名的顾客。我们事先并不知道这5名顾客的销售量是多少，所以不能使用where条件查找他们。 一些SQL数据库如Microsoft SQL Server实现了TOP运算符，所以可以执行命令SELECT Top 5 FROM …，获得前5名顾客的数据。 与这个操作对应的LINQ方法是Take()，它可以从查询结果中提取前n个结果。实际上
C# linq的Take和Skip存在先后顺序
01-21 665
原语句为var q = _list.AsParallel().WithCancellation(tokenSource.Token).Where(item => item.IsBeginWith(syllables)).OrderByDescending(item => item.Syllables.Length).ThenByDescending(item => item.Frequency).Take(num).Skip(skip); linq的Take和Skip存在先后顺序。如果这样
LINQ 语句中Take() 和Skip() 总结
锡克步兵团团长的博客
12-31 3596
Linq 语句中Take() 和Skip() 总结： 一、Take() 和Skip() 在对数据进行分区选择时常用Take() 和Skip() 通过如下例子进行方法的效果展示： Take() 方法： var query = (from student in current.listInfo where student.name.Contains("lilu") ord...
Linq中Take与Skip的使用
07-21 158
eg:现要求查询出class_id为2的班级中年龄最大的3个学生的姓名 使用SQL语句查询时，代码如下所示。 select top 3 student_name from tb_Student where class_id=2 order by student_age 在Linq中使用Take()方法结合orderby子句一起来实现 1 using System; ...
Linq Take和Skip详解
weixin_30892763的博客
05-10 193
Take()方法的作用就是：从查询结果中提取前n个结果。 Skip()方法正好是Take()方法的反面，它可以跳过前n个结果，返回剩余的结果。 例如：查找年龄最大的3个人 表Student的数据是 Name Age Jame 21 Tom 56 KD 36 Black 5 Bules 12 ...
LINQ之Take, TakeWhile
lcy的博客
04-16 1561
目录Take() Take() Take()可以获取序列的指定部分。具体使用请看下面案例。 MSDN public static IEnumerable<TSource> Take<TSource>( this IEnumerable<TSource> source, int count ); 代码示例： public static class Program ...
Linq中的Take和Skip
每天进步一点点
04-26 6807
原文：http://msdn.microsoft.com/zh-cn/library/bb503062(v=vs.110).aspx 如果 count 小于等于零，则不枚举 source，并返回空的 IEnumerableT>。 TakeTSource> 和 SkipTSource> 方法在功能上补充。 如果给定一个序列 coll 和一个整数 n，则连接 coll.Take(n) 
Linq 下的 Take() 方法内部机制是怎样的？
dotNET跨平台
11-01 528
咨询区 Rahul Kishore：我的web需要访问数据库，但是表比较大，我仅仅想要获取该表中 N 条数据，我查阅了 MSDN 文档，看到了一个 Take() 方法，我现在很疑惑它的运行...
Linq中Take、TakeWhile、Skip、SkipWhile的比较
weixin_30654583的博客
10-29 77
以下代码均来自微软官网/// <summary>/// This sample uses Take to get only the first 3 elements of the array./// </summary>public void Linq1(){ int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; v...
【C#】使用 LINQ 中的 Skip() 和 Take()进行分页，为什么要分页，分页作用是什么
最新发布
小5聊的博客
01-10 2372
数据是通过分组查询出来，并且有统计值，这个统计值来源于另外一个表的统计值， 次数分组的数据量不大，最大可能也就在一千或者一万条记录，分组查询速度对性能影响不大。 此时，查询出来的一万条记录，如果都显示在页面，可能对前端渲染有一定性能影响， 因此，可在后端开发语言里进行内存分页。
C#使用LINQ中Enumerable类方法的延迟与立即执行的控制
09-02
"C#使用LINQ中Enumerable类方法的延迟与立即执行的控制" 本文主要探讨了C#中的LINQ（Language Integrated Query）技术，特别是如何通过Enumerable类方法来控制查询的延迟执行和立即执行。LINQ为C#和VB提供了一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值