Span<T> Структура

Определение

Пространство имен:: System

Сборки:: netstandard.dll, System.Runtime.dll

Сборка:: System.Runtime.dll

Сборка:: netstandard.dll

Исходный код:: Span.cs

Исходный код:: Span.cs

Исходный код:: Span.cs

Исходный код:: Span.cs

Исходный код:: Span.cs

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Предоставляет типобезопасное и безопасное представление непрерывной области произвольной памяти.

generic <typename T>
public value class Span

[System.Runtime.InteropServices.Marshalling.NativeMarshalling(typeof(System.Runtime.InteropServices.Marshalling.SpanMarshaller<,>))]
public readonly ref struct Span<T>

public readonly ref struct Span<T>

[<System.Runtime.InteropServices.Marshalling.NativeMarshalling(typeof(System.Runtime.InteropServices.Marshalling.SpanMarshaller<,>))>]
type Span<'T> = struct

type Span<'T> = struct

Public Structure Span(Of T)

Параметры типа

T

Тип элементов в элементе Span<T>.

Наследование: Object

ValueType
Span<T>

Атрибуты: NativeMarshallingAttribute

Тип Span<T> — это структура ссылок, выделенная в стеке, а не в управляемой куче. Типы структур ссылок имеют некоторые ограничения, чтобы гарантировать, что они не могут быть повышены до управляемой кучи, в том числе они не могут быть:

Штучной упаковке.
Назначается переменным типа Object или dynamicлюбого типа интерфейса.
Поля в ссылочных типах.
Используется через await границы и yield границы.

Кроме того, вызовы двух методов Equals(Object) и GetHashCode вызывают исключение NotSupportedException.

Important

Так как это тип только для стека, Span<T> не подходит для многих сценариев, требующих хранения ссылок на буферы в куче. Это верно для подпрограмм, которые запускают асинхронные методы. Для таких сценариев можно использовать дополнительные System.Memory<T> и System.ReadOnlyMemory<T> типы.

Для диапазонов, представляющих неизменяемые или доступные только для чтения структуры, используйте System.ReadOnlySpan<T>.

Memory

Область Span<T> представляет собой смежную произвольную память. Экземпляр Span<T> часто используется для хранения элементов массива или части массива. В отличие от массива, Span<T> экземпляр может указывать на управляемую память, собственную память или память, управляемую в стеке. В следующем примере создается Span<Byte> из массива.

// Create a span over an array.
var array = new byte[100];
var arraySpan = new Span<byte>(array);

byte data = 0;
for (int ctr = 0; ctr < arraySpan.Length; ctr++)
    arraySpan[ctr] = data++;

int arraySum = 0;
foreach (var value in array)
    arraySum += value;

Console.WriteLine($"The sum is {arraySum}");
// Output:  The sum is 4950

// Create a span over an array.
let array = Array.zeroCreate<byte> 100
let arraySpan = Span<byte> array

let mutable data = 0uy
for i = 0 to arraySpan.Length - 1 do
    arraySpan[i] <- data
    data <- data + 1uy

let mutable arraySum = 0
for value in array do
    arraySum <- arraySum + int value

printfn $"The sum is {arraySum}"
// Output:  The sum is 4950

В следующем примере создается Span<Byte> из 100 байт собственной памяти:

// Create a span from native memory.
var native = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe
{
    nativeSpan = new Span<byte>(native.ToPointer(), 100);
}
byte data = 0;
for (int ctr = 0; ctr < nativeSpan.Length; ctr++)
    nativeSpan[ctr] = data++;

int nativeSum = 0;
foreach (var value in nativeSpan)
    nativeSum += value;

Console.WriteLine($"The sum is {nativeSum}");
Marshal.FreeHGlobal(native);
// Output:  The sum is 4950

// Create a span from native memory.
let native = Marshal.AllocHGlobal 100
let nativeSpan = Span<byte>(native.ToPointer(), 100)

let mutable data = 0uy
for i = 0 to nativeSpan.Length - 1 do
    nativeSpan[i] <- data
    data <- data + 1uy

let mutable nativeSum = 0
for value in nativeSpan do
    nativeSum <- nativeSum + int value

printfn $"The sum is {nativeSum}"
Marshal.FreeHGlobal native
// Output:  The sum is 4950

В следующем примере ключевое слово C# stackalloc используется для выделения 100 байт памяти в стеке:

// Create a span on the stack.
byte data = 0;
Span<byte> stackSpan = stackalloc byte[100];
for (int ctr = 0; ctr < stackSpan.Length; ctr++)
    stackSpan[ctr] = data++;

int stackSum = 0;
foreach (var value in stackSpan)
    stackSum += value;

Console.WriteLine($"The sum is {stackSum}");
// Output:  The sum is 4950

    // Create a span on the stack.
    let mutable data = 0uy
    let stackSpan = 
        let p = NativeInterop.NativePtr.stackalloc<byte> 100 |> NativeInterop.NativePtr.toVoidPtr
        Span<byte>(p, 100)

    for i = 0 to stackSpan.Length - 1 do
        stackSpan[i] <- data
        data <- data + 1uy

    let mutable stackSum = 0
    for value in stackSpan do
        stackSum <- stackSum + int value

    printfn $"The sum is {stackSum}"
// Output:  The sum is 4950

Поскольку Span<T> это абстракция по произвольному блоку памяти, методы Span<T> типа и методов с Span<T> параметрами работают над любым Span<T> объектом независимо от типа памяти, который он инкапсулирует. Например, каждый из отдельных разделов кода, который инициализирует диапазон и вычисляет сумму его элементов, можно рефакторинговать в один метод инициализации и вычисления, как показано в следующем примере:

public static void WorkWithSpans()
{
    // Create a span over an array.
    var array = new byte[100];
    var arraySpan = new Span<byte>(array);

    InitializeSpan(arraySpan);
    Console.WriteLine($"The sum is {ComputeSum(arraySpan):N0}");

    // Create an array from native memory.
    var native = Marshal.AllocHGlobal(100);
    Span<byte> nativeSpan;
    unsafe
    {
        nativeSpan = new Span<byte>(native.ToPointer(), 100);
    }

    InitializeSpan(nativeSpan);
    Console.WriteLine($"The sum is {ComputeSum(nativeSpan):N0}");

    Marshal.FreeHGlobal(native);

    // Create a span on the stack.
    Span<byte> stackSpan = stackalloc byte[100];

    InitializeSpan(stackSpan);
    Console.WriteLine($"The sum is {ComputeSum(stackSpan):N0}");
}

public static void InitializeSpan(Span<byte> span)
{
    byte value = 0;
    for (int ctr = 0; ctr < span.Length; ctr++)
        span[ctr] = value++;
}

public static int ComputeSum(Span<byte> span)
{
    int sum = 0;
    foreach (var value in span)
        sum += value;

    return sum;
}
// The example displays the following output:
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

open System
open System.Runtime.InteropServices
open FSharp.NativeInterop

// Package FSharp.NativeInterop.NativePtr.stackalloc for reuse.
let inline stackalloc<'a when 'a: unmanaged> length : Span<'a> =
    let voidPointer = NativePtr.stackalloc<'a> length |> NativePtr.toVoidPtr
    Span<'a>(voidPointer, length)

let initializeSpan (span: Span<byte>) =
    let mutable value = 0uy
    for i = 0 to span.Length - 1 do
        span[i] <- value
        value <- value + 1uy

let computeSum (span: Span<byte>) =
    let mutable sum = 0
    for value in span do
        sum <- sum + int value
    sum

let workWithSpans () =
    // Create a span over an array.
    let array = Array.zeroCreate<byte> 100
    let arraySpan = Span<byte> array

    initializeSpan arraySpan
    printfn $"The sum is {computeSum arraySpan:N0}"

    // Create an array from native memory.
    let native = Marshal.AllocHGlobal 100
    let nativeSpan = Span<byte>(native.ToPointer(), 100)

    initializeSpan nativeSpan
    printfn $"The sum is {computeSum nativeSpan:N0}"

    Marshal.FreeHGlobal native

    // Create a span on the stack.
    let stackSpan = stackalloc 100

    initializeSpan stackSpan
    printfn $"The sum is {computeSum stackSpan:N0}"

// The example displays the following output:
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

Массивы

Когда оборачивает массив, Span<T> может обернуть весь массив, как это было в примерах в разделе "Память". Так как он поддерживает срез, Span<T> также может указывать на любой смежный диапазон в массиве.

В следующем примере создается срез среднего пяти элементов целочисленного массива 10 элементов. Обратите внимание, что код удвоит значения каждого целого числа в срезе. Как показано в выходных данных, изменения, внесенные диапазоном, отражаются в значениях массива.

using System;

var array = new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
var slice = new Span<int>(array, 2, 5);
for (int ctr = 0; ctr < slice.Length; ctr++)
    slice[ctr] *= 2;

// Examine the original array values.
foreach (var value in array)
    Console.Write($"{value}  ");
Console.WriteLine();

// The example displays the following output:
//      2  4  12  16  20  24  28  16  18  20

module Program

open System

[<EntryPoint>]
let main _ =
    let array = [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
    let slice = Span<int>(array, 2, 5)
    for i = 0 to slice.Length - 1 do
        slice[i] <- slice[i] * 2

    // Examine the original array values.
    for value in array do
        printf $"{value}  "
    printfn ""
    0
// The example displays the following output:
//      2  4  12  16  20  24  28  16  18  20

Срезы

Span<T> включает две перегрузки Slice метода, которые образуют срез из текущего диапазона, который начинается с указанного индекса. Это позволяет обрабатывать данные в Span<T> виде набора логических блоков, которые могут обрабатываться по мере необходимости частями конвейера обработки данных с минимальным воздействием на производительность. Например, так как современные протоколы сервера часто основаны на тексте, управление строками и подстроками особенно важно. В классе String основным методом извлечения подстрок является Substring. Для конвейеров данных, использующих обширную обработку строк, его использование приводит к некоторым потерям производительности, поскольку:

Создает новую строку для хранения подстроки.
Копирует подмножество символов из исходной строки в новую строку.

Эту операцию выделения и копирования можно устранить с помощью Span<T> или ReadOnlySpan<T>, как показано в следующем примере:

using System;

class Program2
{
    static void Run()
    {
        string contentLength = "Content-Length: 132";
        var length = GetContentLength(contentLength.ToCharArray());
        Console.WriteLine($"Content length: {length}");
    }

    private static int GetContentLength(ReadOnlySpan<char> span)
    {
        var slice = span.Slice(16);
        return int.Parse(slice);
    }
}
// Output:
//      Content length: 132

module Program2

open System

let getContentLength (span: ReadOnlySpan<char>) =
    let slice = span.Slice 16
    Int32.Parse slice

let contentLength = "Content-Length: 132"
let length = getContentLength (contentLength.ToCharArray())
printfn $"Content length: {length}"
// Output:
//      Content length: 132

Конструкторы

Имя	Описание
Span<T>(T)	Создает новую Span<T> длину 1 вокруг указанной ссылки.
Span<T>(T[], Int32, Int32)	Создает новый Span<T> объект, содержащий указанное количество элементов массива, начиная с указанного индекса.
Span<T>(T[])	Создает новый Span<T> объект на протяжении всего указанного массива.
Span<T>(Void*, Int32)	Создает объект Span<T> из указанного числа элементов, начиная с указанного `T` адреса памяти.

Свойства

Имя	Описание
Empty	Возвращает пустой Span<T> объект.
IsEmpty	Возвращает значение, указывающее, является ли текущий Span<T> пустым.
Item[Int32]	Возвращает элемент в указанном отсчитываемом от нуля индексе.
Length	Возвращает длину текущего диапазона.

Методы

Имя	Описание
Clear()	Очищает содержимое этого Span<T> объекта.
CopyTo(Span<T>)	Копирует содержимое этого Span<T> объекта в место назначения Span<T>.
Equals(Object)	Устаревшие. Устаревшие. Вызовы этого метода не поддерживаются.
Fill(T)	Заполняет элементы этого диапазона указанным значением.
GetEnumerator()	Возвращает перечислитель для этого Span<T>.
GetHashCode()	Устаревшие. Формирует исключение NotSupportedException.
GetPinnableReference()	Возвращает ссылку на объект типа T, который можно использовать для закрепления. Этот метод предназначен для поддержки .NET компиляторов и не предназначен для вызова пользовательским кодом.
Slice(Int32, Int32)	Формирует срез текущего диапазона, начиная с указанного индекса для указанной длины.
Slice(Int32)	Формирует срез из текущего диапазона, начинающегося с указанного индекса.
ToArray()	Копирует содержимое этого диапазона в новый массив.
ToString()	Возвращает строковое представление этого Span<T> объекта.
TryCopyTo(Span<T>)	Пытается скопировать текущий объект Span<T> в место назначения Span<T> и возвращает значение, указывающее, успешно ли выполнена операция копирования.

Операторы

Имя	Описание
Equality(Span<T>, Span<T>)	Возвращает значение, указывающее, равны ли два Span<T> объекта.
Implicit(ArraySegment<T> to Span<T>)	Определяет неявное преобразование объекта ArraySegment<T> в объект Span<T>.
Implicit(Span<T> to ReadOnlySpan<T>)	Определяет неявное преобразование объекта Span<T> в объект ReadOnlySpan<T>.
Implicit(T[] to Span<T>)	Определяет неявное преобразование массива в .Span<T>
Inequality(Span<T>, Span<T>)	Возвращает значение, указывающее, равны ли два Span<T> объекта.

Методы расширения

Имя	Описание
BinarySearch<T,TComparable>(Span<T>, TComparable)	Выполняет поиск всего отсортированного Span<T> значения с помощью указанного `TComparable` универсального типа.
BinarySearch<T,TComparer>(Span<T>, T, TComparer)	Выполняет поиск всего отсортированного Span<T> значения с использованием указанного `TComparer` универсального типа.
BinarySearch<T>(Span<T>, IComparable<T>)	Выполняет поиск всего отсортированного Span<T> значения с помощью указанного IComparable<T> универсального интерфейса.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Находит длину общего префикса между `span` и `other`.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>)	Находит длину общего префикса между `span` и `other`.
Contains<T>(Span<T>, T)	Указывает, найдено ли указанное значение в диапазоне.
ContainsAny<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск экземпляра любого из указанных `values` и возвращается `true` при обнаружении. Если не найдено, возвращается `false`.
ContainsAny<T>(Span<T>, SearchValues<T>)	Выполняет поиск экземпляра любого из указанных `values` и возвращается `true` при обнаружении. Если не найдено, возвращается `false`.
ContainsAny<T>(Span<T>, T, T, T)	Выполняет поиск экземпляра `value0`, `value1`или `value2` в указанном диапазоне.
ContainsAny<T>(Span<T>, T, T)	Выполняет поиск экземпляра `value0` или `value1`возвращается `true` при обнаружении. Если не найдено, возвращается `false`.
ContainsAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск указанного диапазона для любого значения, отличного от указанного `values`значения.
ContainsAnyExcept<T>(Span<T>, SearchValues<T>)	Выполняет поиск указанного диапазона для любого значения, отличного от указанного `values`значения.
ContainsAnyExcept<T>(Span<T>, T, T, T)	Выполняет поиск любого значения, отличного от `value0`значения , `value1`или `value2`.
ContainsAnyExcept<T>(Span<T>, T, T)	Выполняет поиск указанного диапазона для любого значения, отличного от `value0` или `value1`.
ContainsAnyExcept<T>(Span<T>, T)	Выполняет поиск указанного диапазона для любого значения, отличного от указанного `value`значения.
ContainsAnyExceptInRange<T>(Span<T>, T, T)	Выполняет поиск любого значения за пределами диапазона между `lowInclusive` и `highInclusive`включительно.
ContainsAnyInRange<T>(Span<T>, T, T)	Выполняет поиск любого значения в диапазоне между `lowInclusive` и `highInclusive`включительно и возвращает `true` значение, если найдено. Если не найдено, возвращается `false`.
Count<T>(Span<T>, ReadOnlySpan<T>)	Подсчитывает количество указанных `value` в параметре `span`.
Count<T>(Span<T>, T)	Подсчитывает количество указанных `value` в параметре `span`.
EndsWith<T>(Span<T>, ReadOnlySpan<T>)	Определяет, отображается ли указанная последовательность в конце диапазона.
IndexOf<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск указанной последовательности и возвращает индекс первого вхождения.
IndexOf<T>(Span<T>, T)	Выполняет поиск указанного значения и возвращает индекс первого вхождения.
IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск первого индекса любого из указанных значений.
IndexOfAny<T>(Span<T>, SearchValues<T>)	Выполняет поиск первого индекса любого из указанных значений.
IndexOfAny<T>(Span<T>, T, T, T)	Выполняет поиск первого индекса любого из указанных значений.
IndexOfAny<T>(Span<T>, T, T)	Выполняет поиск первого индекса любого из указанных значений.
IndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск первого индекса любого значения, отличного от указанного `values`.
IndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Выполняет поиск первого индекса любого значения, отличного от указанного `values`.
IndexOfAnyExcept<T>(Span<T>, T, T, T)	Выполняет поиск первого индекса любого значения, отличного от `value0`, `value1`или `value2`.
IndexOfAnyExcept<T>(Span<T>, T, T)	Выполняет поиск первого индекса любого значения, отличного от двух указанных значений.
IndexOfAnyExcept<T>(Span<T>, T)	Выполняет поиск первого индекса любого значения, отличного от указанного `value`.
IndexOfAnyExceptInRange<T>(Span<T>, T, T)	Выполняет поиск первого индекса любого значения вне диапазона между `lowInclusive` и `highInclusive`включительно.
IndexOfAnyInRange<T>(Span<T>, T, T)	Выполняет поиск первого индекса любого значения в диапазоне между `lowInclusive` и `highInclusive`включительно.
LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск указанной последовательности и возвращает индекс последнего вхождения.
LastIndexOf<T>(Span<T>, T)	Выполняет поиск указанного значения и возвращает индекс последнего вхождения.
LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск последнего индекса любого из указанных значений.
LastIndexOfAny<T>(Span<T>, SearchValues<T>)	Выполняет поиск последнего индекса любого из указанных значений.
LastIndexOfAny<T>(Span<T>, T, T, T)	Выполняет поиск последнего индекса любого из указанных значений.
LastIndexOfAny<T>(Span<T>, T, T)	Выполняет поиск последнего индекса любого из указанных значений.
LastIndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Выполняет поиск последнего индекса любого значения, отличного от указанного `values`.
LastIndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Выполняет поиск последнего индекса любого значения, отличного от указанного `values`.
LastIndexOfAnyExcept<T>(Span<T>, T, T, T)	Выполняет поиск последнего индекса любого значения, отличного от указанного `value0`, `value1`или `value2`.
LastIndexOfAnyExcept<T>(Span<T>, T, T)	Выполняет поиск последнего индекса любого значения, отличного от указанного или `value0`указанного`value1`.
LastIndexOfAnyExcept<T>(Span<T>, T)	Выполняет поиск последнего индекса любого значения, отличного от указанного `value`.
LastIndexOfAnyExceptInRange<T>(Span<T>, T, T)	Выполняет поиск последнего индекса любого значения за пределами диапазона между `lowInclusive` и `highInclusive`включительно.
LastIndexOfAnyInRange<T>(Span<T>, T, T)	Выполняет поиск последнего индекса любого значения в диапазоне между `lowInclusive` и `highInclusive`включительно.
Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)	Определяет, перекрывается ли диапазон и диапазон только для чтения в памяти и выводит смещение элемента.
Overlaps<T>(Span<T>, ReadOnlySpan<T>)	Определяет, перекрывается ли диапазон и диапазон только для чтения в памяти.
Replace<T>(Span<T>, T, T, IEqualityComparer<T>)	Заменяет все случаи `oldValue` на `newValue`.
Replace<T>(Span<T>, T, T)	Заменяет все случаи `oldValue` на `newValue`.
ReplaceAny<T>(Span<T>, SearchValues<T>, T)	Заменяет все `span` вхождения любого из элементов в `valuesnewValue`.
ReplaceAnyExcept<T>(Span<T>, SearchValues<T>, T)	Заменяет все `span` элементы, отличные от тех, в которых они есть `values`, `newValue`на .
Reverse<T>(Span<T>)	Изменяет последовательность элементов во всем диапазоне.
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)	Определяет относительный порядок диапазона и диапазон только для чтения, сравнивая элементы с помощью IComparable{T}. CompareTo(T).
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Определяет, равны ли две последовательности, сравнивая элементы с помощью элемента IEqualityComparer<T>.
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)	Определяет, равны ли диапазон и диапазон только для чтения, сравнивая элементы с помощью IEquatable{T}. Equals(T).
Sort<T,TComparer>(Span<T>, TComparer)	Сортирует элементы в целом Span<T> с помощью `TComparer`.
Sort<T>(Span<T>, Comparison<T>)	Сортирует элементы в целом Span<T> с помощью указанного Comparison<T>.
Sort<T>(Span<T>)	Сортирует элементы в целом Span<T> с помощью IComparable<T> реализации каждого элемента элемента Span<T>.
Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)	Сортирует пару диапазонов (один из них содержит ключи и другой, содержащий соответствующие элементы) на основе ключей в первом Span<T> с помощью указанного сравнения.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)	Сортирует пару диапазонов (один из них содержит ключи и другой, содержащий соответствующие элементы) на основе ключей в первом Span<T> случае с помощью указанного сравнения.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>)	Сортирует пару диапазонов (один из которых содержит ключи и другой, содержащий соответствующие элементы), на основе ключей в первом Span<T> случае с использованием IComparable<T> реализации каждого ключа.
StartsWith<T>(Span<T>, ReadOnlySpan<T>)	Определяет, отображается ли указанная последовательность в начале диапазона.
ToImmutableArray<T>(Span<T>)	Преобразует диапазон в неизменяемый массив.
Trim<T>(Span<T>, ReadOnlySpan<T>)	Удаляет все начальные и конечные вхождения набора элементов, указанных в диапазоне только для чтения, из диапазона.
Trim<T>(Span<T>, T)	Удаляет все начальные и конечные вхождения указанного элемента из диапазона.
TrimEnd<T>(Span<T>, ReadOnlySpan<T>)	Удаляет все конечные вхождения набора элементов, указанных в диапазоне только для чтения, из диапазона.
TrimEnd<T>(Span<T>, T)	Удаляет все конечные вхождения указанного элемента из диапазона.
TrimStart<T>(Span<T>, ReadOnlySpan<T>)	Удаляет все начальные вхождения набора элементов, указанных в диапазоне только для чтения, из диапазона.
TrimStart<T>(Span<T>, T)	Удаляет все начальные вхождения указанного элемента из диапазона.

Применяется к

См. также раздел

Обратная связь

Были ли сведения на этой странице полезными?