Span<T> Struct

Definitie

Naamruimte:: System

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Bron:: Span.cs

Bron:: Span.cs

Bron:: Span.cs

Bron:: Span.cs

Bron:: Span.cs

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Biedt een type-veilige en geheugenveilige weergave van een aaneengesloten regio van willekeurig geheugen.

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)

Type parameters

T

Het type items in de Span<T>.

Overname: Object

ValueType
Span<T>

Kenmerken: NativeMarshallingAttribute

Opmerkingen

Het Span<T> type is een refstruct die wordt toegewezen aan de stack in plaats van aan de beheerde heap. Verwstruct-typen hebben enkele beperkingen om ervoor te zorgen dat ze niet kunnen worden gepromoveerd naar de beheerde heap, inclusief dat ze niet kunnen zijn:

Boxed.
Toegewezen aan variabelen van het type Object of dynamic, of aan een interfacetype.
Velden in een verwijzingstype.
Gebruikt over await en yield grenzen.

Bovendien veroorzaken aanroepen van de twee methoden Equals(Object) en GetHashCode een NotSupportedException.

Important

Omdat het een stack-only type is, Span<T> is dit niet geschikt voor veel scenario's waarvoor verwijzingen naar buffers op de heap moeten worden opgeslagen. Dit geldt bijvoorbeeld voor routines die asynchrone methodeaanroepen maken. Voor dergelijke scenario's kunt u de complementaire typen System.Memory<T> en System.ReadOnlyMemory<T> gebruiken.

Voor delen die onveranderbare of 'read-only' structuren vertegenwoordigen, gebruikt u System.ReadOnlySpan<T>.

Memory

A Span<T> vertegenwoordigt een aaneengesloten regio van willekeurig geheugen. Een Span<T> exemplaar wordt vaak gebruikt voor het opslaan van de elementen van een matrix of een deel van een matrix. In tegenstelling tot een matrix kan een Span<T> exemplaar echter verwijzen naar beheerd geheugen, systeemeigen geheugen of geheugen dat op de stack wordt beheerd. In het volgende voorbeeld wordt een Span<Byte> van een matrix gemaakt:

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

In het volgende voorbeeld wordt een Span<Byte> systeemeigen geheugen van 100 bytes gemaakt:

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

In het volgende voorbeeld wordt het C# -trefwoord stackalloc gebruikt om 100 bytes geheugen toe te wijzen aan de stack:

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

Omdat Span<T> dit een abstractie is van een willekeurig geheugenblok, werken methoden van het Span<T> type en de methoden met Span<T> parameters op elk Span<T> object, ongeacht het type geheugen dat wordt ingekapseld. Elk van de afzonderlijke codesecties die het bereik initialiseren en de som van de elementen berekenen, kan bijvoorbeeld samengevoegd worden tot één initialisatie- en berekeningsmethode, zoals in het volgende voorbeeld geïllustreerd wordt.

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

Reeksen

Wanneer een matrix wordt verpakt, Span<T> kan deze een hele matrix verpakken, zoals in de voorbeelden in de sectie Geheugen . Omdat het segmenteren ondersteunt, Span<T> kan het ook verwijzen naar elk aaneengesloten bereik binnen de matrix.

In het volgende voorbeeld wordt een segment gemaakt van de middelste vijf elementen van een matrix met een geheel getal van 10 elementen. Houd er rekening mee dat de code de waarden van elk geheel getal in het segment verdubbelt. Zoals in de uitvoer wordt weergegeven, worden de wijzigingen die door het bereik zijn aangebracht, weergegeven in de waarden van de matrix.

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

Segmenten

Span<T> bevat twee overloads van de Slice-methode die een deel vormen uit de huidige span die begint bij een opgegeven index. Dit maakt het mogelijk om de gegevens in een Span<T> set logische segmenten te behandelen die indien nodig kunnen worden verwerkt door delen van een pijplijn voor gegevensverwerking met minimale invloed op de prestaties. Omdat moderne serverprotocollen bijvoorbeeld vaak op tekst zijn gebaseerd, is het bewerken van tekenreeksen en subtekenreeksen bijzonder belangrijk. In de String klasse is Substringde primaire methode voor het extraheren van subtekenreeksen. Voor gegevenspijplijnen die afhankelijk zijn van uitgebreide bewerking van tekenreeksen, biedt het gebruik ervan enkele prestatiestraffen, omdat het:

Hiermee maakt u een nieuwe tekenreeks voor het opslaan van de subtekenreeks.
Hiermee kopieert u een subset van de tekens van de oorspronkelijke tekenreeks naar de nieuwe tekenreeks.

Deze toewijzings- en kopieerbewerking kan worden geëlimineerd met behulp van Span<T> of ReadOnlySpan<T>, zoals het volgende voorbeeld laat zien:

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

Constructors

Name	Description
Span<T>(T)	Hiermee maakt u een nieuwe Span<T> lengte 1 rond de opgegeven verwijzing.
Span<T>(T[], Int32, Int32)	Hiermee maakt u een nieuw Span<T> object met een opgegeven aantal elementen van een matrix die begint bij een opgegeven index.
Span<T>(T[])	Hiermee maakt u een nieuw Span<T> object over het geheel van een opgegeven matrix.
Span<T>(Void*, Int32)	Hiermee maakt u een nieuw Span<T> object op basis van een opgegeven aantal `T` elementen vanaf een opgegeven geheugenadres.

Eigenschappen

Name	Description
Empty	Retourneert een leeg Span<T> object.
IsEmpty	Retourneert een waarde die aangeeft of de huidige Span<T> leeg is.
Item[Int32]	Hiermee haalt u het element op de opgegeven op nul gebaseerde index op.
Length	Retourneert de lengte van de huidige periode.

Methoden

Name	Description
Clear()	Hiermee wist u de inhoud van dit Span<T> object.
CopyTo(Span<T>)	Hiermee kopieert u de inhoud ervan Span<T> naar een bestemming Span<T>.
Equals(Object)	Verouderd. Verouderd. Aanroepen naar deze methode worden niet ondersteund.
Fill(T)	Vult de elementen van dit bereik met een opgegeven waarde.
GetEnumerator()	Retourneert een enumerator voor dit Span<T>.
GetHashCode()	Verouderd. Gooit een NotSupportedException.
GetPinnableReference()	Retourneert een verwijzing naar een object van het type T dat kan worden gebruikt voor het vastmaken. Deze methode is bedoeld ter ondersteuning van .NET compilers en is niet bedoeld om door gebruikerscode aan te roepen.
Slice(Int32, Int32)	Hiermee wordt een segment uit de huidige periode samengesteld dat begint bij een opgegeven index voor een opgegeven lengte.
Slice(Int32)	Hiermee wordt een segment uit de huidige periode samengesteld dat begint bij een opgegeven index.
ToArray()	Hiermee kopieert u de inhoud van dit bereik naar een nieuwe matrix.
ToString()	Retourneert de tekenreeksweergave van dit Span<T> object.
TryCopyTo(Span<T>)	Probeert de huidige Span<T> naar een bestemming Span<T> te kopiëren en retourneert een waarde die aangeeft of de kopieerbewerking is geslaagd.

Operators

Name	Description
Equality(Span<T>, Span<T>)	Retourneert een waarde die aangeeft of twee Span<T> objecten gelijk zijn.
Implicit(ArraySegment<T> to Span<T>)	Definieert een impliciete conversie van een ArraySegment<T> naar een Span<T>.
Implicit(Span<T> to ReadOnlySpan<T>)	Definieert een impliciete conversie van een Span<T> naar een ReadOnlySpan<T>.
Implicit(T[] to Span<T>)	Definieert een impliciete conversie van een matrix naar een Span<T>.
Inequality(Span<T>, Span<T>)	Retourneert een waarde die aangeeft of twee Span<T> objecten niet gelijk zijn.

Extensiemethoden

Name	Description
BinarySearch<T,TComparable>(Span<T>, TComparable)	Hiermee wordt gezocht naar een hele gesorteerde Span<T> waarde met behulp van het opgegeven `TComparable` algemene type.
BinarySearch<T,TComparer>(Span<T>, T, TComparer)	Hiermee wordt gezocht naar een geheel dat is gesorteerd Span<T> op een opgegeven waarde met behulp van het opgegeven `TComparer` algemene type.
BinarySearch<T>(Span<T>, IComparable<T>)	Hiermee wordt gezocht naar een volledige gesorteerde Span<T> waarde met behulp van de opgegeven IComparable<T> algemene interface.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Hiermee vindt u de lengte van een gemeenschappelijk voorvoegsel dat wordt gedeeld tussen `span` en `other`.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>)	Hiermee vindt u de lengte van een gemeenschappelijk voorvoegsel dat wordt gedeeld tussen `span` en `other`.
Contains<T>(Span<T>, T)	Hiermee wordt aangegeven of een opgegeven waarde in een bereik wordt gevonden.
ContainsAny<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar een exemplaar van een van de opgegeven `values` en retourneert `true` indien gevonden. Als dit niet wordt gevonden, wordt het resultaat geretourneerd `false`.
ContainsAny<T>(Span<T>, SearchValues<T>)	Zoekt naar een exemplaar van een van de opgegeven `values` en retourneert `true` indien gevonden. Als dit niet wordt gevonden, wordt het resultaat geretourneerd `false`.
ContainsAny<T>(Span<T>, T, T, T)	Hiermee wordt gezocht naar een exemplaar van `value0`, `value1`of `value2` in de opgegeven periode.
ContainsAny<T>(Span<T>, T, T)	Zoekt naar een exemplaar van `value0` of `value1`, en retourneert `true` indien gevonden. Als dit niet wordt gevonden, wordt het resultaat geretourneerd `false`.
ContainsAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Zoekt in de opgegeven periode naar een andere waarde dan de opgegeven `values`waarde.
ContainsAnyExcept<T>(Span<T>, SearchValues<T>)	Zoekt in de opgegeven periode naar een andere waarde dan de opgegeven `values`waarde.
ContainsAnyExcept<T>(Span<T>, T, T, T)	Zoekt naar een andere waarde dan `value0`, `value1`of `value2`.
ContainsAnyExcept<T>(Span<T>, T, T)	Zoekt in de opgegeven periode naar een andere waarde dan `value0` of `value1`.
ContainsAnyExcept<T>(Span<T>, T)	Zoekt in de opgegeven periode naar een andere waarde dan de opgegeven `value`waarde.
ContainsAnyExceptInRange<T>(Span<T>, T, T)	Zoekt naar een waarde buiten het bereik tussen `lowInclusive` en `highInclusive`inclusief.
ContainsAnyInRange<T>(Span<T>, T, T)	Zoekt naar een waarde in het bereik tussen `lowInclusive` en `highInclusive`inclusief, en retourneert `true` indien gevonden. Als dit niet wordt gevonden, wordt het resultaat geretourneerd `false`.
Count<T>(Span<T>, ReadOnlySpan<T>)	Telt het aantal keren dat de opgegeven `value` voorkomt in de `span`.
Count<T>(Span<T>, T)	Telt het aantal keren dat de opgegeven `value` voorkomt in de `span`.
EndsWith<T>(Span<T>, ReadOnlySpan<T>)	Bepaalt of de opgegeven reeks wordt weergegeven aan het einde van een periode.
IndexOf<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de opgegeven reeks en retourneert de index van het eerste exemplaar.
IndexOf<T>(Span<T>, T)	Zoekt naar de opgegeven waarde en retourneert de index van het eerste exemplaar.
IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de eerste index van een van de opgegeven waarden.
IndexOfAny<T>(Span<T>, SearchValues<T>)	Zoekt naar de eerste index van een van de opgegeven waarden.
IndexOfAny<T>(Span<T>, T, T, T)	Zoekt naar de eerste index van een van de opgegeven waarden.
IndexOfAny<T>(Span<T>, T, T)	Zoekt naar de eerste index van een van de opgegeven waarden.
IndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de eerste index van een andere waarde dan de opgegeven `values`waarde.
IndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Zoekt naar de eerste index van een andere waarde dan de opgegeven `values`waarde.
IndexOfAnyExcept<T>(Span<T>, T, T, T)	Zoekt naar de eerste index van een andere waarde dan `value0`, `value1`of `value2`.
IndexOfAnyExcept<T>(Span<T>, T, T)	Zoekt naar de eerste index van een andere waarde dan de twee opgegeven waarden.
IndexOfAnyExcept<T>(Span<T>, T)	Zoekt naar de eerste index van een andere waarde dan de opgegeven `value`waarde.
IndexOfAnyExceptInRange<T>(Span<T>, T, T)	Zoekt naar de eerste index van een waarde buiten het bereik tussen `lowInclusive` en `highInclusive`inclusief.
IndexOfAnyInRange<T>(Span<T>, T, T)	Zoekt naar de eerste index van een waarde in het bereik tussen `lowInclusive` en `highInclusive`inclusief.
LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de opgegeven reeks en retourneert de index van het laatste exemplaar.
LastIndexOf<T>(Span<T>, T)	Zoekt naar de opgegeven waarde en retourneert de index van het laatste exemplaar.
LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de laatste index van een van de opgegeven waarden.
LastIndexOfAny<T>(Span<T>, SearchValues<T>)	Zoekt naar de laatste index van een van de opgegeven waarden.
LastIndexOfAny<T>(Span<T>, T, T, T)	Zoekt naar de laatste index van een van de opgegeven waarden.
LastIndexOfAny<T>(Span<T>, T, T)	Zoekt naar de laatste index van een van de opgegeven waarden.
LastIndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Zoekt naar de laatste index van een andere waarde dan de opgegeven `values`.
LastIndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Zoekt naar de laatste index van een andere waarde dan de opgegeven `values`.
LastIndexOfAnyExcept<T>(Span<T>, T, T, T)	Zoekt naar de laatste index van een andere waarde dan de opgegeven `value0`, `value1`of `value2`.
LastIndexOfAnyExcept<T>(Span<T>, T, T)	Zoekt naar de laatste index van een andere waarde dan de opgegeven `value0` of `value1`.
LastIndexOfAnyExcept<T>(Span<T>, T)	Zoekt naar de laatste index van een andere waarde dan de opgegeven `value`.
LastIndexOfAnyExceptInRange<T>(Span<T>, T, T)	Zoekt naar de laatste index van een waarde buiten het bereik tussen `lowInclusive` en `highInclusive`inclusief.
LastIndexOfAnyInRange<T>(Span<T>, T, T)	Hiermee wordt gezocht naar de laatste index van een waarde in het bereik tussen `lowInclusive` en `highInclusive`inclusief.
Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)	Bepaalt of een span en een alleen-lezen span elkaar overlappen in het geheugen en de elementverschiluitvoer.
Overlaps<T>(Span<T>, ReadOnlySpan<T>)	Bepaalt of een span en een alleen-lezen span overlappen in het geheugen.
Replace<T>(Span<T>, T, T, IEqualityComparer<T>)	Vervangt alle exemplaren van ``oldValue`` door ``newValue``.
Replace<T>(Span<T>, T, T)	Vervangt alle exemplaren van ``oldValue`` door ``newValue``.
ReplaceAny<T>(Span<T>, SearchValues<T>, T)	Vervangt in `span` alle gevallen van een van de elementen in `values` door `newValue`.
ReplaceAnyExcept<T>(Span<T>, SearchValues<T>, T)	Vervangt in `span` alle elementen, behalve die in `values`, door `newValue`.
Reverse<T>(Span<T>)	Hiermee wordt de volgorde van de elementen in de gehele periode omgekeerd.
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)	Bepaalt de relatieve volgorde van een span en een alleen-lezen span door de elementen te vergelijken met behulp van IComparable{T}. CompareTo(T).
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	Bepaalt of twee reeksen gelijk zijn door de elementen te vergelijken met behulp van een IEqualityComparer<T>.
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)	Bepaalt of een spanwijdte en een alleen-lezenspanne gelijk zijn door de elementen te vergelijken met behulp van IEquatable{T}. Is gelijk aan(T).
Sort<T,TComparer>(Span<T>, TComparer)	Hiermee sorteert u de elementen in het geheel Span<T> met behulp van de `TComparer`.
Sort<T>(Span<T>, Comparison<T>)	Sorteert de elementen in het geheel Span<T> met behulp van de opgegeven Comparison<T>.
Sort<T>(Span<T>)	Sorteert de elementen in het geheel Span<T> met behulp van de IComparable<T> implementatie van elk element van het Span<T>.
Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)	Hiermee sorteert u een paar spanten (een met de sleutels en de andere met de bijbehorende items) op basis van de sleutels in de eerste Span<T> met behulp van de opgegeven vergelijkingsfunctie.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)	Hiermee sorteert u een paar spans (een met de sleutels en de andere met de bijbehorende items) op basis van de sleutels in de eerste Span<T> met behulp van de opgegeven vergelijking.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>)	Hiermee sorteert u een paar spans (een met de sleutels en de andere met de bijbehorende items) op basis van de sleutels in de eerste Span<T> met behulp van de IComparable<T> implementatie van elke sleutel.
StartsWith<T>(Span<T>, ReadOnlySpan<T>)	Bepaalt of een opgegeven reeks wordt weergegeven aan het begin van een periode.
ToImmutableArray<T>(Span<T>)	Converteert de spanwijdte naar een onveranderbare matrix.
Trim<T>(Span<T>, ReadOnlySpan<T>)	Hiermee verwijdert u alle voorloop- en volgbewerkingen van een set elementen die zijn opgegeven in een alleen-lezenspanne van een spanwijdte.
Trim<T>(Span<T>, T)	Verwijdert alle voorloop- en volg-exemplaren van een opgegeven element uit een span.
TrimEnd<T>(Span<T>, ReadOnlySpan<T>)	Hiermee verwijdert u alle achtervolgende exemplaren van een set elementen die zijn opgegeven in een alleen-lezenspanne van een span.
TrimEnd<T>(Span<T>, T)	Hiermee verwijdert u alle achtervolgende exemplaren van een opgegeven element uit een span.
TrimStart<T>(Span<T>, ReadOnlySpan<T>)	Hiermee verwijdert u alle voorloopvallen van een set elementen die zijn opgegeven in een alleen-lezenspanne van de spanwijdte.
TrimStart<T>(Span<T>, T)	Hiermee verwijdert u alle voorloop-exemplaren van een opgegeven element uit het bereik.

Van toepassing op

Zie ook

Feedback

Is deze pagina nuttig?