span使用方法,span标签使用说明

在日常项目中,很多时候都是在处理字符串,由于字符串的不可变性,会生成很多新的字符串,产生新的字符串意味着需要内存分配和进行垃圾回收(GC),频繁产生新的字符串,也会让GC频繁地回收,即使GC机制一直在改进,即使GC并行回收,也会短暂得阻塞当前程序所有线程进行垃圾回收.

在.Net Core引入Span,Span和数组不同,可以高效的与托管内存和非托管内存,甚至是栈上的交互.最主要的是类型安全和操作内存也是安全的.使用Span可以减少内存的分配,是可以提高性能的.

以往我们用用句柄处理非托管内存,要手动申请和手动释放,使用Span不用手动释放,由GC进行回收.

static void Span1() { var arr = new byte[10]; Span<byte> bytes = arr; //bytes指向arr的引用 for (int i = 0; i < arr.Length; i ) { bytes[i] = (byte)(i 1); //修改bytes数组的值 } Span<byte> slicedBytes = bytes.Slice(5, 2); //bytes.Slice(5, 2)返回bytes下标为为5,长度为2的内容 }

根据上面的代码,进行分析

1. 分析bytes和arr是不是指向同一块内存空间.
2. 分析bytes.Slice是否进行了内存分配

(1)先看一下arr在堆中的内存分配,先将代码执行到

将代码执行到方法体要结束

(2)打开即时窗口,输入 &(arr[0]) ,得到arr[0]在内存的地址.

获取arr在托管堆的内存地址

(3)打开内存窗口,根据在即时窗口拿到的地址,查看在内存中的分配

根据arr的地址查看在托管堆上的内存分配

看到arr的起止地址为0x0000019983091150,结束位置0x0000019983091159,arr在一段连续内存空间内.

回到我们上面2个问题.

问题1,我们只要查看bytes[0]和arr[0]是否为同一个内存地址.

bytes和arr第0个元素地址为同一个

问题2,我们查看slicedBytes[0]和bytes[5]是否为同一个内存地址.得出的结论:通过内存地址比较.没有进行新的内存分配

/// <summary> /// 在栈上分配空间,在栈上分配的内存在离开其所在的作用域自动释放 /// </summary> static void Span2() { int i = 42; Span<byte> stackBytes = stackalloc byte[2]; //c#语言版本 7.0以上支持 stackBytes[0] = 42; stackBytes[1] = 43; }

我们知道在c#中,基本类型是分配在栈上的.通过stackalloc关键字也可以将数组类型分配在栈上.使用栈可以提高程序的性能.只是栈的空间有限.需要合理使用.

/// <summary> /// Span与句柄交互 /// 使用AllocHGlobal(非托管内存分配),要与FreeHGlobal(释放内存)结对 /// </summary> static void Span3() { IntPtr ptr = Marshal.AllocHGlobal(1); try { Span<byte> b; unsafe //使用指针,要加unsafe关键字 { b = new Span<byte>((byte*)ptr, 1); } b[0] = 42; byte val1 = Marshal.ReadByte(ptr); Console.WriteLine(val1 == b[0]); } finally { Marshal.FreeHGlobal(ptr); } }ReadOnlySpan在String中使用

/// <summary> /// ReadOnlySpan在String使用 /// Substring和Slice对比 /// </summary> static void ReadOnlySpan1() { string str = "hello word,hello csharp!"; string newStr = str.Substring(2, 5); //返回新的字符串,要重新分配内存 ReadOnlySpan<char> readOnlySpan = str.AsSpan().Slice(2, 5); //返回的不是新产生的字符串,这里没有内存分配,内部用指针移到str的地址上 //由于无法直接使用&(str[0])和&(readOnlySpan[0])获取内存的地址 //这里使用魔法黑科技-指针 unsafe { fixed (char* p1 = str) { fixed (char* p2 = readOnlySpan) { } } } }

通过p1和p2的地址,查看在内存中的分配.

通过查看内存,ReadOnlySpan只是将指针移动到下标str[2]的地址

得助于.Net Core代码开源,我们可以很方便的查看源码,将Span的代码进行裁剪.只分析几个重要的函数如构造函数等.再把函数内断言和参数校验的进行删除.

/// <summary> /// Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed /// or native memory, or to memory allocated on the stack. It is type- and memory-safe. /// Span和数组不同,可以高效的与托管内存和非托管内存,甚至是栈上的交互.最主要的是类型安全和操作内存也是安全的. /// 以往我们用用句柄处理非托管内存,要手动申请和手动释放,使用Span不用手动释放 /// </summary> public readonly ref partial struct Span<T> { /// <summary> /// 指针 /// </summary> internal readonly ByReference<T> _pointer; /// <summary> /// 记录长度 /// </summary> private readonly int _length; [MethodImpl(MethodImplOptions.AggressiveInlining)] public Span(T[] array) { _pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData())); _length = array.Length; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public Span(T[] array, int start, int length) { _pointer = new ByReference<T>(ref Unsafe.Add(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData()), start)); _length = length; } [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe Span(void* pointer, int length) { _pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref *(byte*)pointer)); _length = length; } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal Span(ref T ptr, int length) { _pointer = new ByReference<T>(ref ptr); _length = length; } public ref T this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return ref Unsafe.Add(ref _pointer.Value, index); } } [MethodImpl(MethodImplOptions.AggressiveInlining)] public Span<T> Slice(int start) { return new Span<T>(ref Unsafe.Add(ref _pointer.Value, start), _length - start); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public Span<T> Slice(int start, int length) { return new Span<T>(ref Unsafe.Add(ref _pointer.Value, start), length); } }

上面Span代码,可以看到Span是泛型的.内部有一个ByReference类型的指针,在ByReference内部有一个私有的IntPtr类型_value记录开始的地址,由_length记录内容长度,可以确定返回内容的结束地址.ByReference本身很简单,只是_value是在JIT(即时编译)确定的.

在Span内部可以看到满满的黑科技,如:

1.在很多函数上面都有一个特性标签 [MethodImpl(MethodImplOptions.AggressiveInlining)],在JIT时,会确定函数是否进行内联.我们都知道函数内联是可以提高性能的,可以省掉调用函数的开销.

2.使用Unsafe指针交互.不知道是不是.Net Core版本低的缘故,无法直接使用Unsafe类.

以上内容是2018年11月日所写,在后面的.Net Core版本源码中,使用Span的地方越来越多,如Span的Fill方法源码使用Unsafe.在迁移后面的文章会有专门的介绍.