找回密码
 立即注册

QQ登录

只需一步，快速开始

首页 › 技术交流区 › .NET技术交流 › 查看内容
发新帖

断天涯大虾

社区贡献组

269

主题

272

帖子

1655

积分

社区贡献组

积分
1655

微信认证勋章

最新发帖

是什么优化让 .NET Core 性能飙升？

断天涯大虾
社区贡献组   /  发表于：2017-7-17 12:18  /   查看：10719  /  回复：0
本帖最后由 断天涯大虾 于 2017-7-17 13:46 编辑

.NET Core（开放源代码，跨平台，x-copy可部署等）有许多令人兴奋的方面，其中最值得称赞的就是其性能了。
感谢所有社区开发人员对.NET Core做出的贡献，其中的许多改进也将在接下来的几个版本中引入.NET Framework。
本文主要介绍.NET Core中的一些性能改进，特别是.NET Core 2.0中的，重点介绍各个核心库的一些示例。

集合
集合是任何应用程序的基石，同时.NET库中也有大量集合。.NET库中的一些改进是为了消除开销，例如简化操作以便更好的实现内联，减少指令数量等。例如，下面的这个使用Q<T>的例子：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new Queue<int>();
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 q.Enqueue(i);
  15.                 q.Dequeue();
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
PR dotnet/corefx #2515移除了这些操作中相对复杂的模数运算，在个人计算机，以上代码在.NET 4.7上产生如下输出：
  1. 00：00：00.9392595
  2. 00：00：00.9390453
  3. 00：00：00.9455784
  4. 00：00：00.9508294
  5. 00：00：01.0107745
复制代码
而使用.NET Core 2.0则会产生如下输出：
  1. 00：00：00.9392595
  2. 00：00：00.9390453
  3. 00：00：00.9455784
  4. 00：00：00.9508294
  5. 00：00：01.0107745
复制代码
由于这是挂钟时间所节省的，较小的值计算的更快，这也表明吞吐量增加了约2倍！

在其他情况下，通过更改操作算法的复杂性，可以更快地进行操作。编写软件时，最初编写的一个简单实现，虽然是正确的，但是这样实现往往不能表现出最佳的性能，直到特定的场景出现时，才考虑如何提高性能。例如，SortedSet <T>的ctor最初以相对简单的方式编写，由于使用O（N ^ 2）算法来处理重复项，因此不能很好地处理复杂性。该算法在PRnetnet / corefx＃1955中的.NET Core中得到修复。以下简短的程序说明了修复的区别：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. using System.Linq;

  6. public class Test
  7. {
  8.     public static void Main()
  9.     {
  10.         var sw = Stopwatch.StartNew();
  11.         var ss = new SortedSet<int>(Enumerable.Repeat(42, 400_000));
  12.         Console.WriteLine(sw.Elapsed);
  13.     }
  14. }
复制代码
在个人电脑的.NET Framework上，这段代码需要大约7.7秒执行完成。在.NET Core 2.0上，减少到大约0.013s（改进改变了算法的复杂性，集合越大，节省的时间越多）。
或者在SortedSet <T>上考虑这个例子：
  1. public class Test
  2. {
  3.     static int s_result;

  5.     public static void Main()
  6.     {
  7.         while (true)
  8.         {
  9.             var s = new SortedSet<int>();
  10.             for (int n = 0; n < 100_000; n++)
  11.             {
  12.                 s.Add(n);
  13.             }

  15.             var sw = Stopwatch.StartNew();
  16.             for (int i = 0; i < 10_000_000; i++)
  17.             {
  18.                 s_result = s.Min;
  19.             }
  20.             Console.WriteLine(sw.Elapsed);
  21.         }
  22.     }
  23. }
复制代码
.NET 4.7中Min和Max的实现遍布SortedSet <T>的整个树，但是只需要找到最小或最大值即可，因为实现可以只遍历相关的节点。PR dotnet / corefx＃11968修复了.NET Core实现。在.NET 4.7中，此示例生成如下结果：
  1. 00：00：01.1427246
  2. 00：00：01.1295220
  3. 00：00：01.1350696
  4. 00：00：01.1502784
  5. 00：00：01.1677880
复制代码
而在.NET Core 2.0中，我们得到如下结果：
  1. 00：00：00.0861391
  2. 00：00：00.0861183
  3. 00：00：00.0866616
  4. 00：00：00.0848434
  5. 00：00：00.0860198
复制代码
显示出相当大的时间下降和吞吐量的增加。
即使像List <T>这样的主工作核心也有改进的空间。考虑下面的例子：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Generic;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var l = new List<int>();
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 l.Add(i);
  15.                 l.RemoveAt(0);
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中，会得到的结果如下：
  1. 00：00：00.4434135
  2. 00：00：00.4394329
  3. 00：00：00.4496867
  4. 00：00：00.4496383
  5. 00：00：00.4515505
复制代码
和.NET Core 2.0，得到：
  1. 00：00：00.3213094
  2. 00：00：00.3211772
  3. 00：00：00.3179631
  4. 00：00：00.3198449
  5. 00：00：00.3164009
复制代码
可以肯定的是，在0.3秒内可以实现1亿次这样的添加并从列表中删除的操作，这表明操作开始并不慢。但是，通过执行一个应用程序，列表通常会添加到很多，同时也节省了总时间消耗。

这些类型的集合改进扩展不仅仅是System.Collections.Generic命名空间; System.Collections.Concurrent也有很多改进。事实上，.NET Core 2.0上的ConcurrentQueue <T>和ConcurrentBag <T>完全重写了。下面看看一个基本的例子，使用ConcurrentQueue <T>但没有任何并发，例子中使用ConcurrentQueue <T>代替了Queue<T>：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;

  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         while (true)
  10.         {
  11.             var q = new ConcurrentQueue<int>();
  12.             var sw = Stopwatch.StartNew();
  13.             for (int i = 0; i < 100_000_000; i++)
  14.             {
  15.                 q.Enqueue(i);
  16.                 q.TryDequeue(out int _);
  17.             }
  18.             Console.WriteLine(sw.Elapsed);
  19.         }
  20.     }
  21. }
复制代码
在个人电脑上，.NET 4.7产生的输出如下：
  1. 00：00：02.6485174
  2. 00：00：02.6144919
  3. 00：00：02.6699958
  4. 00：00：02.6441047
  5. 00：00：02.6255135
复制代码
显然，.NET 4.7上的ConcurrentQueue <T>示例比.NET 4.7中的Queue <T>版本慢，因为ConcurrentQueue <T>需要采用同步来确保是否安全使用。但是，更有趣的比较是当在.NET Core 2.0上运行相同的代码时会发生什么：
  1. 00：00：01.7700190
  2. 00：00：01.8324078
  3. 00：00：01.7552966
  4. 00：00：01.7518632
  5. 00：00：01.7560811
复制代码
这表明当将.NET Core 2.0切换到30％时，ConcurrentQueue <T>的吞吐量没有任何并发&#8203;&#8203;性提高。但是实施中的变化提高了序列化的吞吐量，甚至更多地减少了使用队列的生产和消耗之间的同步，这可能对吞吐量有更明显的影响。请考虑以下代码：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. using System.Threading.Tasks;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         while (true)
  10.         {
  11.             const int Items = 100_000_000;
  12.             var q = new ConcurrentQueue<int>();
  13.             var sw = Stopwatch.StartNew();

  15.             Task consumer = Task.Run(() =>
  16.             {
  17.                 int total = 0;
  18.                 while (total < Items) if (q.TryDequeue(out int _)) total++;
  19.             });
  20.             for (int i = 0; i < Items; i++) q.Enqueue(i);
  21.             consumer.Wait();

  23.             Console.WriteLine(sw.Elapsed);
  24.         }
  25.     }
  26. }
复制代码
在.NET 4.7中，个人计算机输出如下结果：
  1. 00：00：06.1366044
  2. 00：00：05.7169339
  3. 00：00：06.3870274
  4. 00：00：05.5487718
  5. 00：00：06.6069291
复制代码
而使用.NET Core 2.0，会得到以下结果：
  1. 00：00：01.2052460
  2. 00：00：01.5269184
  3. 00：00：01.4638793
  4. 00：00：01.4963922
  5. 00：00：01.4927520
复制代码
这是一个3.5倍的吞吐量的增长。不但CPU效率提高了， 而且内存分配也大大减少。下面的例子主要观察GC集合的数量，而不是挂钟时间：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new ConcurrentQueue<int>();
  11.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 q.Enqueue(i);
  15.                 q.TryDequeue(out int _);
  16.             }
  17.             Console.WriteLine([        DISCUZ_CODE_16        ]quot;Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中，得到以下输出：
  1. Gen0 = 162 Gen1 = 80 Gen2 = 0
  2. Gen0 = 162 Gen1 = 81 Gen2 = 0
  3. Gen0 = 162 Gen1 = 81 Gen2 = 0
  4. Gen0 = 162 Gen1 = 81 Gen2 = 0
  5. Gen0 = 162 Gen1 = 81 Gen2 = 0
复制代码
而使用.NET Core 2.0，会得到如下输出：
  1. Gen0 = 0 Gen1 = 0 Gen2 = 0
  2. Gen0 = 0 Gen1 = 0 Gen2 = 0
  3. Gen0 = 0 Gen1 = 0 Gen2 = 0
  4. Gen0 = 0 Gen1 = 0 Gen2 = 0
  5. Gen0 = 0 Gen1 = 0 Gen2 = 0
复制代码
.NET 4.7中的实现使用了固定大小的数组链表，一旦固定数量的元素被添加到每个数组中，就会被丢弃， 这有助于简化实现，但也会导致生成大量垃圾。在.NET Core 2.0中，新的实现仍然使用链接在一起的链接列表，但是随着新的片段的添加，这些片段的大小会增加，更重要的是使用循环缓冲区，只有在前一个片段完全结束时，新片段才会增加。这种分配的减少可能对应用程序的整体性能产生相当大的影响。

ConcurrentBag <T>也有类似改进。ConcurrentBag <T>维护thread-local work-stealing队列，使得添加到的每个线程都有自己的队列。在.NET 4.7中，这些队列被实现为每个元素占据一个节点的链接列表，这意味着对该包的任何添加都会导致分配。在.NET Core 2.0中，这些队列是数组，这意味着除了增加阵列所涉及的均摊成本之外，增加的还是无需配置的。以下可以看出：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Collections.Concurrent;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             var q = new ConcurrentBag<int>() { 1, 2 };
  11.             var sw = new Stopwatch();

  13.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  14.             sw.Start();

  16.             for (int i = 0; i < 100_000_000; i++)
  17.             {
  18.                 q.Add(i);
  19.                 q.TryTake(out int _);
  20.             }

  22.             sw.Stop();
  23.             Console.WriteLine([        DISCUZ_CODE_19        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  24.         }
  25.     }
  26. }
复制代码
在.NET 4.7中，个人计算机上产生以下输出：
  1. Elapsed=00:00:06.5672723 Gen0=953 Gen1=0 Gen2=0
  2. Elapsed=00:00:06.4829793 Gen0=954 Gen1=1 Gen2=0
  3. Elapsed=00:00:06.9008532 Gen0=954 Gen1=0 Gen2=0
  4. Elapsed=00:00:06.6485667 Gen0=953 Gen1=1 Gen2=0
  5. Elapsed=00:00:06.4671746 Gen0=954 Gen1=1 Gen2=0
复制代码
而使用.NET Core 2.0，会得到：
  1. Elapsed=00:00:04.3377355 Gen0=0 Gen1=0 Gen2=0
  2. Elapsed=00:00:04.2892791 Gen0=0 Gen1=0 Gen2=0
  3. Elapsed=00:00:04.3101593 Gen0=0 Gen1=0 Gen2=0
  4. Elapsed=00:00:04.2652497 Gen0=0 Gen1=0 Gen2=0
  5. Elapsed=00:00:04.2808077 Gen0=0 Gen1=0 Gen2=0
复制代码
吞吐量提高了约30％，并且分配和完成的垃圾收集量减少了。

LINQ
在应用程序代码中，集合通常与语言集成查询（LINQ）紧密相连，该查询已经有了更多的改进。LINQ中的许多运算符已经完全重写为.NET Core，以便减少分配的数量和大小，降低算法复杂度，并且消除不必要的工作。

例如，Enumerable.Concat方法用于创建一个单一的IEnumerable <T>，它首先产生first域可枚举的所有元素，然后再生成second域所有的元素。它在.NET 4.7中的实现是简单易懂的，下面的代码正好反映了这种行为表述：
  1. static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second) {
  2.     foreach (TSource element in first) yield return element;
  3.     foreach (TSource element in second) yield return element;
  4. }
复制代码
当两个序列是简单的枚举，如C＃中的迭代器生成的，这种过程会执行的很好。但是如果应用程序代码具有如下代码呢？
  1. first.Concat(second.Concat(third.Concat(fourth)));
复制代码
每次我们从迭代器中退出时，则会返回到枚举器的MoveNext方法。这意味着如果你从另一个迭代器中枚举产生一个元素，则会返回两个MoveNext方法，并移动到下一个需要调用这两个MoveNext方法的元素。你调用的枚举器越多，操作所需的时间越长，特别是这些操作中的每一个都涉及多个接口调用（MoveNext和Current）。这意味着连接多个枚举会以指数方式增长，而不是呈线性增长。PR dotnet / corefx＃6131修正了这个问题，在下面的例子中，区别是显而易见的：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> zeroToTen = Enumerable.Range(0, 10);
  10.         IEnumerable<int> result = zeroToTen;
  11.         for (int i = 0; i < 10_000; i++)
  12.         {
  13.             result = result.Concat(zeroToTen);
  14.         }

  16.         var sw = Stopwatch.StartNew();
  17.         foreach (int i in result) { }
  18.         Console.WriteLine(sw.Elapsed);
  19.     }
  20. }
复制代码
在个人计算机上，.NET 4.7需要大约4.12秒。但在.NET Core 2.0中，这只需要约0.14秒，提高了30倍。
通过消除多个运算器同时使用时的消耗，运算器也得到了大大的提升。例如下面的例子：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> tenMillionToZero = Enumerable.Range(0, 10_000_000).Reverse();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             int fifth = tenMillionToZero.OrderBy(i => i).Skip(4).First();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在这里，我们创建一个可以从10,000,000下降到0的数字，然后再等待一会来排序它们上升，跳过排序结果中的前4个元素，并抓住第五个。在个人计算机上的NET 4.7中得到如下输出：
  1. 00：00：01.3879042
  2. 00：00：01.3438509
  3. 00：00：01.4141820
  4. 00：00：01.4248908
  5. 00：00：01.3548279
复制代码
而使用.NET Core 2.0，会得到如下输出：
  1. 00：00：00.1776617
  2. 00：00：00.1787467
  3. 00：00：00.1754809
  4. 00：00：00.1765863
  5. 00：00：00.1735489
复制代码
这是一个巨大的改进（&#12316;8x），避免了大部分的开销。

类似地，来自justinvp的 PR dotnet / corefx＃3429对常用的ToList方法添加了优化，为已知长度的源，提供了优化的路径，并且通过像Select这样的操作器来管理。在以下简单测试中，这种影响是显而易见的：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> tenMillionToZero = Enumerable.Range(0, 10_000_000).Reverse();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             int fifth = tenMillionToZero.OrderBy(i => i).Skip(4).First();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在.NET 4.7中，会得到如下结果：
  1. 00：00：00.1308687
  2. 00：00：00.1228546
  3. 00：00：00.1268445
  4. 00：00：00.1247647
  5. 00：00：00.1503511
复制代码
而在.NET Core 2.0中，得到如下结果：
  1. 00：00：00.0386857
  2. 00：00：00.0337234
  3. 00：00：00.0346344
  4. 00：00：00.0345419
  5. 00：00：00.0355355
复制代码
显示吞吐量增加约4倍。
在其他情况下，性能优势来自于简化实施，以避免开销，例如减少分配，避免委托分配，避免接口调用，最小化字段读取和写入，避免拷贝等。例如，jamesqo为PR dotnet / corefx＃11208做出的贡献，大大地减少了Enumerable.ToArray涉及的开销。请看下面的例子：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         IEnumerable<int> zeroToTenMillion = Enumerable.Range(0, 10_000_000).ToArray();
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             zeroToTenMillion.Select(i => i).ToList();
  14.             Console.WriteLine(sw.Elapsed);
  15.         }
  16.     }
  17. }
复制代码
在.NET 4.7中，会得到如下的结果：
  1. Elapsed=00:00:01.0548794 Gen0=2 Gen1=2 Gen2=2
  2. Elapsed=00:00:01.1147146 Gen0=2 Gen1=2 Gen2=2
  3. Elapsed=00:00:01.0709146 Gen0=2 Gen1=2 Gen2=2
  4. Elapsed=00:00:01.0706030 Gen0=2 Gen1=2 Gen2=2
  5. Elapsed=00:00:01.0620943 Gen0=2 Gen1=2 Gen2=2
复制代码

而.NET Core 2.0的结果如下：
  1. Elapsed=00:00:00.1716550 Gen0=1 Gen1=1 Gen2=1
  2. Elapsed=00:00:00.1720829 Gen0=1 Gen1=1 Gen2=1
  3. Elapsed=00:00:00.1717145 Gen0=1 Gen1=1 Gen2=1
  4. Elapsed=00:00:00.1713335 Gen0=1 Gen1=1 Gen2=1
  5. Elapsed=00:00:00.1705285 Gen0=1 Gen1=1 Gen2=1
复制代码
这个例子中提高了6倍，但是垃圾收集却只有一半。
LINQ有一百多个运算器，本文只提到了几个，其它的很多也都有所改进。

压缩
前面所展示的集合和LINQ的例子都是处理内存中的数据，当然还有许多其他形式的数据处理，包括大量CPU计算和逻辑判断，这些运算也在得到提升。

一个关键的例子是压缩，例如使用DeflateStream，性能方面也有一些重大的性能改进。例如，在.NET 4.7中，zlib（本地压缩库）用于压缩数据，但是相对未优化的托管实现了用于解压缩的数据; PR dotnet / corefx＃2906添加了.NET Core支持，以便使用zlib进行解压缩。来自bjjones的 PR dotnet / corefx＃5674使用英特尔生产的zlib这个更优化的版本。这些结合产生了非常棒的效果。下面的例子，创建一个大量的数据：
  1. using System;
  2. using System.IO;
  3. using System.IO.Compression;
  4. using System.Diagnostics;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         // Create some fairly compressible data
  10.         byte[] raw = new byte[100 * 1024 * 1024];
  11.         for (int i = 0; i < raw.Length; i++) raw[i] = (byte)i;
  12.         var sw = Stopwatch.StartNew();

  14.         // Compress it
  15.         var compressed = new MemoryStream();
  16.         using (DeflateStream ds = new DeflateStream(compressed, CompressionMode.Compress, true))
  17.         {
  18.             ds.Write(raw, 0, raw.Length);
  19.         }
  20.         compressed.Position = 0;

  22.         // Decompress it
  23.         var decompressed = new MemoryStream();
  24.         using (DeflateStream ds = new DeflateStream(compressed, CompressionMode.Decompress))
  25.         {
  26.             ds.CopyTo(decompressed);
  27.         }
  28.         decompressed.Position = 0;

  30.         Console.WriteLine(sw.Elapsed);
  31.     }
  32. }
复制代码
在.NET 4.7中，这一个压缩/解压缩操作，会得到如下结果：
00：00：00.7977190
而使用.NET Core 2.0，会得到如下结果：
00：00：00.1926701

加密
.NET应用程序中另一个常见的计算源是使用加密操作，在这方面.NET Core也有改进。例如，在.NET 4.7中，SHA256.Create返回在管理代码中实现的SHA256类型，而管理代码可以运行得非常快，但是对于运算量非常大的计算，这仍然难以与原始吞吐量和编译器优化竞争。相反，对于.NET Core 2.0，SHA256.Create返回基于底层操作系统的实现，例如在Windows上使用CNG或在Unix上使用OpenSSL。从下面这个简单的例子可以看出，它散列着一个100MB的字节数组：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Security.Cryptography;

  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         byte[] raw = new byte[100 * 1024 * 1024];
  10.         for (int i = 0; i < raw.Length; i++) raw[i] = (byte)i;

  12.         using (var sha = SHA256.Create())
  13.         {
  14.             var sw = Stopwatch.StartNew();
  15.             sha.ComputeHash(raw);
  16.             Console.WriteLine(sw.Elapsed);
  17.         }
  18.     }
  19. }
复制代码
在.NET 4.7中，会得到：
00：00：00.7576808
而使用.NET Core 2.0，会得到：
00：00：00.4032290
零代码更改的一个很好提升。

数学运算
数学运算也是一个很大的计算量，特别是处理大量数据时。通过像dotnet / corefx＃2182这样的PR ，axelheer对BigInteger的各种操作做了一些实质的改进。请考虑以下示例：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Numerics;

  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         var rand = new Random(42);
  10.         BigInteger a = Create(rand, 8192);
  11.         BigInteger b = Create(rand, 8192);
  12.         BigInteger c = Create(rand, 8192);

  14.         var sw = Stopwatch.StartNew();
  15.         BigInteger.ModPow(a, b, c);
  16.         Console.WriteLine(sw.Elapsed);
  17.     }

  19.     private static BigInteger Create(Random rand, int bits)
  20.     {
  21.         var value = new byte[(bits + 7) / 8 + 1];
  22.         rand.NextBytes(value);
  23.         value[value.Length - 1] = 0;
  24.         return new BigInteger(value);
  25.     }
  26. }
复制代码
在.NET 4.7中，会得到以下输出结果：
00：00：05.6024158
.NET Core 2.0上的相同代码会得到输出结果如下：
00：00：01.2707089
这是开发人员只关注.NET的某个特定领域的一个很好的例子，开发人员使得这种改进更好的满足了自己的需求，同时也满足了可能会用到这方面功能的其他开发人员的需求。
一些核心的整型类型的数学运算也得到了改进。例如：
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     private static long a = 99, b = 10, div, rem;

  7.     public static void Main()
  8.     {
  9.         var sw = Stopwatch.StartNew();
  10.         for (int i = 0; i < 100_000_000; i++)
  11.         {
  12.             div = Math.DivRem(a, b, out rem);
  13.         }
  14.         Console.WriteLine(sw.Elapsed);
  15.     }
  16. }
复制代码
PR dotnet / coreclr＃8125用更快的实现取代了DivRem，在.NET 4.7中会得到的如下结果：
00：00：01.4143100
并在.NET Core 2.0上得到如下结果：
00：00：00.7469733
吞吐量提高约2倍。

序列化
二进制序列化是.NET的另一个领域。BinaryFormatter最初并不是.NET Core中的一个组件，但是它包含在.NET Core 2.0中。该组件在性能方面有比较巧妙的修复。例如，PR dotnet / corefx＃17949是一种单行修复，可以增加允许增长的最大大小的特定数组，但是这一变化可能对吞吐量产生重大影响，通过O（N）算法比以前的O（N ^ 2）算法要话费更长的操作时间。以下代码示例，明显的展示了这一点：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.IO;
  5. using System.Runtime.Serialization.Formatters.Binary;
  6. class Test
  7. {
  8.     static void Main()
  9.     {
  10.         var books = new List<Book>();
  11.         for (int i = 0; i < 1_000_000; i++)
  12.         {
  13.             string id = i.ToString();
  14.             books.Add(new Book { Name = id, Id = id });
  15.         }

  17.         var formatter = new BinaryFormatter();
  18.         var mem = new MemoryStream();
  19.         formatter.Serialize(mem, books);
  20.         mem.Position = 0;

  22.         var sw = Stopwatch.StartNew();
  23.         formatter.Deserialize(mem);
  24.         sw.Stop();

  26.         Console.WriteLine(sw.Elapsed.TotalSeconds);
  27.     }

  29.     [Serializable]
  30.     private class Book
  31.     {
  32.         public string Name;
  33.         public string Id;
  34.     }
  35. }
复制代码
在.NET 4.7中，代码输出如下结果：
76.677144
而在.NET Core 2.0中，会输出如下结果：
6.4044694
在这种情况下显示出了12倍的吞吐量提高。换句话说，它能够更有效地处理巨大的序列化输入。

文字处理
.NET应用程序中另一种很常见的计算形式就是处理文本，文字处理在堆栈的各个层次上都有大量的改进。
对于正则表达式，通常用于验证和解析输入文本中的数据。以下是使用Regex.IsMatch重复匹配电话号码的示例：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Text.RegularExpressions;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         var sw = new Stopwatch();
  9.         int gen0 = GC.CollectionCount(0);
  10.         sw.Start();

  12.         for (int i = 0; i < 10_000_000; i++)
  13.         {
  14.             Regex.IsMatch("555-867-5309", @"^\d{3}-\d{3}-\d{4}[        DISCUZ_CODE_39        ]quot;);
  15.         }

  17.         Console.WriteLine([        DISCUZ_CODE_39        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  18.     }
  19. }
复制代码
在个人计算机上，.NET 4.7会得到的如下结果：
  1. Elapsed=00:00:05.4367262 Gen0=820 Gen1=0 Gen2=0
复制代码
而使用.NET Core 2.0会得到如下结果：
  1. Elapsed=00:00:04.0231373 Gen0=248
复制代码
由于PR dotnet / corefx＃231的变化很小，这些修改有助于缓存一部分数据，因此吞吐量提高了25％，分配/垃圾收集减少了70％。

文本处理的另一个例子是各种形式的编码和解码，例如通过WebUtility.UrlDecode进行URL解码。在这种解码方法中，通常情况下输入不需要任何解码，但是如果输入经过了解码器，则输入仍然可以通过。感谢来自hughbe的 PR dotnet / corefx＃7671，这种情况已经被优化了。例如下面这段程序：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         var sw = new Stopwatch();
  9.         int gen0 = GC.CollectionCount(0);
  10.         sw.Start();

  12.         for (int i = 0; i < 10_000_000; i++)
  13.         {
  14.             WebUtility.UrlDecode("abcdefghijklmnopqrstuvwxyz");
  15.         }

  17.         Console.WriteLine([        DISCUZ_CODE_42        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  18.     }
  19. }
复制代码
在.NET 4.7中，会得到以下输出：
  1. Elapsed=00:00:01.6742583 Gen0=648
复制代码
而在.NET Core 2.0中，输出如下：
  1. Elapsed=00:00:01.2255288 Gen0=133
复制代码
其他形式的编码和解码也得到了改进。例如，dotnet / coreclr＃10124优化了使用一些内置Encoding -derived类型的循环。例如下面的示例：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Linq;
  4. using System.Text;
  5. public class Test
  6. {
  7.     public static void Main()
  8.     {
  9.         string s = new string(Enumerable.Range(0, 1024).Select(i => (char)('a' + i)).ToArray());
  10.         while (true)
  11.         {
  12.             var sw = Stopwatch.StartNew();
  13.             for (int i = 0; i < 1_000_000; i++)
  14.             {
  15.                 byte[] data = Encoding.UTF8.GetBytes(s);
  16.             }
  17.             Console.WriteLine(sw.Elapsed);
  18.         }
  19.     }
  20. }
复制代码
在.NET 4.7中得到以下输出，如：
  1. 00：00：02.4028829
  2. 00：00：02.3743152
  3. 00：00：02.3401392
  4. 00：00：02.4024785
  5. 00：00：02.3550876
复制代码
而.NET Core 2.0等到如下输出：
  1. 00：00：01.6133550
  2. 00：00：01.5915718
  3. 00：00：01.5759625
  4. 00：00：01.6070851
  5. 00：00：01.6070767
复制代码
这些改进也适用于字符串和其它类型之间转换，例如.NET中生成Parse和ToString方法。使用枚举来表示各种状态是相当普遍的，例如使用Enum.Parse将字符串解析为相应的枚举。PR dotnet / coreclr＃2933改善了这一点。请查看以下的代码：
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     public static void Main()
  6.     {
  7.         while (true)
  8.         {
  9.             var sw = new Stopwatch();
  10.             int gen0 = GC.CollectionCount(0);
  11.             sw.Start();

  13.             for (int i = 0; i < 2_000_000; i++)
  14.             {
  15.                 Enum.Parse(typeof(Colors), "Red, Orange, Yellow, Green, Blue");
  16.             }

  18.             Console.WriteLine([        DISCUZ_CODE_48        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  19.         }
  20.     }

  22.     [Flags]
  23.     private enum Colors
  24.     {
  25.         Red = 0x1,
  26.         Orange = 0x2,
  27.         Yellow = 0x4,
  28.         Green = 0x8,
  29.         Blue = 0x10
  30.     }
  31. }
复制代码
在.NET 4.7中，会得到的以下结果：
  1. Elapsed=00:00:00.9529354 Gen0=293
  2. Elapsed=00:00:00.9422960 Gen0=294
  3. Elapsed=00:00:00.9419024 Gen0=294
  4. Elapsed=00:00:00.9417014 Gen0=294
  5. Elapsed=00:00:00.9514724 Gen0=293
复制代码
在.NET Core 2.0上，会得到以下结果：
  1. Elapsed=00:00:00.6448327 Gen0=11
  2. Elapsed=00:00:00.6438907 Gen0=11
  3. Elapsed=00:00:00.6285656 Gen0=12
  4. Elapsed=00:00:00.6286561 Gen0=11
  5. Elapsed=00:00:00.6294286 Gen0=12
复制代码
不但吞吐量提高了约33％，而且分配和相关垃圾收集也减少了约25倍。

当然，在.NET应用程序中需要进行大量的自定义文本处理，除了使用像Regex / Encoding这样的内置类型和Parse和ToString这样的内置操作之外，文本操作通常都是直接构建在字符串之上，并且大量的改进已经引入到了操作on String之上。

例如，String.IndexOf很擅长于查找字符串中的字符。IndexOf在bnetyersmyth的dotnet / coreclr＃5327中得到改进，他们为String实现了一系列的性能改进。正如下面的例子：
  1. using System;
  2. using System.Diagnostics;
  3. public class Test
  4. {
  5.     public static void Main()
  6.     {
  7.         var dt = DateTime.Now;
  8.         while (true)
  9.         {
  10.             var sw = new Stopwatch();
  11.             int gen0 = GC.CollectionCount(0);
  12.             sw.Start();

  14.             for (int i = 0; i < 2_000_000; i++)
  15.             {
  16.                 dt.ToString("o");
  17.                 dt.ToString("r");
  18.             }

  20.             Console.WriteLine([        DISCUZ_CODE_51        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0}");
  21.         }
  22.     }
  23. }
复制代码
在.NET 4.7上，会得到如下结果：
  1. 00：00：05.9718129
  2. 00：00：05.9199793
  3. 00：00：06.0203108
  4. 00：00：05.9458049
  5. 00：00：05.9622262
复制代码
而在.NET Core 2.0中，会得到如下结果：
  1. 00：00：03.1283763
  2. 00：00：03.0925150
  3. 00：00：02.9778923
  4. 00：00：03.0782851
复制代码
吞吐量提高约2倍。
下面是比较字符串部分。这是一个使用String.StartsWith和序数比较的例子：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Linq;
  4. public class Test
  5. {
  6.     public static void Main()
  7.     {
  8.         string s = string.Concat(Enumerable.Repeat("a", 100)) + "b";
  9.         while (true)
  10.         {
  11.             var sw = Stopwatch.StartNew();
  12.             for (int i = 0; i < 100_000_000; i++)
  13.             {
  14.                 s.IndexOf('b');
  15.             }
  16.             Console.WriteLine(sw.Elapsed);
  17.         }
  18.     }
  19. }
复制代码
在.NET 4.7上会得到如下结果：
  1. 00：00：01.3097317
  2. 00：00：01.3072381
  3. 00：00：01.3045015
  4. 00：00：01.3068244
  5. 00：00：01.3210207
复制代码
.NET Core 2.0会得到如下结果：
  1. 00：00：00.6239002
  2. 00：00：00.6150021
  3. 00：00：00.6147173
  4. 00：00：00.6129136
  5. 00：00：00.6099822
复制代码
对String的改进，也让我们看到对于其它方面进行更多改进的可能性，这是非常有趣的。

文件系统
到目前为止，本文一直专注于内存中操纵数据的各种改进。但是.NET Core的许多更改都是&#8203;&#8203;关于I / O的。
下面从文件开始介绍。这是一个从文件中异步读取所有数据并将其写入另一个文件的示例：
  1. using System;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using System.Threading.Tasks;
  5. class Test
  6. {
  7.     static void Main() => MainAsync().GetAwaiter().GetResult();
  8.     static async Task MainAsync()
  9.     {
  10.         string inputPath = Path.GetTempFileName(), outputPath = Path.GetTempFileName();
  11.         byte[] data = new byte[50_000_000];
  12.         new Random().NextBytes(data);
  13.         File.WriteAllBytes(inputPath, data);

  15.         var sw = new Stopwatch();
  16.         int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  17.         sw.Start();

  19.         for (int i = 0; i < 100; i++)
  20.         {
  21.             using (var input = new FileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, useAsync: true))
  22.             using (var output = new FileStream(outputPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x1000, useAsync: true))
  23.             {
  24.                 await input.CopyToAsync(output);
  25.             }
  26.         }

  28.         Console.WriteLine([        DISCUZ_CODE_57        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  29.     }
  30. }
复制代码
FileStream中的开销也在进一步减少，例如DOTNET / corefx＃11569增加了一个专门的CopyToAsync实现，dotnet/ corefx＃2929也改进了异步写入的处理，.NET 4.7会得到如下结果：
  1. Elapsed=00:00:09.4070345 Gen0=14 Gen1=7 Gen2=1
复制代码
.NET Core 2.0会得到如下结果：
  1. Elapsed=00:00:06.4286604 Gen0=4 Gen1=1 Gen2=1
复制代码


网络
网络是值得关注的部分，这部分也将取得很大的改进。目前正在付出很大的努力来优化和调整低等级的网络堆栈，以便高效地构建更高级别的组件。
这种改变带来的一个很大的影响是PR dotnet / corefx＃15141。SocketAsyncEventArgs是Socket上大量异步操作的核心，它支持同步完成模型，因此异步操作实际完成了同步操作，这样避免了异步操作的分配消耗。但是，.NET 4.7中的同步操作运算是失败的， PR修复了上述的实现问题，允许在socket上进行所有异步操作的同步完成。这样的提升在以下代码中变现的非常明显：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. class Test
  8. {
  9.     static void Main()
  10.     {
  11.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  12.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  13.         {
  14.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  15.             listener.Listen(1);

  17.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  18.             using (Socket server = listener.Accept())
  19.             {
  20.                 connectTask.Wait();

  22.                 using (var clientAre = new AutoResetEvent(false))
  23.                 using (var clientSaea = new SocketAsyncEventArgs())
  24.                 using (var serverAre = new AutoResetEvent(false))
  25.                 using (var serverSaea = new SocketAsyncEventArgs())
  26.                 {
  27.                     byte[] sendBuffer = new byte[1000];
  28.                     clientSaea.SetBuffer(sendBuffer, 0, sendBuffer.Length);
  29.                     clientSaea.Completed += delegate { clientAre.Set(); };

  31.                     byte[] receiveBuffer = new byte[1000];
  32.                     serverSaea.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
  33.                     serverSaea.Completed += delegate { serverAre.Set(); };

  35.                     var sw = new Stopwatch();
  36.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  37.                     sw.Start();

  39.                     for (int i = 0; i < 1_000_000; i++)
  40.                     {
  41.                         if (client.SendAsync(clientSaea)) clientAre.WaitOne();
  42.                         if (clientSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);

  44.                         if (server.ReceiveAsync(serverSaea)) serverAre.WaitOne();
  45.                         if (serverSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);
  46.                     }

  48.                     Console.WriteLine([        DISCUZ_CODE_60        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }
复制代码
该程序创建两个连接的socket，然后向socket写入1000次，并且在案例中使用异步方法接收，但绝大多数操作将同步完成。在.NET 4.7中会得到如下结果：

在.NET Core 2.0中，大多数操作能够同步完成，得到如下结果：
Elapsed=00:00:05.6197060 Gen0=0 Gen1=0 Gen2=0
不仅仅是直接使用socket来实现组件的这种改进，而且还通过更高级别的组件来间接使用socket，其他PR的结果是更高级别组件（如NetworkStream）的额外性能提升。例如，PR dotnet / corefx＃16502在SocketAsyncEventArgs上重新实现了基于Socket的SendAsync和ReceiveAsync操作，并且允许它们在NetworkStream中使用。Read / WriteAsync和PR dotnet / corefx＃12664添加了一个专门的CopyToAsync重写，以便更有效地从NetworkStream读取数据并将其复制到其他流中。这些变化对NetworkStream吞吐量和分配有非常大的影响。看看下面这个例子：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. class Test
  8. {
  9.     static void Main()
  10.     {
  11.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  12.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  13.         {
  14.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  15.             listener.Listen(1);

  17.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  18.             using (Socket server = listener.Accept())
  19.             {
  20.                 connectTask.Wait();

  22.                 using (var clientAre = new AutoResetEvent(false))
  23.                 using (var clientSaea = new SocketAsyncEventArgs())
  24.                 using (var serverAre = new AutoResetEvent(false))
  25.                 using (var serverSaea = new SocketAsyncEventArgs())
  26.                 {
  27.                     byte[] sendBuffer = new byte[1000];
  28.                     clientSaea.SetBuffer(sendBuffer, 0, sendBuffer.Length);
  29.                     clientSaea.Completed += delegate { clientAre.Set(); };

  31.                     byte[] receiveBuffer = new byte[1000];
  32.                     serverSaea.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
  33.                     serverSaea.Completed += delegate { serverAre.Set(); };

  35.                     var sw = new Stopwatch();
  36.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  37.                     sw.Start();

  39.                     for (int i = 0; i < 1_000_000; i++)
  40.                     {
  41.                         if (client.SendAsync(clientSaea)) clientAre.WaitOne();
  42.                         if (clientSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);

  44.                         if (server.ReceiveAsync(serverSaea)) serverAre.WaitOne();
  45.                         if (serverSaea.SocketError != SocketError.Success) throw new SocketException((int)clientSaea.SocketError);
  46.                     }

  48.                     Console.WriteLine([        DISCUZ_CODE_61        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }
复制代码
与之前的Socket一样，下面我们创建两个连接的socket，然后把它们包含在NetworkStream中。在其中一个流中，我们将1K数据写入一百万次，而另一个流则通过CopyToAsync操作读出所有数据。在.NET 4.7中，会得到如下输出：
  1. Elapsed = 00：00：24.7827947 Gen0 = 220 Gen1 = 3 Gen2 = 0
复制代码
而在.NET Core 2.0中，时间减少了5倍，垃圾回收有效地减少到零：
  1. Elapsed=00:00:05.6456073 Gen0=74 Gen1=0 Gen2=0
复制代码
其它网络相关组件也将得到进一步优化。例如SslStream通常将围绕在NetworkStream中，以便向连接中添加SSL。下面的示例将看到这种影响，这个示例将在NetworkStream之上添加SslStream的用法：
  1. using System;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  8. class Test
  9. {
  10.     static void Main() => MainAsync().GetAwaiter().GetResult();
  11.     static async Task MainAsync()
  12.     {
  13.         using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  14.         using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
  15.         {
  16.             listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
  17.             listener.Listen(1);

  19.             Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
  20.             using (Socket server = listener.Accept())
  21.             {
  22.                 await connectTask;

  24.                 using (var serverStream = new NetworkStream(server))
  25.                 using (var clientStream = new NetworkStream(client))
  26.                 {
  27.                     Task serverCopyAll = serverStream.CopyToAsync(Stream.Null);

  29.                     byte[] data = new byte[1024];
  30.                     new Random().NextBytes(data);

  32.                     var sw = new Stopwatch();
  33.                     int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  34.                     sw.Start();

  36.                     for (int i = 0; i < 1_000_000; i++)
  37.                     {
  38.                         await clientStream.WriteAsync(data, 0, data.Length);
  39.                     }
  40.                     client.Shutdown(SocketShutdown.Send);
  41.                     serverCopyAll.Wait();
  42.                     sw.Stop();

  44.                     Console.WriteLine([        DISCUZ_CODE_64        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  45.                 }
  46.             }
  47.         }
  48.     }
  49. }
复制代码
在.NET 4.7中，会得到如下结果：
  1. Elapsed=00:00:21.1171962 Gen0=470 Gen1=3 Gen2=1
复制代码
.NET Core 2.0包含了诸如dotnet / corefx＃12935和dotnet / corefx＃13274等PR的改进，这两者都将大大减少了使用SslStream所涉及的分配。在.NET Core 2.0上运行相同的代码时，会得到如下结果：
  1. Elapsed=00:00:05.6456073 Gen0=74 Gen1=0 Gen2=0
复制代码
85％的垃圾收集已被删除！

并发
对于并发和并行性相关的原始化和基础部分，也得到了许多改进。
这里的一个关键点是ThreadPool，它是执行许多.NET应用程序的核心。例如，PR dotnet / coreclr＃3157减少了QueueUserWorkItem中涉及的某些对象的大小，PR dotnet / coreclr＃9234使用了ConcurrentQueue <T>重写来替换ThreadPool的全局队列，其中会用到较少的同步和分配。从以下的示例中，会看到最终结果：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  4. class Test
  5. {
  6.     static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             int remaining = 20_000_000;
  11.             var mres = new ManualResetEventSlim();
  12.             WaitCallback wc = null;
  13.             wc = delegate
  14.             {
  15.                 if (Interlocked.Decrement(ref remaining) <= 0) mres.Set();
  16.                 else ThreadPool.QueueUserWorkItem(wc);
  17.             };

  19.             var sw = new Stopwatch();
  20.             int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
  21.             sw.Start();

  23.             for (int i = 0; i < Environment.ProcessorCount; i++) ThreadPool.QueueUserWorkItem(wc);
  24.             mres.Wait();

  26.             Console.WriteLine([        DISCUZ_CODE_67        ]quot;Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
  27.         }
  28.     }
  29. }
复制代码
在.NET 4.7中，会等到如下结果：
  1. Elapsed=00:00:03.6263995 Gen0=225 Gen1=51 Gen2=16
  2. Elapsed=00:00:03.6304345 Gen0=231 Gen1=62 Gen2=17
  3. Elapsed=00:00:03.6142323 Gen0=225 Gen1=53 Gen2=16
  4. Elapsed=00:00:03.6565384 Gen0=232 Gen1=62 Gen2=16
  5. Elapsed=00:00:03.5999892 Gen0=228 Gen1=62 Gen2=17
复制代码
而在.NET Core 2.0中，会得到如下结果：
  1. Elapsed=00:00:02.1797508 Gen0=153 Gen1=0 Gen2=0
  2. Elapsed=00:00:02.1188833 Gen0=154 Gen1=0 Gen2=0
  3. Elapsed=00:00:02.1000003 Gen0=153 Gen1=0 Gen2=0
  4. Elapsed=00:00:02.1024852 Gen0=153 Gen1=0 Gen2=0
  5. Elapsed=00:00:02.1044461 Gen0=154 Gen1=1 Gen2=0
复制代码
这是一个巨大的吞吐量的改善，并且这样一个核心组件的垃圾量也将大幅减少。
同步原语也在.NET Core中得到提升。例如，低级并发代码通常使用SpinLock来尝试避免分配锁定对象或最小化竞争锁所花费的时间。PR dotnet / coreclr＃6952改进了失败的快速路径，以下测试会得到显而易见的结果：
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  4. class Test
  5. {
  6.     static void Main()
  7.     {
  8.         while (true)
  9.         {
  10.             bool taken = false;
  11.             var sl = new SpinLock(false);
  12.             sl.Enter(ref taken);

  14.             var sw = Stopwatch.StartNew();
  15.             for (int i = 0; i < 100_000_000; i++)
  16.             {
  17.                 taken = false;
  18.                 sl.TryEnter(0, ref taken);
  19.             }
  20.             Console.WriteLine(sw.Elapsed);
  21.         }
  22.     }
  23. }
复制代码
在.NET 4.7中，会得到如下结果：
  1. 00:00:02.3276463
  2. 00:00:02.3174042
  3. 00:00:02.3022212
  4. 00:00:02.3015542
  5. 00:00:02.2974777
复制代码
而在.NET Core 2.0中，会得到如下结果：
  1. 00：00：00.3915327
  2. 00：00：00.3953084
  3. 00：00：00.3875121
  4. 00：00：00.3980009
  5. 00：00：00.3886977
复制代码
吞吐量的这种差异可能会对运行这种锁的热路径产生很大的影响。
这只是众多例子中的一个。另一个例子围绕着Lazy<T>，它被PR dotnet / coreclr＃8963用manofstick重写，以便提高访问初始化过的Lazy <T>的效率。这样的提升效果从下面的示例中清晰可见：
  1. using System;
  2. using System.Diagnostics;
  3. class Test
  4. {
  5.     static int s_result;

  7.     static void Main()
  8.     {
  9.         while (true)
  10.         {
  11.             var lazy = new Lazy<int>(() => 42);
  12.             s_result = lazy.Value;

  14.             var sw = Stopwatch.StartNew();
  15.             for (int i = 0; i < 1_000_000_000; i++)
  16.             {
  17.                 s_result = lazy.Value;
  18.             }
  19.             Console.WriteLine(sw.Elapsed);
  20.         }
  21.     }
  22. }
复制代码
在.NET 4.7中，会得到的结果如下：
  1. 00：00：02.6769712
  2. 00：00：02.6789140
  3. 00：00：02.6535493
  4. 00：00：02.6911146
  5. 00：00：02.7253927
复制代码
而在.NET Core 2.0中，会得到的结果如下：
  1. 00：00：00.5278348
  2. 00：00：00.5594950
  3. 00：00：00.5458245
  4. 00：00：00.5381743
  5. 00：00：00.5502970
复制代码
吞吐量增加约5倍。

下一步是什么
本文只涉及了部分.NET Core的性能改进。在dotnet / corefx和dotnet / coreclr repos 中的pull请求中搜索“perf”或“performance”，你会发现接近一千个合并的PR改进。其中一些是比较大的同时也很有影响力的改进，而另一些则主要减少了库和运行时的消耗，这些变化一起起作用，保证了能够在.NET Core上更快的运行应用程序。展望未来，性能将成为关注的重点，无论是以性能改进为目标的API还是现有库的性能的改进。

欢迎大家深入了解.NET Core代码库，以便找到影响自己的应用程序和库的瓶颈，并提交PR来修复它们。如果你的问题得到修复，也请将修复程序分享给所有需要的人。
转载请注明出自：葡萄城控件
   
关于葡萄城：全球最大的控件提供商，世界领先的企业应用定制工具、企业报表和商业智能解决方案提供商，为超过75%的全球财富500强企业提供服务。

0 个回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
产品与服务
活字格低代码平台
Wyn 商业智能软件
SpreadJS纯前端表格控件
技术服务体系
技术博客
低代码技术
客户与案例
典型客户
成功案例
用户访谈
合作与生态
合作伙伴网络
葡萄城市场
葡萄城与国产化
活字格用友客开工具
品牌活动
葡萄城公开课
品牌战略发布会
赋能开发者高峰论坛
企业级低代码发展研讨会
企业级低代码应用大赛
表格技术研讨会
了解葡萄城
葡萄城简介
愿景使命
研发与创新
荣誉奖项
加入我们
联系方式
联系我们
400-657-6008

葡萄城社区二维码

关注“葡萄城社区”

赋能开发者

西安葡萄城软件有限公司
专业的软件开发技术和低代码平台提供商

陕ICP备2020018819号  |   陕公网安备：61019002000258  |   隐私政策  |   网站地图  

邮箱： info.xa@grapecity.com  |  © 2024 葡萄城软件，保留所有权利

Archiver| 手机版| 小黑屋|

返回顶部