Code Analysis: Using ref and Span to improve program performance in .Net Core

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

##1. Preface

In fact, when it comes to ref, many students already know it. Ref is a language feature of C# 7.0. It provides developers with a mechanism to return 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 Like manipulating pointers in C language, such high-level syntax always brings some side effects, but I don’t think this has anything, and not every C# developer needs to have a deep understanding of these internal operating mechanisms. I think no matter What is complicated is that it only provides people with a free choice. Risk and flexibility are never compatible.

Let’s look at a few examples to illustrate the identity of 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 functions use ref and non-safe pointer 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 reference x of the local i variable. 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 best reflects its features. This function Provided, returns 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 also It will change accordingly.

3. Span

System.Span is part of the .Net Core core, under the System.Memory.dll 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 similar pointer (T*) that can be provided by using the ref keyword The way to operate single value objects. Basically, operating pointers is not considered a good thing in the .NET system. 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 take character interception and character conversion (conversion to integer) as an example:

If there is a string

string content = "content-length:123",To convert 123 to an integer, the usual approach is to first use Substring to 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 For example, this 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");

The algorithm for converting string to int is implemented using ReadonlySpan. This is also a typical usage scenario of Span. Officially given The same is true for scenarios where Span is suitable for scenarios where contiguous memory is reused multiple times.

The conversion code is as follows:

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;
 }
}

4. The last two paragraphs

The time for the code to be called 100,000 times is as follows:

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

Currently, Span’s related support is sufficient. It is only the most basic architecture. In the future, CoreFx will reconstruct and use Span for many APIs. accomplish. It can be seen that the performance of .Net Core will become more and more powerful in the future.

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