.net Span类型和Memory类型

.NET 中 Span 类型和 Memory 类型的深度剖析

在 .NET 编程的世界里，高效处理内存是提升程序性能的关键。Span 和 Memory 类型的出现，为开发者提供了强大而灵活的工具，用于高效地访问和操作连续内存区域。今天，我们就来深入探讨这两种类型及其相关概念。

核心类型介绍

1. Span

Span 代表一块连续的、不可变长度的内存区域，可直接读写其中的元素。它可以在栈上声明，也能指向堆上分配的数据或其他内存位置。这种设计使得在不复制数据的情况下，能高效处理内存区域，尤其适用于处理大型数据结构、高性能计算以及与操作系统交互的场景。

2. ReadOnlySpan

ReadOnlySpan 是 Span 的只读版本，提供对连续内存区域的只读访问。当不需要修改内存内容时，使用它能确保数据的安全性，同时享受与 Span 类似的性能优势。

3. Memory 和 ReadOnlyMemory

System.Memory 和 System.ReadOnlyMemory 类似于 Span，但它们增加了表示更复杂内存所有权的能力。可以引用来自非托管内存、网络流、管道或内存映射文件等来源的数据。此外，它们支持跨线程和异步操作，可通过 IMemoryOwner 接口表示所有权。

4. MemoryManager

用于创建和管理 Memory 和 ReadOnlyMemory 实例。开发者可通过实现 MemoryManager 自定义内存的分配和释放方式。

5. IMemoryOwner

作为 MemoryManager 的一个更简单的实现，表示临时拥有一段可释放内存的实体。可通过 MemoryPool 获取此类实例，当内存不再需要时，可通过 Dispose() 方法释放资源。

6. MemoryPool

内存池类，用于高效地分配和回收小块内存，避免频繁的内存分配和垃圾回收带来的开销。可以从内存池中租借 Memory 实例，完成后归还给池。

7. Memory.Pin() 方法和 GCHandle

当需要将 Span 或 Memory 转换为不受垃圾回收影响、可暴露给非托管代码的指针时，可使用 .Pin() 方法获取 MemoryHandle，或直接使用 GCHandle 类来固定内存，常用于与非托管代码（如 C/C++ 互操作）的内存共享。

代码示例

Span 和 ReadOnlySpan 示例

// 创建一个整数数组
int[] array = { 1, 2, 3, 4, 5 };

// 从数组创建 Span
Span<int> span = new Span<int>(array);

// 访问 Span 中的元素
Console.WriteLine(span[0]); // 输出: 1
span[0] = 10; // 修改 Span 中的元素会影响原始数组

// 使用 Slice 方法获取 Span 的子集
Span<int> subSpan = span.Slice(1, 3); // 从索引 1 开始，长度为 3 的子集: { 10, 2, 3 }
foreach (var item in subSpan)
{
    Console.WriteLine(item);
}

// 创建 ReadOnlySpan
ReadOnlySpan<int> readOnlySpan = span.AsReadOnly();
Console.WriteLine(readOnlySpan[0]); // 输出: 10
// readOnlySpan[0] = 20; // 这会编译错误，因为 ReadOnlySpan 是只读的

从这个示例可以看出，Span 就像是对数组内存的一个“视图”，修改 Span 中的元素会直接影响原始数组。而 ReadOnlySpan 则提供了只读访问，保证了数据的安全性。

Memory 和 ReadOnlyMemory 示例

// 创建一个整数数组
int[] array = { 1, 2, 3, 4, 5 };

// 从数组创建 Memory
Memory<int> memory = MemoryMarshal.CreateFromArray(array);

// 访问 Memory 中的元素（通过 Span 属性）
Span<int> spanFromMemory = memory.Span;
Console.WriteLine(spanFromMemory[0]); // 输出: 1
spanFromMemory[0] = 100; // 修改 Span 中的元素会影响原始数组和 Memory

// 创建 ReadOnlyMemory
ReadOnlyMemory<int> readOnlyMemory = memory;
ReadOnlySpan<int> readOnlySpan = readOnlyMemory.Span;
Console.WriteLine(readOnlySpan[0]); // 输出: 100
// readOnlySpan[0] = 200; // 这会编译错误，因为 ReadOnlySpan 是只读的

// 使用 Memory 的 Slice 方法
Memory<int> subMemory = memory.Slice(1, 3); // { 100, 2, 3 }
Span<int> subSpan = subMemory.Span;
foreach (var item in subSpan)
{
    Console.WriteLine(item);
}

Memory 同样可以方便地访问和操作内存，但它更适合处理复杂的内存场景，尤其是涉及异步和跨线程操作。

Span.Clear 方法示例

int[] array = { 1, 2, 3, 4, 5 };
Span<int> span = new Span<int>(array);
span.Clear();
Console.WriteLine(string.Join(", ", array)); // 输出 0, 0, 0, 0, 0

Span.Clear 方法能快速将 Span 中的所有元素设置为默认值，这在需要清空内存数据时非常实用。

MemoryMarshal 类示例

byte[] byteArray = { 1, 2, 3 };
Span<int> intSpan = MemoryMarshal.Cast<byte, int>(byteArray.AsSpan()).Slice(0, byteArray.Length / sizeof(int));
Console.WriteLine(intSpan[0]); // 输出 67305985，这是 1, 2, 3 的字节表示转换为 int 的结果

MemoryMarshal 类提供了一组静态方法，用于在 Span、Memory 和其他类型之间进行转换和操作，大大增强了内存操作的灵活性。

Span 与字符串示例

string str = "Hello";
ReadOnlySpan<char> charSpan = str.AsSpan();
Console.WriteLine(charSpan[0]); // 输出 H

char[] charArray = new char[5];
Span<char> writableCharSpan = charArray.AsSpan();
writableCharSpan.Fill('A');
string newStr = new string(writableCharSpan);
Console.WriteLine(newStr); // 输出 AAAAA

通过 MemoryMarshal 或 Text.Encoding 类，可以在 Span 和字符串之间进行转换，方便处理字符串相关的内存操作。

异步编程和跨线程操作

Memory 和 ReadOnlyMemory 非常适合用于异步编程和跨线程操作，因为它们是引用类型，可以安全地跨越方法边界和线程边界。而 Span 是值类型，生命周期和范围受到限制，不适合直接用于这些场景。

以下是一个使用 Memory 和 ReadOnlyMemory 进行异步编程和跨线程操作的示例代码：

class Program
{
    static async Task Main()
    {
        // 创建一个整数数组
        int[] array = { 1, 2, 3, 4, 5 };

        // 从数组创建 Memory
        Memory<int> memory = array.AsMemory();

        // 异步方法，接受 ReadOnlyMemory 作为参数
        await ProcessMemoryAsync(memory);

        // 跨线程操作
        Task threadTask = Task.Run(() => ProcessMemoryOnThread(memory));
        await threadTask;
    }

    static async Task ProcessMemoryAsync(ReadOnlyMemory<int> readOnlyMemory)
    {
        // 使用 ReadOnlySpan 来处理内存区域
        ReadOnlySpan<int> span = readOnlyMemory.Span;

        foreach (var item in span)
        {
            // 模拟异步操作，例如 I/O 操作
            await Task.Delay(100);
            Console.WriteLine(item);
        }
    }

    static void ProcessMemoryOnThread(ReadOnlyMemory<int> readOnlyMemory)
    {
        // 使用 ReadOnlySpan 来处理内存区域
        ReadOnlySpan<int> span = readOnlyMemory.Span;

        // 跨线程操作，这里只是简单地遍历并打印值
        foreach (var item in span)
        {
            Console.WriteLine(item);
        }
    }
}

在这个示例中，Memory 和 ReadOnlyMemory 确保了在异步和跨线程操作中能够安全地共享对连续内存区域的引用，而无需复制数据，提高了性能。

总结

Span 和 Memory 类型为 .NET 开发者提供了强大的内存处理能力。Span 适用于需要直接、高效访问内存的场景，而 Memory 则更适合处理复杂的内存所有权和跨线程、异步操作。合理运用这些类型，可以显著提升程序的性能和资源利用率。在实际开发中，我们应根据具体的需求和场景，灵活选择使用这些类型，以达到最佳的编程效果。 ======================================================================
前些天发现了一个比较好玩的人工智能学习网站，通俗易懂，风趣幽默，可以了解了解AI基础知识，人工智能教程，不是一堆数学公式和算法的那种，用各种举例子来学习，读起来比较轻松，有兴趣可以看一下。
人工智能教程