数组（结构类型）的 Where 是否已优化以避免不必要地复制结构值？

Question

出于内存性能的原因，我有一个结构数组，因为项目的数量很大，并且项目会定期被扔掉，因此会破坏 GC 堆。这不是我是否应该使用大型结构的问题；我已经确定 GC 垃圾处理会导致性能问题。我的问题是当我需要处理这个结构数组时，我应该避免使用 LINQ 吗？由于结构并不小，因此按值传递它是不明智的，而且我不知道 LINQ 代码生成器是否足够聪明以执行此操作。结构如下：

public struct ManufacturerValue
{
    public int ManufacturerID;
    public string Name;
    public string CustomSlug;
    public string Title;
    public string Description;
    public string Image;
    public string SearchFilters;
    public int TopZoneProduction;
    public int TopZoneTesting;
    public int ActiveProducts;
}

假设我们有一个包含这些值的数组，我想提取一个自定义 slug 的字典到制造商 ID。在我将其更改为结构之前，它是一个类，因此原始代码是使用简单的 LINQ 查询编写的：

ManufacturerValue[] = GetManufacturerValues();
var dict = values.Where(p => !string.IsNullOrEmpty(p.CustomSlug))
                 .ToDictionary(p => p.CustomSlug, p => p.ManufacturerID);

我担心的是我想了解 LINQ 将如何生成实际代码来构建这个字典。我的怀疑是，在内部，LINQ 代码最终会变成这样的幼稚实现：

var dict = new Dictionary<string, int>();
for (var i = 0; i < values.Length; i++) {
    var value = values[i];
    if (!string.IsNullOrEmpty(value.CustomSlug)) {
        dict.Add(value.CustomSlug, value.ManufacturerID);
    }
}

这会很糟糕，因为第三行将创建结构的本地副本，这会很慢，因为结构很大并且会破坏内存总线。除了 ID 和自定义 slug 之外，我们也不需要任何东西，因此它会在每次迭代中复制很多无用的信息。如果我自己高效地编写代码，我会这样写：

var dict = new Dictionary<string, int>();
for (var i = 0; i < values.Length; i++) {
    if (!string.IsNullOrEmpty(values[i].CustomSlug)) {
        dict.Add(values[i].CustomSlug, values[i].ManufacturerID);
    }
}

那么有谁知道代码生成器是否足够聪明，可以像第二个示例那样使用简单的数组索引，当生成器代码在结构数组上运行时，还是会实现更幼稚但更慢的第一个实现？

反编译此类代码以了解代码生成器实际上会为此做什么的最佳方法是什么？

更新

这些更改现已投入生产。事实证明，在重写代码和使用 Dot Memory profiler 来确定正在使用多少内存以及在哪里使用的过程中，我在 Phalanger PHP 编译器代码中发现了两个内存泄漏。这是我们的进程使用的内存量不断增长的原因之一，其中一个内存泄漏非常严重，实际上是由 Microsoft Async 代码引起的（可能值得写一篇博客或堆栈溢出问题/答案，以帮助其他人避免它）。

无论如何，一旦我发现了内存泄漏并修复了它们，我就在没有任何内存优化将类转换为结构的情况下推送了该代码，奇怪的是，这实际上导致 GC 更加颠簸。根据性能计数器，我看到 GC 将使用高达 27% 的 CPU 的时间段。由于内存泄漏，这些大块很可能以前没有得到 GC，所以它们只是闲逛。修复代码后，GC 的行为开始变得比以前更差。

最后，我们使用这个问题中的反馈完成了将这些类转换为结构的代码，现在我们在峰值时的总内存使用量约为原来的 50%，当服务器上的负载下降时，它会迅速下降更重要的是，我们看到只有 0.05% 的 CPU 用于 GC，即使这样。因此，如果有人想知道这些更改是否会对现实世界产生影响，他们确实可以，特别是如果您的对象通常会停留一段时间，因此会卡在第二代堆中，然后需要被扔掉并收集垃圾.

Answer 1

反编译此类代码以了解代码生成器实际上会为此做什么的最佳方法是什么？

无需反编译代码。所有 LINQ to Objects 方法的实现都可以在Reference Source 看到。

关于您的具体问题。使用 LINQ（以及通常基于 IEnumerable<T> 和 Func<T, ..> 的方法）时，您可以期待大量的 struct 复制操作。

例如，IEnumerator<T> 的当前元素通过属性Current 访问，定义如下

T Current { get; }

因此访问至少涉及一份副本。但是枚举器实现通常在 MoveNext 方法期间将当前元素存储到一个字段中，所以我想说你可以安全地计算 2 次复制操作。

当然，每个Func<T, ...> 都会导致另一个副本，因为T 是输入参数。

因此，一般而言，在这种情况下您应该避免使用 LINQ。

或者，您可以使用通过数组和索引模拟引用的老派技术。所以不要这样：

var dict = values
    .Where(p => !string.IsNullOrEmpty(p.CustomSlug))
    .ToDictionary(p => p.CustomSlug, p => p.ManufacturerID);

你可以使用这个来避免struct复制：

var dict = Enumerable.Range(0, values.Length)
    .Where(i => !string.IsNullOrEmpty(values[i].CustomSlug))
    .ToDictionary(i => values[i].CustomSlug, i => values[i].ManufacturerID);

更新：由于似乎对这个主题很感兴趣，我将为您提供最后一种技术的变体，它可以让您的生活更轻松，同时避免过多的struct 复制。

假设您的 ManufacturerValue 是一个类，并且您使用了很多 LINQ 查询，例如示例中的查询。然后你切换到struct。

您还可以像这样创建包装器struct 和辅助扩展方法

public struct ManufacturerValue
{
    public int ManufacturerID;
    public string Name;
    public string CustomSlug;
    public string Title;
    public string Description;
    public string Image;
    public string SearchFilters;
    public int TopZoneProduction;
    public int TopZoneTesting;
    public int ActiveProducts;
}

public struct ManufacturerValueRef
{
    public readonly ManufacturerValue[] Source;
    public readonly int Index;
    public ManufacturerValueRef(ManufacturerValue[] source, int index) { Source = source; Index = index; }
    public int ManufacturerID => Source[Index].ManufacturerID;
    public string Name => Source[Index].Name;
    public string CustomSlug => Source[Index].CustomSlug;
    public string Title => Source[Index].Title;
    public string Description => Source[Index].Description;
    public string Image => Source[Index].Image;
    public string SearchFilters => Source[Index].SearchFilters;
    public int TopZoneProduction => Source[Index].TopZoneProduction;
    public int TopZoneTesting => Source[Index].TopZoneTesting;
    public int ActiveProducts => Source[Index].ActiveProducts;
}

public static partial class Utils
{
    public static IEnumerable<ManufacturerValueRef> AsRef(this ManufacturerValue[] values)
    {
        for (int i = 0; i < values.Length; i++)
            yield return new ManufacturerValueRef(values, i);
    }
}

这是额外的（一次性）工作，但具有以下好处：

(1) 它是一个struct，但具有固定大小，因此与普通引用相比，复制开销可以忽略不计（一个额外的int）。
(2) 您可以扩展实际数据struct 大小而无需担心。
(3) LINQ 查询只需添加.AsRef()

示例：

var dict = values.AsRef()
    .Where(p => !string.IsNullOrEmpty(p.CustomSlug))
    .ToDictionary(p => p.CustomSlug, p => p.ManufacturerID);

Answer 2

结构是 [按值传递][1] - 所以我相当肯定，只是为您的 ToDictionary 使用委托的行为将导致两个副本，无论发生什么其他事情。

换句话说，考虑

.ToDictionary(p => p.CustomSlug, p => p.ManufacturerID);

相当于：

var key = GetKey(values[i]);
var value = GetValue(values[i]);

.ToDictionary(key, value);

这显然会创建结构的两个副本以传递给GetKey 和GetValue。

Answer 3

如果您需要稍微放松一下垃圾收集器，您可能需要在 app.config 文件中使用 gcServer 选项：

<configuration>
    <runtime>
        <gcServer enabled="true" />
    </runtime>
</configuration>

要查看基于您的 LINQ 代码生成的 IL 类型，LinqPad 是一个很棒的工具。

不幸的是，我对使用 LINQ 对结构枚举一无所知。我通常使用结构来保留少量的值类型。

也许放宽 GC 可以帮助您规避性能问题，并给课程另一个机会？我还有一个应用程序可以进行大量的对象创建和处理，其性能被 GC Frenzy 所拖累。使用 GCServer="true" 解决了这个问题，但使用的私有内存略有增加。

Answer 4

箭头：

p => !string.IsNullOrEmpty(p.CustomSlug)
p => p.CustomSlug
p => p.ManufacturerID

每个都编译成一个实际的方法，其中p 是该方法的值参数。然后这些方法以 Func 委托实例的形式传递给 Linq。由于它们是值参数，因此您的结构是按值传递的。

也许你可以使用：

ManufacturerValue[] values = GetManufacturerValues();
var dict = Enumerate.Range(0, values.Length)
  .Where(i => !string.IsNullOrEmpty(values[i].CustomSlug))
  .ToDictionary(i => values[i].CustomSlug, i => values[i].ManufacturerID);

这只是捕获每个 lambda 箭头（闭包）中的数组引用。

编辑：我没有看到 Ivan Stoev 的回答已经有这个建议。改为支持他的答案。

Answer 5

我已经在 1000 万个结构与大大小小的类上对 Linq 的 Where() 的性能进行了基准测试。

结构在所有情况下都更快。

代码：https://github.com/Erikvv/linq-large-struct-benchmark