Implementation code on how to use ref and Span to improve program performance in .Net Core

This article mainly introduces the simple implementation code of using ref and Span to improve program performance in .Net Core. Friends in need can refer to it

1. Preface

In fact, when it comes to ref, many students already know it. Ref is a language feature of C# 7.0, which provides developers with Provides a mechanism for returning local variable references and value references.
Span is also a complex data type based on ref syntax. In the second half of the article, I will have an example showing how to use it.

2. Ref keyword

Whether it is the ref or out key, it is a language feature that is relatively difficult to understand and operate, such as C language is the same as operating pointers. Such high-level syntax always brings some side effects, but I don’t think this has anything, and not every C# developer must have a deep understanding of these internal operating mechanisms. I think that no matter what complex things are, it only provides people with a free choice. Risk and flexibility are always incompatible.

Let’s look at a few examples to illustrate the similarity between references and pointers. Of course, the following usage methods can be used before C# 7.0:

public static void IncrementByRef(ref int x)
{
 x++;
}
public unsafe static void IncrementByPointer(int* x)
{
 (*x)++;
}

The above two functionsUse ref and non-safe pointers respectively to complete the parameter +1.

int i = 30;
IncrementByRef(ref i);
// i = 31
unsafe{
 IncrementByPointer(&i);
}
// i = 32

The following are the features provided by C# 7.0:

1.ref locals (referencing local variables)

int i = 42;
ref var x = ref i;
x = x + 1;
// i = 43

In this example, it is the local i variable The reference x, when the value of x is changed, the value of the i variable also changes.

2.ref returns (return value reference)

ref returns is a powerful feature in C# 7. The following code is the most effective Reflecting its characteristics, this function provides a reference to an item in the int array:

public static ref int GetArrayRef(int[] items, int index) => ref items[index];

Obtains the reference to the item in the array through the subscript. When the reference value is changed, the array It will also change accordingly.

3. Span

System.Span is part of the .Net Core core, in System.Memory.dl l Under the assembly. Currently this feature is independent and may be integrated into CoreFx in the future;

How to use it? Reference the following NuGet package under the project created by .Net Core 2.0 SDK:

 <ItemGroup>
 <PackageReference Include="System.Memory" Version="4.4.0-preview1-25305-02" />
 <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.4.0-preview1-25305-02" />
 </ItemGroup>

Above we saw the pointer (T*)-like operation single value that can be provided by using the ref keywordObjectWay. Basically, operating pointers under the .NET system is not considered a good event. Of course, .NET provides us with refs for safely operating single-value references. But single value is only a small part of the needs of users to use "pointers"; for pointers, the more common situation is when operating a series of "elements" in a continuous memory space.

Span is represented as a continuous memory block of known length and type. In many ways it is very similar to T[] or ArraySegment in that it provides safe access to memory region pointers. In fact, I understand that it will be an abstraction of the operation (void*) pointer in .NET. Developers familiar with C/C++ should know better what this means.

The characteristics of Span are as follows:

•Abstracts the type system of all continuous memory spaces, including: arrays, unmanaged pointers, stack pointers , fixed or pinned managed data, and references to internal areas of values
•Support CLR standard object types and value types
•Support generics
•Support GC, unlike pointers that need to be managed by themselves.

Let’s take a look at the definition of Span, which is grammatically and semantically related to ref:

public struct Span<T> {
 ref T _reference;
 int _length;
 public ref T this[int index] { get {...} }
 ...
}
public struct ReadOnlySpan<T> {
 ref T _reference;
 int _length;
 public T this[int index] { get {...} }
 ...
}

Next, I will use an intuitive example to illustrate the usage scenario of Span; we use Character interception and character conversion (conversion to integer) are as an example:

If there is a string<a href="http://www.php.cn/wiki/57.html" target="_blank">string</a> content = "content-length:123" ,To convert 123 to an integer, the usual approach is to first Substring truncate the string that has nothing to do with numeric characters. The conversion code is as follows:

string content = "content-length:123";
Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int j = 0; j < 100000; j++)
{
 int.Parse(content.Substring(15));
}
watch1.Stop();
Console.WriteLine("\tTime Elapsed:\t" + watch1.ElapsedMilliseconds.ToString("N0") + "ms");

Why use This example is a typical substring usage scenario. Every time a string is operated, a new string object will be generated. Of course, it is not just Substring. String objects are repeatedly operated when int.Parse is performed. If a large number of operations are performed, it will put pressure on the GC. .

Use Span to implement this algorithm:

string content = "content-length:123";
ReadOnlySpan<char> span = content.ToCharArray(); 
span.Slice(15).ParseToInt();
watch.Start();
for (int j = 0; j < 100000; j++)
{
 int icb = span.Slice(15).ParseToInt();
}
watch.Stop();
Console.WriteLine("\tTime Elapsed:\t" + watch.ElapsedMilliseconds.ToString("N0") + "ms");

这里将string转换为int的算法利用ReadonlySpan实现，这也是Span的典型使用场景，官方给的场景也是如些，Span适用于多次复用操作连续内存的场景。

转换代码如下：

public static class ReadonlySpanxtension
{
 public static int ParseToInt(this ReadOnlySpan<char> rspan)
 {
  Int16 sign = 1;
  int num = 0;
  UInt16 index = 0;
  if (rspan[0].Equals(&#39;-&#39;)){
   sign = -1; index = 1;
  }
  for (int idx = index; idx < rspan.Length; idx++){
   char c = rspan[idx];
   num = (c - &#39;0&#39;) + num * 10;
  }
  return num * sign;
 }
}

四、最后

上述两段代码100000次调用的时间如下：

String Substring Convert:
  Time Elapsed: 18ms
ReadOnlySpan Convert:
  Time Elapsed: 4ms

目前Span的相关支持还够，它只是最基础架构，之后CoreFx会对很多API使用Span进行重构和实现。可见.Net Core的性能日后会越来越强大。

The above is the detailed content of Implementation code on how to use ref and Span to improve program performance in .Net Core. For more information, please follow other related articles on the PHP Chinese website!