.net泛型，数组，lambda调用性能 定量比较

最新推荐文章于 2026-06-26 05:38:55 发布
原创 最新推荐文章于 2026-06-26 05:38:55 发布 · 1.7k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c# #排序算法
本文探讨了.NET框架中泛型、数组和Lambda表达式在排序性能上的差异。作者通过编写不同版本的快速排序算法进行测试，发现.NET LINQ的Sort方法性能最优。实验结果显示，使用Lambda表达式会降低性能，而从List转换为数组可以显著提高排序速度。此外，调整函数调用结构也会对性能产生影响。

这几天准备.net的面试 周末手写快速排序练练手，一时兴起想测测自己写的快速排序性能如何，尤其是对比以前写过的快速排序，发现了.net性能上的一点儿有趣的事情

首先是一段高扩展性的快速排序，支持泛型，同时还使用lambda表达式使得该快速排序可以支持任何类型的排序，只要提供了排序方法即可，代码如下

public static void Sort<T>(List<T> arrayForSort, int startIndex, int endIndex, Func<T, T, bool> CompareMethod)
        {
            if (startIndex >= endIndex)
            {
                return;
            }
            int pointer = startIndex;
            int end = endIndex;
            for (int i = pointer + 1; i <= end; i++)
            {
                if (CompareMethod(arrayForSort[pointer], arrayForSort[i]))//把比当前锚点数小的数全部移到锚点数左边
                {
                    var temp = arrayForSort[pointer];
                    arrayForSort[pointer] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    pointer = i;
                }
                else//若当前比较的数比锚点数大 则将其与最后面的数对调
                {
                    var temp = arrayForSort[end];
                    arrayForSort[end] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    --i;
                    --end;
                }
            }
            Sort<T>(arrayForSort, startIndex, pointer, CompareMethod);
            Sort<T>(arrayForSort, pointer+1, endIndex, CompareMethod);
        }

然后同样的排序方法，写法也一样，但是去掉了方便扩展的泛型支持以及lambda，这样代码就只能对list<int>排序了代码如下（其实就是把参数改了下，删除了最后的CompareMethod参数) 

public static void Sort(List<int> arrayForSort, int startIndex, int endIndex)
        {
            if (startIndex >= endIndex)
            {
                return;
            }
            int pointer = startIndex;
            int end = endIndex;
            for (int i = pointer + 1; i <= end; i++)
            {
                if (arrayForSort[pointer] > arrayForSort[i])//把比当前锚点数小的数全部移到锚点数左边
                {
                    var temp = arrayForSort[pointer];
                    arrayForSort[pointer] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    pointer = i;
                }
                else//若当前比较的数比锚点数大 则将其与后面的数对调
                {
                    var temp = arrayForSort[end];
                    arrayForSort[end] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    --i;
                    --end;
                }
            }
            Sort(arrayForSort, startIndex, pointer);
            Sort(arrayForSort, pointer + 1, endIndex);
        }
然后进一步简化 讲list<int>改为int[]数组，代码不用动，只需要改参数就可以了 

public static void Sort(int[] arrayForSort, int startIndex, int endIndex)
        {
            if (startIndex >= endIndex)
            {
                return;
            }
            int pointer = startIndex;
            int end = endIndex;
            for (int i = pointer + 1; i <= end; i++)
            {
                if (arrayForSort[pointer] > arrayForSort[i])//把比当前锚点数小的数全部移到锚点数左边
                {
                    var temp = arrayForSort[pointer];
                    arrayForSort[pointer] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    pointer = i;
                }
                else//若当前比较的数比锚点数大 则将其与后面的数对调
                {
                    var temp = arrayForSort[end];
                    arrayForSort[end] = arrayForSort[i];
                    arrayForSort[i] = temp;
                    --i;
                    --end;
                }
            }
            Sort(arrayForSort, startIndex, pointer);
            Sort(arrayForSort, pointer + 1, endIndex);
        }

最后是快排的另一种写法，同样是用int[]做容器（其实我已经不怎么看得懂当时是如何写的了。。。。。） 

 public static void SortAnotherMethod(int[] source, int startPoint, int endPoint)
        {
            if (startPoint < endPoint)
            {
                int i = partrn(source, startPoint, endPoint);
                SortAnotherMethod(source, startPoint, i - 1);
                SortAnotherMethod(source, i + 1, endPoint);
            }
        }
        private static void swap(int[] source, int left, int right)
        {
            source[left] = source[right] + source[left];
            source[right] = source[left] - source[right];
            source[left] = source[left] - source[right];
        }
        private static int partrn(int[] source, int left, int right)
        {
            int pivot = source[left];
            while (left < right)
            {
                while (left < right && source[right] >= pivot)
                    right--;
                if (left < right)
                {
                    swap(source, left, right);
                }
                while (left < right && source[left] <= pivot)
                    left++;
                if (left < right)
                {
                    swap(source, left, right);
                }
            }
            source[left] = pivot;
            return left;
        }

最后是相对简单的调用代码。。利用stopwatch计时，这里利用快速排序对一千万个数进行排序 数字范围在一亿里面  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace QuickSort
{
    class Program
    {
        static void Main(string[] args)
        {
            Random rdm = new Random();
            List<int> testList = new List<int>();
            List<int> testList2 = new List<int>();
            int[] testArray4 = new int[10000000];
            List<int> testList3 = new List<int>();
            int[] testArray3 = new int[10000000];
            for (int i = 0; i < 10000000; i++)
            {
                var number = rdm.Next(100000000);
                testList.Insert(i, number);
                testList2.Insert(i, number);
                testList3.Insert(i, number);
                testArray3[i] = number;
                testArray4[i] = number;
            }
            var watch1 = new Stopwatch();
            watch1.Start();
            QuickSortMain.Sort<int>(testList, 0, testList.Count-1, (x, y) => { return x > y; });
            watch1.Stop();
            var customSort = watch1.ElapsedMilliseconds;

            watch1.Reset();
            watch1.Start();
            QuickSortMain.Sort(testList2, 0, testList2.Count - 1);
            watch1.Stop();
            var customSort2 = watch1.ElapsedMilliseconds;

            watch1.Reset();
            watch1.Start();
            QuickSortMain.Sort(testArray3, 0, testArray3.Length - 1);
            watch1.Stop();
            var customSort3 = watch1.ElapsedMilliseconds;

            watch1.Reset();
            watch1.Start();
            QuickSortMain.SortAnotherMethod(testArray4, 0, testArray4.Length - 1);
            watch1.Stop();
            var customSort4 = watch1.ElapsedMilliseconds;

            watch1.Reset();
            watch1.Start();
            testList3.Sort();
            watch1.Stop();
            var systemSort = watch1.ElapsedMilliseconds;
            Console.WriteLine("泛型方法，涉及lambda调用       Custom1 Sort:" + customSort);//快排，比较方法用了lambda，容器为list<int>
            Console.WriteLine("直接list<int>做容器                  Custom2 Sort:" + customSort2);//直接用list<int>做容器
            Console.WriteLine("直接int[]做容器                         Custom3 Sort:" + customSort3);//容器为Int[]，写法上和1,2是一样的
            Console.WriteLine("直接int[]做容器的另一种写法     Custom4 Sort:" + customSort4);//容器同样为int[], 算法同样是快速排序但是写法略有不同
            Console.WriteLine("C#自带排序方法                       System Sort:" + systemSort);//系统自带排序
            Console.ReadLine();
        }
    }
}

激动人心的时刻到了 让我们来看看各种调用方法在时间上面的差异


很不幸自己写的方法全部败给了.net linq自带的sort(改天可以研究研究)

这里看看自己的排序方法之间的差异

第一种 扩展性最强 泛型+lambda可以应付基本上所有排序（当然.net自带的也可以这么做 但是是使用的ICompare接口，我个人认为是直接用lambda来比较方便），时间上惨不忍睹。。。和.net linq差了一个数量级还多

第二种 去掉了lambda调用，速度立马飞升三分之一，可见lambda对性能的影响是很明显的（其实任何函数调用都影响性能，这就是为啥c++里面简短的函数编译时候可以内联）

第三种 将list<int>改为了int[]，速度又提升一半，很明显数组的直接内存地址读取要比list通过地址来读取快一倍（改天试试用hashtable做容器跟int[]做对比）

第四种 还是int[]做容器，只是排序算法写法稍微做了改动，本质上还是快速排序，可以看出，和最开始的唯一不同多了几步函数调用，可见函数调用对性能的影响

第五章 .net linq自带的sort......不说啥了。。。有谁知道内部是如何实现的么？



【信息科学与工程学】【运营科学】第二篇 C4信息与通信网络运营 (C4) ——数据中心网络运营05
weixin_49199313的博客
03-27 629
编号应用领域角色/岗位类型场景算法算子名称算子的数学方程式/逻辑表达复杂度关联知识数据输入数据需求数据输出法律法规及裁决依据/道德标准及方法1241企业之间战略“认知战”指挥官（攻击方）不直接攻击产品， 而是通过系统性舆论、行业报告、KOL发声， 重塑市场对竞争对手核心优势的“认知”， 将其贬低为“过时技术”或“错误赛道”认知解构与赛道降级针对对手的核心优势A， 构建并传播叙事N： “A虽然是过去十年的主流， 但已被新兴的B范式取代。 坚守A是路径依赖， 将错失未来。”对手以“强大的线下渠道”（A）为核心优
C#中的泛型
见证大牛成长之路的专栏
01-17 709
C#中的泛型   前言 现在的.NET版本是5.0了,但是在1.1的时候,最受诟病的一个缺陷就是没有对泛型的支持.你想想,对于一种强类型的语言来说,我写了一个针对整数的排序,但是现在又需要对字符串排序,然又需要对double排序等等,强类型语言又不像弱类型语言一样所有的类型都使用一个关键字定义就行,比如JS就都是使用var来定义变量.所以说,强类型语言如果没有
List中常用的Lambda表达式
qq_36598111的博客
11-24 2849
对比平常的for循环，stream().forEach可以进行并发处理，比如你这个循环里要进行很多业务处理，调用接口或者第三方，或者查询之类的接口，一般对值的处理还是用for循环好一点，性能上会快一点。属于中间操作，性能上不太好，还不如for循环，在某些特定调式的时候可以用。其中 reversed() 表示倒序的意思，如果不使用此方法则是正序。Function.identity()值的是整个对象的值当作vaule。写了一些常用的，后续如果用到一些其他的继续更新。开发随手记一些常用的吧。
C# Lambda表达式详解，及Lambda表达式树的创建
aa124413278的博客
07-15 837
　　最近由于项目需要，刚刚学完了Action委托和Func<T>委托，发现学完了委托就必须学习lambda表达式，委托和Lambda表达式联合起来，才能充分的体现委托的便利、才能使代码更加简介、优雅。 Lambda表达式 "Lambda表达式"是一个匿名函数，是一种高效的类似于函数式编程的表达式，Lambda简化了开发中需要编写的代码量。它可以包含表达式和语句，并且...
.NET中那些所谓的新语法之三：系统预定义委托与Lambda表达式
OnlyRu丶小心心
11-20 666
开篇：在上一篇中，我们了解了匿名类、匿名方法与扩展方法等所谓的新语法，这一篇我们继续征程，看看系统预定义委托（Action/Func/Predicate）和超爱的Lambda表达式。为了方便码农们，.Net基类库针对实际开发中最常用的情形提供了几个预定义好的委托，这些委托可以直接使用，无需再重头定义一个自己的委托类型。预定义委托在.Net基类库中使用的比较广泛，比如在Lambda表达式和并行计算中
C#Lamda表达式
weixin_41244604的博客
11-25 1830
Lambda 表达式（C# 引用） “Lambda 表达式”是采用以下任意一种形式的表达式： 表达式 lambda，表达式为其主体： (input-parameters) => expression 语句 lambda，语句块作为其主体： (input-parameters) => { <sequence-of-statements> } 使用 lambda 声明运算符=> 从其主体中分离 lambda 参数列表。 若要创建 Lambda 表达式，需要在 Lambda
.net 4.0提供的并行计算Task到底有多快的定量分析
xboxeer的专栏
10-20 736
昨天研究了下利用不同容器实现快排算法（list+lambda, list, int[],
Java技术体系之基础能力篇（五）——深入理解JVM原理
qsmiley10的博客
05-01 3140
1、Java概述 1.1 Java技术体系   从广义上讲，Kotlin、Clojure、JRuby、Groovy等运行于Java虚拟机上的编程语言及其相关的程序都属于Java技术体系中的一员。如果仅从传统意义上来看，JCP官方所定义的Java技术体系包括了以下几个组成部分： Java程序设计语言 各种硬件平台上的Java虚拟机实现 Class文件格式 Java类库API 来自商业机构和开源社区的第三方Java类库   以上是根据Java各个组成部分的功能来进行划分，如果按照技术所服务的领域来划分，或者
机器学习偏差与方差：模型诊断的工程听诊器
aikunjiao3421的博客
06-13 394
在机器学习实践中，预测误差并非单一概念，而是可分解为偏差（反映模型系统性偏离）与方差（反映模型对数据扰动的敏感性）两大核心成分。这一经典分解不仅是理论基础，更是定位欠拟合、过拟合及线上性能波动的底层逻辑——偏差主导时模型表达能力不足，需增强特征或升级模型结构；方差主导时模型过度记忆噪声，需正则化、集成或数据鲁棒性处理。其技术价值在于将模糊的‘效果不好’转化为可测量、可干预的工程问题，广泛应用于风控建模、工业质检、推荐系统等强调稳定性的生产场景。本文聚焦实操诊断与全链路调控，提供基于损失曲线、Bootstra
量化感知训练（QAT）实战：让模型在训练时就学会int8推理
chuanggangbo5551的博客
06-16 320
量化感知训练（QAT）是一种面向边缘部署的模型优化技术，其核心在于将量化操作嵌入训练流程，使模型主动适应int8数值域的缩放因子（scale）与零点偏移（zero_point）约束。不同于后训练量化（PTQ）的静态映射，QAT通过前向传播中的FakeQuant层模拟硬件量化行为，并在反向传播中联合更新权重与量化参数，从而缓解因分布偏移、通道敏感度失配导致的精度骤降问题。该技术显著提升TFLite等轻量级推理引擎的int8精度，广泛应用于移动端图像识别、STM32嵌入式AI及工业质检等低功耗场景，是实现高精度
MATLAB SAR图像船舶尾迹检测工具：Radon变换建模+GMC稀疏优化实现自动航迹提取
最新发布
k6l7m8n9的博客
06-26 41
一套即装即用的MATLAB船舶尾迹检测方案，专为合成孔径雷达（SAR）海面图像设计，支持TerraSAR-X等常见格式输入。核心流程从原始SAR图像出发，先通过radonT.m执行Radon正向变换，将船舶尾迹映射为参数空间中的显著峰值；再构建线性响应模型，引入广义最小极大凹面（GMC）函数作为稀疏正则化项，在保持整体目标函数可解性的同时增强航迹结构的稀疏表达能力；最后在贝叶斯框架下，调用IP_solve.m进行最大后验（MAP）估计，完成反问题求解，输出高置信度的航迹候选线段（confirmedHalfl
【信息科学与工程学】【运营科学】第二篇 C4信息与通信网络运营 (C4) ——数据中心网络运营04
weixin_49199313的博客
03-24 709
典型值：λ1​∈[−0.02,−0.01], λ2​∈[−0.01,0], η1​,η3​∈[0.1,0.3], η2​,η4​∈[0.05,0.15]参数：δ1​∈[−0.8,−0.3], δ2​∈[−0.5,−0.2], δ3​∈[−0.4,−0.1], δ4​∈[−0.6,−0.2]参数：φ1​∈[0.1,0.3], φ2​∈[−0.2,−0.05], φ3​∈[−0.1,0.1], φ4​∈[−0.3,−0.1]参数：α∈[0.3,0.6], β∈[0.2,0.4], γ∈[0.01,0.03]
C#数组的lambda表达式
过客
01-09 878
C#数组的lambda表达式和数组结合使用
C# 中使用Linq和Lambda表达式对List<T>进行排序
热门推荐
飞月程序人生
07-02 1万+
C#中List排序的两种方法 List stu = (ListStudent>)Session["StudentList"]; Linq表达式: //按学号降序 ListStudent> stuList = (from s in stu  orderby s.stuNO descending select s).ToListStudent>(); /
lambda之排序
Yes_You_Can 的博客
11-29 991
本文参考链接：https://blog.csdn.net/songbinxu/article/details/80417861 https://blog.csdn.net/ray_up/article/details/42084863 https://blog.csdn.net/ray_up/a...
3004—C# Lambda随笔
zhang_yling的专栏
10-29 274
一、对象数组查询 1—简单型 Product[] products = new Product[] { new Product{Id=1,Name="Tomato Soup",Category="Groceries",Price=1}, new Product{Id=2,Name="Yo-yo",Category="Toys",Price=3.75M}, new Product{Id=3,Name="Hammer",Category="Hardware",...
C# 高效编程：Any () 与 Count () 正确选择
m0_46091798的博客
12-30 862
在 C 开发中，选择 `Count()` 还是 `Any()`，关键在于明确业务意图并理解不同集合类型与场景下的性能差异。2. 获取数量区分集合类型：`ICollection<T>` 使用 `Count` 属性，`IEnumerable<T>` 使用 `Count()` 方法。对延迟加载集合（如 LINQ 查询、EF DbSet），`Any()` 仅获取首条匹配记录，`Count()` 则可能遍历全部数据或扫描全表。// 避免：Count() > 0 会生成 SELECT COUNT() …
VB.NET的lambda运算符和C#的lambda运算符=>之比较
itleon的博客
10-26 3666
VB.NET也是有运算符的，不过不是=&amp;gt;，而是用Function（）代替的。比如求一个字符串数组中最短字符串的长度，代码如下： Dim words As String() = {&quot;cherry&quot;, &quot;apple&quot;, &quot;blueberry&quot;} Dim shortestWordLength As Integer = words.Min(Function(mm) mm.Length
Linq与Lambda表达式在.NET中的性能对比
python_git301的博客
09-12 496
在.NET开发中，Linq（Language Integrated Query）和Lambda表达式是两个常用的功能强大的工具，用于处理集合和查询数据。Linq和Lambda表达式的性能比较是一个复杂的问题，因为性能取决于多个因素，如查询的复杂性、数据量的大小以及底层数据提供程序的实现。总体而言，Linq和Lambda表达式在绝大多数情况下都具有相似的性能，但在某些情况下，它们之间可能存在一些微小的差异。例如，在处理大量数据时，Lambda表达式可能稍微快一些，因为它们在编译时生成的代码更加紧凑。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值