概述：内存管理是软件开发的一个关键方面，可确保资源的有效利用、提高性能并防止内存泄漏。.NET Core 是一个跨平台框架，它引入了一个复杂的内存管理模型，该模型利用自动垃圾回收等功能来管理内存。本文探讨了 .NET Core 中内存管理的复杂性，并提供了实时用例和 C# 示例，以详细阐述每个概念。让我们踏上一段旅程，了解托管和非托管资源、垃圾回收器的工作原理、内存泄漏以及如何检测和预防它们。 了解托管资源与非托管资源在 .NET Core 中，内存分为托管资源和非托管资源。托管资源是 .NET 运行时可以直接控制的资源，而非托管资源则不在其权限范围内，通常是对系统资源的直接调用。问题陈述：访问

内存管理是软件开发的一个关键方面，可确保资源的有效利用、提高性能并防止内存泄漏。.NET Core 是一个跨平台框架，它引入了一个复杂的内存管理模型，该模型利用自动垃圾回收等功能来管理内存。本文探讨了 .NET Core 中内存管理的复杂性，并提供了实时用例和 C# 示例，以详细阐述每个概念。让我们踏上一段旅程，了解托管和非托管资源、垃圾回收器的工作原理、内存泄漏以及如何检测和预防它们。

了解托管资源与非托管资源

在 .NET Core 中，内存分为托管资源和非托管资源。托管资源是 .NET 运行时可以直接控制的资源，而非托管资源则不在其权限范围内，通常是对系统资源的直接调用。

问题陈述：访问文件系统

解决方案：用于托管资源System.IO

using System.IO;  
  
class FileManager {  
    public void ReadFile() {  
        // Managed resource: FileStream is managed by .NET runtime  
        using (FileStream fs = File.Open("file.txt", FileMode.Open)) {  
            byte[] b = new byte[1024];  
            UTF8Encoding temp = new UTF8Encoding(true);  
  
            while (fs.Read(b,0,b.Length) > 0) {  
                Console.WriteLine(temp.GetString(b));  
            }  
        }  
    }  
}

在上面的示例中，是一个托管资源，当它不再使用时，垃圾回收器 （GC） 会自动清理它，前提是我们在语句中使用它或显式调用 .FileStreamusingDispose()

问题陈述：与 Windows API 交互

解决方案：对非托管资源使用 P/Invoke

using System;  
using System.Runtime.InteropServices;  
  
class WindowsInterop {  
    [DllImport("user32.dll", CharSet = CharSet.Auto)]  
    public static extern IntPtr MessageBox(int hWnd, String text, String caption, uint type);  
  
    public void ShowMessage() {  
        // Unmanaged resource: A call to an external Windows function  
        MessageBox(0, "Hello, World!", "Message Box", 0);  
    }  
}  

此示例演示如何使用非托管资源，其中 from 直接调用，绕过 .NET 的内存管理。仔细管理这些资源以避免泄漏至关重要。MessageBoxuser32.dll

.NET Core 中的垃圾回收

.NET Core 的垃圾回收器 （GC） 是一个标记和扫描收集器，通过回收不再使用的对象占用的内存来优化内存使用率。

分代垃圾回收

.NET Core 中的对象分为三代（0、1 和 2），通过优先收集较年轻的对象（这些对象更有可能是短期的）来促进高效的内存管理。

实时用例：优化 Web 应用程序中的内存分配

class UserDataCache {  
    private Dictionary<Guid, string> _cache = new Dictionary<Guid, string>();  
  
    public void AddUserData(Guid userId, string data) {  
        _cache.Add(userId, data);  
        // Force a collection in Generation 0  
        GC.Collect(0);  
    }  
}

在这里，在将数据添加到缓存后在第 0 代中强制使用 GC 似乎是优化内存的一种方式，但由于潜在的性能影响，通常不建议这样做。最好让 GC 按其时间表运行。

.NET GC 是一个跟踪垃圾回收器。它监视应用程序的对象使用情况，以释放未使用的内存。

// GC will collect this object once it goes out of scope  
{  
  LargeObject large = new LargeObject();   
}

此处，LargeObject 有资格在范围结束后进行垃圾回收。GC 释放分配给它的内存。

代

GC 根据对象年龄将内存组织成几代：

• 第 0 代：最新对象
• 第 1 代：在 GC 中幸存下来
• 第 2 代：在多个 GC 中幸存下来

较高的世代比较低的世代收集频率较低。

对象的世代

GC 根据内存中的对象的年龄将其分为三代：

第 0 代

• 寿命短的最年轻的对象
• 频繁快速的垃圾回收
• 对象可以提升到第 1 代

第 1 代

• 使用寿命稍长的稍旧物体
• 减少垃圾回收频率
• 对象可以提升到第 2 代

第 2 代

• 寿命更长的最老对象
• 不频繁的垃圾回收
• 物品会一直留在这里，直到收集到为止

这种代际模型通过关注更有可能发现死物的区域，使 GC 更加高效。

GC 根

GC 使用 GC 根作为查找可访问对象的起点。无法从根部触及的物体被认为是死的，可以进行垃圾收集。

一些常见的 GC 根包括：

• 静态字段
• 局部变量
• 堆栈上的项目
• CPU 寄存器

在垃圾回收期间，任何可从根访问的对象都将被扫描并标记为活动对象。

垃圾回收模式

.NET Core 中有两种主要的 GC 模式：There are two main GC modes in .NET Core：

工作站 GC

针对响应能力进行了优化

• 在专用线程上运行
• 使用多个 GC 堆
• 低延迟，但内存使用率高

服务器气相色谱仪

针对吞吐量进行了优化

• 在多个专用线程上运行
• 单个 GC 堆
• 延迟更高，但内存使用率更低

GC 模式可以根据您的应用要求进行配置。

管理垃圾回收

作为开发人员，您可以对 GC 行为进行一些控制：

• GC.Collect()- 手动触发气相色谱循环
• GC.GetTotalMemory()- 检查分配的内存
• 配置生成阈值
• 配置 GC 模式

但通常允许 GC 自动管理内存。

真实世界的例子 ??

下面是一个可能导致高 GC 压力的低效内存使用示例：

// Loading large bitmap images   
// in a loop without disposing them  
  
foreach (var imageName in imageNames)   
{  
  
  var bitmap = new Bitmap(imageName)   
  {  
    // Process image  
  }   
  
}

这些对象不会被处理，因此它们会无限期地保留在内存中。Bitmap

改进后的代码正确处理位图：

foreach (var imageName in imageNames) {  
    
  using (var bitmap = new Bitmap(imageName)) {  
    // Process image  
  }  
  
}

现在，可以在每次循环迭代后对对象进行垃圾回收。Bitmap

自动内存管理

当其中一个世代填满时，GC 会在后台线程上自动运行：

static void Main() {  
  
  // Running this loop generates lots of temporary strings  
  for(int i=0; i<100000; i++) {  
    string s = i.ToString();   
  }  
  
  // GC will kick in automatically to clean up  
}

这种自动过程消除了开发人员的复杂内存管理。

垃圾回收统计

我们可以使用以下方法查看 GC 内存统计信息：GC.GetTotalMemory()

long memory1 = GC.GetTotalMemory(false);  
  
// do memory intensive work  
  
long memory2 = GC.GetTotalMemory(false);   
  
Console.WriteLine(memory2 - memory1); // GC memory difference

这有助于深入了解 GC 在程序执行期间的工作方式。

强制垃圾回收

我们可以通过调用以下命令强制垃圾回收：GC.Collect()

GC.Collect(); // forcibly clean up unused objects

但是，通常不建议这样做，因为它会中断正常的程序流。

减少垃圾回收

过于频繁的 GC 会影响性能。以下是一些优化提示：

• 重用对象而不是重构对象
• 避免大型对象分配
• 调用 Dispose on disposable objects
• 尽可能使用 Structs 而不是类

优化垃圾回收性能

虽然 .NET Core 中的垃圾回收会自动工作，但开发人员可以通过多种方式根据其特定工作负载优化 GC 性能。目标是最大程度地减少垃圾回收导致的暂停，同时控制内存使用量。

监控 GC 行为

第一步是监视 GC 当前在应用程序中的行为方式：

• 检查第 2 代堆大小是否较高 — 表明对象生存期管理不佳
• 监控 GC 堆分配率 — 内存分配速度
• 在 GC 中查看时间——收集时间的总百分比
• 检查 GC 暂停的频率和持续时间

可以使用分析工具（如 dotTrace 或 PerfView）收集此数据。

GC 配置选项

用于优化垃圾回收器性能的一些关键配置选项：

代数

堆分为几代，可以根据需要调整大小：

// Larger Gen 0 for short-lived objects  
gcServer: {  
   heapSize: 1GB  
   gen0size: 100MB // Default 256KB  
}

垃圾回收模式

根据应用程序类型选择 Workstation 或 Server GC。

并发 GC

启用第 2 代的后台垃圾回收。减少暂停，但占用更多内存。

GC 延迟模式

设置延迟选项，如交互式（低延迟）或低（低内存）

优化最佳实践

优化内存使用的一些编程最佳实践：

• 避免大型对象分配
• 及时处理物品
• 优化对象生存期
• 尽可能使用结构而不是类
• 减少对象依赖关系和引用

真实世界的例子

假设 Web 应用程序经常出现 2 秒的 GC 暂停，导致页面响应滞后。

经过分析，我们发现：

• 第 0 代中的大量短期对象
• 频繁使用完整 GC 来提升对象

一些优化选项：

• 增加 Gen 0 的大小以容纳更多生存期较短的对象
• 启用并发 GC 以避免完全阻塞 GC
• 减少对象分配并延长使用寿命

这可以显著减少 GC 停顿并提高响应能力。

检测和避免内存泄漏

.NET Core 中的内存泄漏仍可能发生，这主要是由于引用阻止 GC 回收内存。

问题陈述：订阅事件

解决方案：显式退订

public class EventPublisher {  
    public event EventHandler<EventArgs> RaiseCustomEvent;  
  
    public void DoSomething() {  
        // Trigger the event  
        OnRaiseCustomEvent(new EventArgs());  
    }  
  
    protected virtual void OnRaiseCustomEvent(EventArgs e) {  
        RaiseCustomEvent?.Invoke(this, e);  
    }  
}  
  
public class EventSubscriber {  
    private EventPublisher _publisher;  
  
    public EventSubscriber(EventPublisher publisher) {  
        _publisher = publisher;  
        _publisher.RaiseCustomEvent += HandleCustomEvent;  
    }  
  
    private void HandleCustomEvent(object sender, EventArgs e) {  
        // Event handling logic here  
    }  
  
    public void Unsubscribe() {  
        _publisher.RaiseCustomEvent -= HandleCustomEvent;  
    }  
}

在这种情况下，必须显式取消订阅 的事件以防止内存泄漏，因为发布者持有对订阅者的引用，从而阻止 GC 收集订阅者。EventSubscriberEventPublisher

用于内存分析的工具

.NET Core 提供了多个用于内存分析的工具，包括 Visual Studio 的诊断工具、dotMemory 和 CLI 工具。这些工具对于识别内存泄漏和了解内存使用模式非常宝贵。dotnet-trace

即使对内存管理技术有深入的了解，.NET Core 应用程序中仍可能出现问题。本节将探讨用于识别和诊断内存相关问题的工具和策略。

1. Visual Studio 诊断工具：Visual Studio 提供用于监视和分析内存使用情况的内置工具，包括“诊断工具”窗口和“性能探查器”。这些工具可以帮助识别内存泄漏、高内存消耗和低效内存使用。

示例：

1. 在 Visual Studio 中打开应用程序。
2. 启动调试 （F5） 以启动应用程序。
3. 打开“诊断工具”窗口（“调试”>“Windows >诊断工具”）。
4. 观察“内存使用情况”和“.NET 对象分配”图，以确定潜在问题。
5. 使用性能探查器（调试>性能探查器）对内存分配和垃圾回收进行更深入的分析。
6. dotMemory：dotMemory 是 JetBrains 推出的一款功能强大的第三方内存分析工具。它提供对内存使用情况、对象分配和垃圾回收的实时见解，从而更轻松地识别和解决内存问题。

示例：

1. 启动 dotMemory 并将其附加到正在运行的 .NET Core 应用程序。
2. 分析内存使用情况、对象分配和垃圾回收统计信息。
3. 使用内置分析工具来识别潜在的内存泄漏、高内存消耗和低效内存使用。
4. 根据分析结果应用内存优化策略。
5. 分析内存转储：内存转储提供应用程序内存状态的快照，这对于诊断与内存相关的问题非常宝贵。在 .NET Core 中，可以使用 dotnet-dump 命令行工具或附加调试器（如 Visual Studio 或 WinDbg）创建内存转储。

示例：

1. 使用任务管理器或命令 dotnet — list 标识 .NET Core 应用程序的进程 ID （PID）。
2. 使用命令 dotnet-dump collect -p <PID> 创建内存转储。
3. 使用 Visual Studio、WinDbg 或 dotMemory 等工具分析内存转储。

通过利用这些分析和诊断技术，可以更好地了解 .NET Core 应用程序的内存使用情况，识别潜在问题，并应用优化策略来提高性能和效率。继续练习和试验这些工具，你将成为诊断和解决 .NET Core 中内存相关问题的专家。

.NET Core 中的高级内存管理技术

除了基础知识之外，掌握 .NET Core 中的高级内存管理技术可以显著提高应用程序的性能和可靠性。让我们更深入地研究内存池、大型对象堆 （LOH） 注意事项以及使用 Span<T> 和 Memory<T> 更有效地管理内存等概念。

内存池

内存池是一种用于减少频繁分配和释放内存块的开销的技术，特别是对于 Web 服务器和数据库管理系统等高吞吐量应用程序。

问题陈述：减少高性能应用程序中的分配开销

解决方案：使用ArrayPool<T>

using System.Buffers;  
  
class HighPerformanceDataProcessor {  
    public void ProcessData() {  
        var buffer = ArrayPool<byte>.Shared.Rent(1024); // Rent a buffer of 1024 bytes  
  
        try {  
            // Process data here  
        }  
        finally {  
            ArrayPool<byte>.Shared.Return(buffer); // Return the buffer to the pool  
        }  
    }  
}

在本例中，用于租用和返回字节数组，在频繁分配和解除分配数组的情况下，显著降低了 GC 压力。ArrayPool<T>

大型对象堆 （LOH） 并发症

大于 85,000 字节的对象在 .NET Core 中的大型对象堆 （LOH） 上分配，这可能导致碎片和内存使用效率低下。

问题陈述：最大限度地减少 LOH 碎片

解决方案：LOH 阈值注意事项和ArrayPool<T>

对于大型数据结构，请考虑将它们分解为较小的块或用于大型数组，以尽可能避免 LOH 分配。ArrayPool<T>

Span<T> 和 Memory<T>：现代内存管理

Span<T>和 .NET Core 中引入的类型，用于提供安全高效的内存访问，而无需不安全的代码。它们对于切片数组和使用缓冲区特别有用。Memory<T>

实时用例：在不分配的情况下处理阵列的子集

解决方案：使用Span<T>

public void ProcessSubset(byte[] data) {  
    Span<byte> dataSpan = data.AsSpan().Slice(start: 10, length: 100);  
  
    // Process the subset here  
    // This operation does not allocate any additional memory  
}

在此方案中，允许在不进行额外分配的情况下对数组的子集进行切片和处理，从而提高性能，尤其是在涉及大型数据处理或操作的方案中。Span<T>

检测和诊断内存问题

检测和诊断 .NET Core 应用程序中的内存问题可能具有挑战性。Visual Studio 的诊断工具、JetBrains dotMemory 和 .NET CLI 等工具可以帮助识别内存泄漏和低效的内存使用。dotnet-tracedotnet-gcdump

用于捕获和分析 GC 堆dotnet-gcdump

dotnet-gcdump collect -p <ProcessID>

此命令创建进程的 GC 转储，可以对其进行分析以查找内存泄漏、了解对象生存期并优化内存使用。

? ♂? 施加内存压力

我们可以有意识地施加内存压力来观察 GC 行为：

// Create list to store 1 million strings  
var list = new List<string>();  
  
// Add strings, forcing GC to run multiple times  
for(var i=0; i<1000000; i++)  
{  
  list.Add(Guid.NewGuid().ToString());  
  
  // Print memory stats every 10000 iterations  
  if(i % 10000 == 0)  
  {  
    Console.WriteLine(#34;Iteration {i}: {GC.GetTotalMemory(false)} bytes");   
  }  
}

这会快速分配大型字符串，并施加内存压力以查看 GC 何时启动。

? 使用结构体

结构直接在堆栈上分配内存，而不是堆上：

// Stack-allocated struct   
struct Point {  
  public int X;  
  public int Y;  
}  
  
// Heap-allocated class  
class PointClass {  
  public int X;   
  public int Y;  
}  
  
var point = new Point(); // allocated on stack  
var pointClass = new PointClass(); // allocated on heap

这使得在某些情况下，结构比类更有效。

固定对象

我们可以使用以下命令将对象固定在内存中：GCHandle

LARGE_ARRAY largeArray = new LARGE_ARRAY(1000000); 

// Pin array to prevent GC from moving it  
GCHandle handle = GCHandle.Alloc(largeArray, GCHandleType.Pinned);  
  
// Use array...  
  
handle. Free(); // Unpin

在处理非托管资源时，固定非常有用。

? 分代垃圾回收

.NET GC 使用基于对象年龄的分代收集策略：

var gen0 = new Object(); // Gen 0  
var gen1 = new Object(); // Gen 0  
  
// gen0 promoted to gen 1 after  
GC.Collect();   
  
var gen2 = new Object(); // Gen 0  
  
// gen1 promoted to gen 2 after   
// multiple GCs  
GC.Collect();   
GC.Collect();

新对象从第 0 代开始，然后在集合中幸存下来时向上移动到第 1 代和第 2 代。

好处

• 将精力集中在较新的对象上
• 利用物体年轻死亡或长寿的趋势
• 减少整体 GC 开销

第 0、1、2 代采集频率

• 第 0 代：非常频繁，每分配几 MB 后
• 第 1 代：频率较低，在第 0 代的每个 GC 之后
• 第 2 代：稀有，仅当第 0 代和第 1 代已满时

? LOH 和 SOH

堆进一步分为大对象堆 （LOH） 和小对象堆 （SOH）：

• LOH：对于> 85,000 字节的对象
• SOH：对于< 85,000 字节的对象

大型对象直接在 LOH 上分配。SOH进一步分为几代人。

Phantom 引用

虚拟引用允许检测何时收集对象：

// Create phantom reference   
var obj = new Object();  
PhantomReference phantomRef = new PhantomReference(obj, referenceQueue);  
  
// Object is now only referenced by phantomRef  
obj = null;    
  
// GC collects obj eventually...  
  
// ReferenceQueue gets notified when obj is collected  
Console.WriteLine(referenceQueue.Dequeue());

这允许在对象变得无法访问时执行清理逻辑。

大型对象堆压缩

LOH 可能会随着时间的推移而变得支离破碎。我们可以强制压实：

// Allocate and release large objects  
for (int i=0; i<100; i++)   
{  
  var large = new byte[100000];  
  large = null;   
}  
  
// Force compaction  
GCSettings.LargeObjectHeapCompactionMode =   
  GCLargeObjectHeapCompactionMode.CompactOnce;  
GC.Collect();

这将对 LOH 进行碎片整理以优化内存使用。

?堆压缩

我们可以启用堆压缩来节省内存：

// Compress heap  
GCSettings.IsServerGC = true;  
GCSettings.LargeObjectHeapCompactionMode =   
  GCLargeObjectHeapCompactionMode.CompactOnce;   
  
// Allocate memory...  
  
// Force compacting GC  
GC.Collect();

对象池

对象池通过重用对象来减少分配：

public class ObjectPool<T> where T : new()   
{  
  private Stack<T> objects = new Stack<T>();  
  
  public T GetObject()  
  {  
    if (objects.Count == 0)  
    {  
      return new T();   
    }  
  
    return objects.Pop();  
  }  
  
  public void ReturnObject(T obj)  
  {  
    objects.Push(obj);  
  }  
}  
  
// Usage:  
  
var pool = new ObjectPool\<MyClass>();  
  
var obj = pool.GetObject();  
// Use obj...  
pool.ReturnObject(obj);

这避免了重复构造/破坏对象。

? 内存映射文件

我们可以将文件映射到内存以实现高效共享：

using (var mmf = MemoryMappedFile.CreateFromFile(file))  
{   
  using (var accessor = mmf.CreateViewAccessor())  
  {  
    int size = mmf.CreateViewStream().Length;  
    byte[] array = new byte[size];  
    accessor.ReadArray(0, array, 0, size);  
  }  
}

内存映射文件非常适合在进程之间快速共享内存。

共享内存

我们也可以直接分配共享内存：

using (var sm = SharedMemory.Create("Name", 10000))  
{  
  using (var stream = sm.CreateViewStream())  
  {  
    // Write to shared memory through stream  
  }  
}

? 基准分配

我们可以使用 BenchmarkDotNet 诊断分配问题：

[MemoryDiagnoser]  
public class MemoryBenchmark  
{  
  [Benchmark]  
  public void AllocateObjects()  
  {  
    // Code that allocates lots of objects  
  }  
}

这样可以深入了解分配模式和 GC 压力。

处置对象

确保正确处理一次性物品：

using (Resource res = new Resource())  
{  
  // Use resource  
}  
  
// Or with a try-finally block  
  
Resource res = new Resource();  
try {  
  // use res   
}  
finally {  
  res.Dispose();  
}

使用实际做法优化 .NET Core 中的内存使用情况

随着我们深入研究 .NET Core 内存管理的高级领域，集成解决特定现实挑战的做法至关重要。本部分将探讨如何通过实用的优化技术充分利用 .NET Core 内存管理功能的潜力，重点关注最大程度地减少内存使用量和提高应用程序性能。

有效利用馆藏

集合是大多数应用程序的基础，但其低效使用可能会导致大量内存开销。

问题陈述：减少集合的内存占用

解决方案：使用System.Collections.Generic

var largeList = new List<int>(initialCapacity: 1000000);  
for (int i = 0; i < largeList.Capacity; i++) {  
    largeList.Add(i);  
}

通过指定初始容量，可以防止 在增长时多次调整大小，从而减少内存开销并提高性能。List<T>

了解和利用堆栈和堆

.NET Core 管理堆栈和堆中的内存。.NET Core manage memory across the stack and heap.了解如何以及何时使用堆栈与堆分配会显著影响应用程序的性能和内存使用率。

实时用例：高性能场景的结构与类

解决方案：选择值类型struct

public struct Point {  
    public int X { get; set; }  
    public int Y { get; set; }  
  
    public Point(int x, int y) {  
        X = x;  
        Y = y;  
    }  
}

对于经常创建和销毁的小型不可变对象，使用 a 而不是 a 可以显著减少堆分配，从而利用堆栈提高内存使用效率。structclass

内存泄漏和最终确定

当程序保留对不再需要的对象的引用时，会发生内存泄漏，从而阻止垃圾回收器回收其内存。

问题陈述：防止事件处理程序中的内存泄漏

解决方案：弱事件模式

public class WeakEventPublisher {  
    private WeakReference<EventHandler> _eventHandler;  
  
    public void Subscribe(EventHandler handler) {  
        _eventHandler = new WeakReference<EventHandler>(handler);  
    }  
  
    public void Notify() {  
        if (_eventHandler.TryGetTarget(out EventHandler handler)) {  
            handler?.Invoke(this, EventArgs.Empty);  
        }  
    }  
}

此示例使用 a 来保存对事件处理程序的引用，确保订阅不会阻止订阅服务器被垃圾回收。WeakReference

IDisposable 和 Finalizers

正确实施对于管理非托管资源的生存期至关重要。IDisposable

实时用例：确保释放非托管资源

解决方案：实现模式IDisposable

public class UnmanagedResourceWrapper : IDisposable {  
    private IntPtr unmanagedResource;  
    private bool disposed = false;  
  
    public UnmanagedResourceWrapper() {  
        // Allocate the unmanaged resource  
    }  
  
    protected virtual void Dispose(bool disposing) {  
        if (!disposed) {  
            if (disposing) {  
                // Dispose managed resources  
            }  
  
            // Free unmanaged resources  
            disposed = true;  
        }  
    }  
  
    public void Dispose() {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  
  
    ~UnmanagedResourceWrapper() {  
        Dispose(false);  
    }  
}

此模式可确保正确清理所有资源（包括托管和非托管资源），从而防止内存泄漏，并确保在不再需要资源时立即释放资源。

进一步了解 .NET Core 中内存管理的细微差别需要理论知识和实践的结合。在最后一段中，我们将探讨内存优化的前沿策略、了解内存流量的重要性，以及如何利用 .NET Core 中的新功能进行最先进的内存管理。这些见解旨在为开发人员提供解决新式 .NET Core 应用程序中复杂的内存管理挑战所需的工具。

内存流量：静默性能杀手

内存流量是指 CPU 和内存之间传输的数据量。由于垃圾回收器 （GC） 上的工作负载增加，高内存流量可能会显著影响应用程序性能。

问题陈述：减少高需求应用程序中的内存流量

解决方案：池化和重用对象

减少内存流量的一种有效策略是实现对象池。这涉及重用“池”中的对象，而不是分配和解除分配它们，这可以显着降低 GC 压力。

public class ObjectPool<T> where T : new() {  
    private readonly ConcurrentBag<T> _objects;  
    private int _counter = 0;  
    private int _maxCount;  
  
    public ObjectPool(int maxCount) {  
        _objects = new ConcurrentBag<T>();  
        _maxCount = maxCount;  
    }  
  
    public T GetObject() {  
        if (_objects.TryTake(out T item)) {  
            return item;  
        }  
        if (_counter < _maxCount) {  
            Interlocked.Increment(ref _counter);  
            return new T();  
        }  
  
        throw new InvalidOperationException("Pool limit reached.");  
    }  
  
    public void PutObject(T item) {  
        _objects. Add(item);  
    }  
}

JIT 编译和内存管理

实时 （JIT） 编译也会影响内存使用，因为编译的代码需要存储在内存中。分层编译等高级功能可以帮助优化此过程。

实时用例：优化 JIT 编译以提高内存效率

解决方案：启用分层编译

分层编译允许运行时在多层中编译方法，这可以优化启动时间和吞吐量之间的平衡。在 .NET Core 应用程序的项目文件中启用分层编译：Enable tiered compilation in your .NET Core application's project file：

<PropertyGroup>  
    <TieredCompilation>true</TieredCompilation>  
</PropertyGroup>

高级诊断和内存分析

.NET Core 提供高级诊断工具和 API，使开发人员能够更深入地了解内存使用情况和性能瓶颈。

利用和用于内存分析dotnet-countersdotnet-dump

解决方案：实时性能监控和内存转储分析

# Start monitoring performance counters  
dotnet-counters monitor --process-id <PID> System.Runtime

用于实时性能监控。若要进行更深入的分析，请使用以下命令捕获内存转储：dotnet-countersdotnet-dump

# Capture a memory dump  
dotnet-dump collect --process-id <PID>

关键要点

• GC 自动处理对象分配和清理
• 生成和分段优化收集
• 池化和结构等技术可减少分配
• 内存诊断和处置等工具有助于管理资源

结束语

.NET Core 中的高级内存管理涉及全面了解内存在托管环境中的工作方式，以及用于诊断、优化和控制内存使用情况的工具和做法。通过应用这些高级技术和原则，开发人员可以构建高效、可缩放且可靠的 .NET Core 应用程序。请记住，掌握内存管理的关键是不断学习、实验和分析，以了解应用程序的特定需求和行为。