Span<T> Struktura

Definicja

Przestrzeń nazw:: System

Zestawy:: netstandard.dll, System.Runtime.dll

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Źródło:: Span.cs

Źródło:: Span.cs

Źródło:: Span.cs

Źródło:: Span.cs

Źródło:: Span.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Zapewnia bezpieczną i bezpieczną pamięć reprezentację ciągłego regionu dowolnego pamięci.

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)

Parametry typu

T

Typ elementów w obiekcie Span<T>.

Dziedziczenie: Object

ValueType
Span<T>

Atrybuty: NativeMarshallingAttribute

Uwagi

Typ Span<T> jest strukturą ref struct przydzielaną na stosie, a nie na stercie zarządzanej. Typy struktury ref mają pewne ograniczenia, aby upewnić się, że nie mogą być promowane do zarządzanej sterty, w tym że nie mogą być następujące:

Zapakowane.
Przypisane do zmiennych typu Object lub dynamic, lub do dowolnego typu interfejsu.
Pola w typie odwołania.
Używane przez await granice i yield .

Ponadto wywołania dwóch metod Equals(Object) i GetHashCode, zgłaszają wartość NotSupportedException.

Important

Ponieważ jest to typ przechowywany tylko na stosie, Span<T> jest nieodpowiedni dla wielu scenariuszy, które wymagają przechowywania odwołań do buforów na stercie. Dotyczy to na przykład rutyn, które wykonują asynchroniczne wywołania metod. W takich scenariuszach można użyć typów uzupełniających System.Memory<T> i System.ReadOnlyMemory<T> .

W przypadku zakresów reprezentujących niezmienne lub tylko do odczytu struktury, użyj System.ReadOnlySpan<T>.

Pamięć

Obiekt Span<T> reprezentuje ciągły region dowolnej pamięci. Wystąpienie Span<T> jest często używane do przechowywania elementów tablicy lub części tablicy. W przeciwieństwie do tablicy wystąpienie Span<T> może jednak wskazywać pamięć zarządzaną, pamięć natywną lub pamięć zarządzaną na stosie. Poniższy przykład tworzy obiekt Span<Byte> na podstawie tablicy:

// 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

Poniższy przykład tworzy obiekt Span<Byte> z 100 bajtów pamięci natywnej:

// 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

W poniższym przykładzie użyto słowa kluczowego stackalloc języka C#, aby przydzielić 100 bajtów pamięci na stosie:

// 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

Ponieważ Span<T> jest abstrakcją nad dowolnym blokiem pamięci, metody typu Span<T> oraz metody z parametrami Span<T> mogą działać na każdym obiekcie Span<T> niezależnie od rodzaju pamięci, którą enkapsuluje. Na przykład każda z oddzielnych sekcji kodu, które inicjują zakres i obliczają sumę swoich elementów, można refaktoryzować na pojedyncze metody inicjowania i obliczania, jak pokazano w poniższym przykładzie:

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

Tablice

Gdy opakowuje tablicę, Span<T> może opakowować całą tablicę, tak jak w przykładach w sekcji Pamięć . Ponieważ obsługuje fragmentowanie, Span<T> może również wskazywać dowolny ciągły zakres w tablicy.

Poniższy przykład tworzy wycinek środkowych pięciu elementów 10-elementowej tablicy całkowitej. Zwróć uwagę, że kod podwaja wartości każdej liczby całkowitej w wycinku. Jak pokazują dane wyjściowe, zmiany wprowadzone przez zakres są odzwierciedlane w wartościach tablicy.

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

Wycinki

Span<T> zawiera dwa przeciążenia metody Slice, które tworzą wycinek z bieżącego zakresu rozpoczynającego się od określonego indeksu. Dzięki temu można traktować dane w Span<T> jako zestaw logicznych fragmentów, które mogą być przetwarzane zgodnie z potrzebami przez części potoku przetwarzania danych, z minimalnym wpływem na wydajność. Na przykład, ponieważ nowoczesne protokoły serwera są często oparte na tekście, manipulowanie ciągami i podciągami jest szczególnie ważne. W klasie String, główną metodą wyodrębniania podciągów jest Substring. W przypadku potoków danych, które opierają się na obszernej manipulacji ciągami, jego użycie wiąże się z pewnymi karami wydajnościowymi, ponieważ:

Tworzy nowy ciąg do przechowywania podciągu.
Kopiuje podzbiór znaków z oryginalnego ciągu do nowego ciągu.

Tę operację alokacji i kopiowania można wyeliminować przy użyciu metody Span<T> lub ReadOnlySpan<T>, jak pokazano w poniższym przykładzie:

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

Konstruktory

Nazwa	Opis
Span<T>(T)	Tworzy nową Span<T> długość 1 wokół określonego odwołania.
Span<T>(T[], Int32, Int32)	Tworzy nowy Span<T> obiekt, który zawiera określoną liczbę elementów tablicy rozpoczynającej się od określonego indeksu.
Span<T>(T[])	Tworzy nowy Span<T> obiekt w całej określonej tablicy.
Span<T>(Void*, Int32)	Tworzy nowy Span<T> obiekt na podstawie określonej liczby elementów rozpoczynających `T` się od określonego adresu pamięci.

Właściwości

Nazwa	Opis
Empty	Zwraca pusty Span<T> obiekt.
IsEmpty	Zwraca wartość wskazującą, czy bieżący Span<T> jest pusty.
Item[Int32]	Pobiera element w określonym indeksie opartym na zerach.
Length	Zwraca długość bieżącego zakresu.

Metody

Nazwa	Opis
Clear()	Czyści zawartość tego Span<T> obiektu.
CopyTo(Span<T>)	Kopiuje zawartość tego Span<T> elementu do miejsca docelowego Span<T>.
Equals(Object)	Przestarzałe. Przestarzałe. Wywołania tej metody nie są obsługiwane.
Fill(T)	Wypełnia elementy tego zakresu określoną wartością.
GetEnumerator()	Zwraca moduł wyliczający dla tego Span<T>elementu .
GetHashCode()	Przestarzałe. Zgłasza element NotSupportedException.
GetPinnableReference()	Zwraca odwołanie do obiektu typu T, którego można użyć do przypinania. Ta metoda ma obsługiwać kompilatory .NET i nie ma być wywoływana przez kod użytkownika.
Slice(Int32, Int32)	Tworzy wycinkę bieżącego zakresu rozpoczynającego się od określonego indeksu dla określonej długości.
Slice(Int32)	Tworzy wycinkę bieżącego zakresu rozpoczynającego się od określonego indeksu.
ToArray()	Kopiuje zawartość tego zakresu do nowej tablicy.
ToString()	Zwraca reprezentację ciągu tego Span<T> obiektu.
TryCopyTo(Span<T>)	Próbuje skopiować bieżący Span<T> element do miejsca docelowego Span<T> i zwraca wartość wskazującą, czy operacja kopiowania powiodła się.

Operatory

Nazwa	Opis
Equality(Span<T>, Span<T>)	Zwraca wartość wskazującą, czy dwa Span<T> obiekty są równe.
Implicit(ArraySegment<T> to Span<T>)	Definiuje niejawną konwersję elementu ArraySegment<T> na .Span<T>
Implicit(Span<T> to ReadOnlySpan<T>)	Definiuje niejawną konwersję Span<T> elementu na .ReadOnlySpan<T>
Implicit(T[] to Span<T>)	Definiuje niejawną konwersję tablicy na Span<T>.
Inequality(Span<T>, Span<T>)	Zwraca wartość wskazującą, czy dwa Span<T> obiekty nie są równe.

Metody rozszerzania

Nazwa	Opis
BinarySearch<T,TComparable>(Span<T>, TComparable)	Wyszukuje całą posortowaną Span<T> wartość przy użyciu określonego `TComparable` typu ogólnego.
BinarySearch<T,TComparer>(Span<T>, T, TComparer)	Wyszukuje całą posortowaną Span<T> dla określonej wartości przy użyciu określonego `TComparer` typu ogólnego.
BinarySearch<T>(Span<T>, IComparable<T>)	Wyszukuje całą posortowaną Span<T> wartość przy użyciu określonego IComparable<T> interfejsu ogólnego.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Znajduje długość dowolnego wspólnego prefiksu współużytkowanego między `span` i `other`.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>)	Znajduje długość dowolnego wspólnego prefiksu współużytkowanego między `span` i `other`.
Contains<T>(Span<T>, T)	Wskazuje, czy określona wartość znajduje się w zakresie.
ContainsAny<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje wystąpienie dowolnego z określonych `values` elementów i zwraca `true` wartość w przypadku znalezienia. Jeśli nie zostanie znaleziona, zwraca wartość `false`.
ContainsAny<T>(Span<T>, SearchValues<T>)	Wyszukuje wystąpienie dowolnego z określonych `values` elementów i zwraca `true` wartość w przypadku znalezienia. Jeśli nie zostanie znaleziona, zwraca wartość `false`.
ContainsAny<T>(Span<T>, T, T, T)	Wyszukuje wystąpienie elementu `value0`, `value1`lub `value2` w określonym zakresie.
ContainsAny<T>(Span<T>, T, T)	Wyszukuje wystąpienie elementu `value0` lub `value1`i zwraca `true` wartość w przypadku znalezienia. Jeśli nie zostanie znaleziona, zwraca wartość `false`.
ContainsAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje określony zakres dla dowolnej wartości innej niż określona `values`.
ContainsAnyExcept<T>(Span<T>, SearchValues<T>)	Wyszukuje określony zakres dla dowolnej wartości innej niż określona `values`.
ContainsAnyExcept<T>(Span<T>, T, T, T)	Wyszukuje dowolną wartość inną niż `value0`, `value1`lub `value2`.
ContainsAnyExcept<T>(Span<T>, T, T)	Wyszukuje określony zakres dla dowolnej wartości innej niż `value0` lub `value1`.
ContainsAnyExcept<T>(Span<T>, T)	Wyszukuje określony zakres dla dowolnej wartości innej niż określona `value`.
ContainsAnyExceptInRange<T>(Span<T>, T, T)	Wyszukuje dowolną wartość poza zakresem między `lowInclusive` i `highInclusive`, włącznie.
ContainsAnyInRange<T>(Span<T>, T, T)	Wyszukuje dowolną wartość w zakresie od `lowInclusive` do `highInclusive`, włącznie i zwraca `true` wartość w przypadku znalezienia. Jeśli nie zostanie znaleziona, zwraca wartość `false`.
Count<T>(Span<T>, ReadOnlySpan<T>)	Zlicza liczbę wystąpień określonych `value` w obiekcie `span`.
Count<T>(Span<T>, T)	Zlicza liczbę wystąpień określonych `value` w obiekcie `span`.
EndsWith<T>(Span<T>, ReadOnlySpan<T>)	Określa, czy określona sekwencja pojawia się na końcu zakresu.
IndexOf<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje określoną sekwencję i zwraca indeks pierwszego wystąpienia.
IndexOf<T>(Span<T>, T)	Wyszukuje określoną wartość i zwraca indeks pierwszego wystąpienia.
IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje pierwszy indeks dowolnej z określonych wartości.
IndexOfAny<T>(Span<T>, SearchValues<T>)	Wyszukuje pierwszy indeks dowolnej z określonych wartości.
IndexOfAny<T>(Span<T>, T, T, T)	Wyszukuje pierwszy indeks dowolnej z określonych wartości.
IndexOfAny<T>(Span<T>, T, T)	Wyszukuje pierwszy indeks dowolnej z określonych wartości.
IndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje pierwszy indeks dowolnej wartości innej niż określona `values`.
IndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Wyszukuje pierwszy indeks dowolnej wartości innej niż określona `values`.
IndexOfAnyExcept<T>(Span<T>, T, T, T)	Wyszukuje pierwszy indeks dowolnej wartości innej niż `value0`, `value1`lub `value2`.
IndexOfAnyExcept<T>(Span<T>, T, T)	Wyszukuje pierwszy indeks dowolnej wartości innej niż dwie określone wartości.
IndexOfAnyExcept<T>(Span<T>, T)	Wyszukuje pierwszy indeks dowolnej wartości innej niż określona `value`.
IndexOfAnyExceptInRange<T>(Span<T>, T, T)	Wyszukuje pierwszy indeks dowolnej wartości poza zakresem między `lowInclusive` i `highInclusive`, włącznie.
IndexOfAnyInRange<T>(Span<T>, T, T)	Wyszukuje pierwszy indeks dowolnej wartości w zakresie od `lowInclusive` do `highInclusive`, włącznie.
LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje określoną sekwencję i zwraca indeks ostatniego wystąpienia.
LastIndexOf<T>(Span<T>, T)	Wyszukuje określoną wartość i zwraca indeks ostatniego wystąpienia.
LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje ostatni indeks dowolnej z określonych wartości.
LastIndexOfAny<T>(Span<T>, SearchValues<T>)	Wyszukuje ostatni indeks dowolnej z określonych wartości.
LastIndexOfAny<T>(Span<T>, T, T, T)	Wyszukuje ostatni indeks dowolnej z określonych wartości.
LastIndexOfAny<T>(Span<T>, T, T)	Wyszukuje ostatni indeks dowolnej z określonych wartości.
LastIndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Wyszukuje ostatni indeks dowolnej wartości innej niż określona `values`.
LastIndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Wyszukuje ostatni indeks dowolnej wartości innej niż określona `values`.
LastIndexOfAnyExcept<T>(Span<T>, T, T, T)	Wyszukuje ostatni indeks dowolnej wartości innej niż określona `value0`, `value1`lub `value2`.
LastIndexOfAnyExcept<T>(Span<T>, T, T)	Wyszukuje ostatni indeks dowolnej wartości innej niż określona `value0` lub `value1`.
LastIndexOfAnyExcept<T>(Span<T>, T)	Wyszukuje ostatni indeks dowolnej wartości innej niż określona `value`.
LastIndexOfAnyExceptInRange<T>(Span<T>, T, T)	Wyszukuje ostatni indeks dowolnej wartości poza zakresem między `lowInclusive` i `highInclusive`, włącznie.
LastIndexOfAnyInRange<T>(Span<T>, T, T)	Wyszukuje ostatni indeks dowolnej wartości w zakresie od `lowInclusive` do `highInclusive`, włącznie.
Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)	Określa, czy zakres i zakres tylko do odczytu nakładają się na pamięć i wyprowadza przesunięcie elementu.
Overlaps<T>(Span<T>, ReadOnlySpan<T>)	Określa, czy zakres i zakres tylko do odczytu nakładają się na pamięć.
Replace<T>(Span<T>, T, T, IEqualityComparer<T>)	Zamienia wszystkie wystąpienia elementu `oldValue` na `newValue`.
Replace<T>(Span<T>, T, T)	Zamienia wszystkie wystąpienia elementu `oldValue` na `newValue`.
ReplaceAny<T>(Span<T>, SearchValues<T>, T)	Zastępuje we `span` wszystkich wystąpieniach dowolnych elementów w elemencie `valuesnewValue` .
ReplaceAnyExcept<T>(Span<T>, SearchValues<T>, T)	Zamienia we `span` wszystkich elementach innych niż te w elemencie `values`, na `newValue`.
Reverse<T>(Span<T>)	Odwraca sekwencję elementów w całym zakresie.
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)	Określa względną kolejność zakresu i zakresu tylko do odczytu, porównując elementy przy użyciu funkcji IComparable{T}. CompareTo(T).
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Określa, czy dwie sekwencje są równe, porównując elementy przy użyciu elementu IEqualityComparer<T>.
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)	Określa, czy zakres i zakres tylko do odczytu są równe, porównując elementy przy użyciu funkcji IEquatable{T}. Equals(T).
Sort<T,TComparer>(Span<T>, TComparer)	Sortuje elementy w całości Span<T> przy użyciu elementu `TComparer`.
Sort<T>(Span<T>, Comparison<T>)	Sortuje elementy w całości Span<T> przy użyciu określonego Comparison<T>elementu .
Sort<T>(Span<T>)	Sortuje elementy w całości Span<T> przy użyciu IComparable<T> implementacji każdego elementu .Span<T>
Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)	Sortuje parę zakresów (jeden zawierający klucze i inne zawierające odpowiednie elementy) na podstawie kluczy w pierwszym Span<T> przy użyciu określonego modułu porównującego.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)	Sortuje parę zakresów (jeden zawierający klucze i inne zawierające odpowiednie elementy) na podstawie kluczy w pierwszym Span<T> przy użyciu określonego porównania.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>)	Sortuje parę zakresów (jeden zawierający klucze i inne zawierające odpowiednie elementy) na podstawie kluczy w pierwszej Span<T> kolejności przy użyciu IComparable<T> implementacji każdego klucza.
StartsWith<T>(Span<T>, ReadOnlySpan<T>)	Określa, czy określona sekwencja pojawia się na początku zakresu.
ToImmutableArray<T>(Span<T>)	Konwertuje zakres na tablicę niezmienną.
Trim<T>(Span<T>, ReadOnlySpan<T>)	Usuwa wszystkie wystąpienia wiodące i końcowe zestawu elementów określonych w zakresie tylko do odczytu z zakresu.
Trim<T>(Span<T>, T)	Usuwa wszystkie wystąpienia wiodące i końcowe określonego elementu z zakresu.
TrimEnd<T>(Span<T>, ReadOnlySpan<T>)	Usuwa wszystkie końcowe wystąpienia zestawu elementów określonych w zakresie tylko do odczytu z zakresu.
TrimEnd<T>(Span<T>, T)	Usuwa wszystkie końcowe wystąpienia określonego elementu z zakresu.
TrimStart<T>(Span<T>, ReadOnlySpan<T>)	Usuwa wszystkie wiodące wystąpienia zestawu elementów określonych w zakresie tylko do odczytu z zakresu.
TrimStart<T>(Span<T>, T)	Usuwa wszystkie wiodące wystąpienia określonego elementu z zakresu.

Dotyczy

Zobacz też

Opinia

Czy ta strona była pomocna?