Span<T> Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Span.cs

Rastgele belleğin bitişik bir bölgesinin tür açısından güvenli ve bellek açısından güvenli bir gösterimini sağlar.

generic <typename T>
public value class Span

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

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

Public Structure Span(Of T)

Tür Parametreleri

T

içindeki Span<T>öğelerin türü.

Devralma

Object

ValueType

Span<T>

Öznitelikler

NativeMarshallingAttribute

Açıklamalar

Tür Span<T>, yönetilen yığın yerine yığında tahsis edilen bir ref struct'tır. Başvuru yapısı türlerinin yönetilen yığına yükseltilmemesini sağlamak için bazı kısıtlamaları vardır ve bunlar şunlar olamaz:

• Kutulu.
• veya Objectveya türünde dynamic değişkenlere ya da herhangi bir arabirim yazım hatasına atanır.
• Bir başvuru türündeki alanlar.
• Ve await sınırları boyunca yield kullanılır.

Buna ek olarak, iki yönteme çağrır Equals(Object) ve GetHashCodebir NotSupportedExceptionoluşturur.

Important

Yalnızca yığın türünde olduğundan, Span<T> yığındaki arabelleklere yönelik başvuruların depolanmasını gerektiren birçok senaryo için uygun değildir. Bu, örneğin zaman uyumsuz yöntem çağrıları yapan rutinler için geçerlidir. Bu tür senaryolar için tamamlayıcı System.Memory<T> ve System.ReadOnlyMemory<T> türleri kullanabilirsiniz.

Sabit veya salt okunur yapıları temsil eden aralıklar için System.ReadOnlySpan<T> kullanın.

Memory

A Span<T> , rastgele belleğin bitişik bir bölgesini temsil eder. Bir Span<T> örnek genellikle bir dizinin öğelerini veya dizinin bir bölümünü tutmak için kullanılır. Ancak bir diziden farklı olarak, bir Span<T> örnek yönetilen belleğe, yerel belleğe veya yığında yönetilen belleğe işaret edebilir. Aşağıdaki örnek bir diziden bir Span<Byte> oluşturur:

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

Aşağıdaki örnek, 100 baytlık yerel bellekten bir Span<Byte> oluşturur.

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

Aşağıdaki örnek, yığında 100 bayt bellek ayırmak için C# stackalloc anahtar sözcüğünü kullanır:

// 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> Rastgele bir bellek bloğu üzerinde soyutlama olduğundan, türün Span<T> yöntemleri ve parametreleri olan Span<T> yöntemler, kapsüllediği bellek türünden bağımsız olarak herhangi bir Span<T> nesne üzerinde çalışır. Örneğin, aşağıdaki örnekte gösterildiği gibi, kodun yayılma alanını başlatan ve öğelerinin toplamını hesaplayan ayrı bölümlerinin her biri tek başlatma ve hesaplama yöntemleri halinde yeniden düzenlenebilir:

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

Diziler

Bir diziyi sarmaladığında, Span<T> Bellek bölümündeki örneklerde olduğu gibi dizinin tamamını sarmalayabilir. Dilimlemeye destek olduğundan, Span<T> dizideki herhangi bir bitişik aralığa da işaret edebilir.

Aşağıdaki örnek, 10 öğeli bir tamsayı dizisinin orta beş öğesinin bir dilimini oluşturur. Kodun, dilimdeki her tamsayının değerlerini ikiye katladığını unutmayın. Çıktıda gösterildiği gibi, span tarafından yapılan değişiklikler dizinin değerlerine yansıtılır.

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

Dilimler

Span<T> , belirtilen dizinde Slice başlayan geçerli yayılma alanının dışında bir dilim oluşturan yöntemin iki aşırı yüklemesini içerir. Bu, bir Span<T> veri işleme işlem hattının bölümleri tarafından gerektiğinde işlenebilen mantıksal öbekler kümesindeki verileri en düşük performans etkisiyle işlemeyi mümkün kılar. Örneğin, modern sunucu protokolleri genellikle metin tabanlı olduğundan, dizelerin ve alt dizelerin değiştirilmesi özellikle önemlidir. String sınıfında, alt dizeleri çıkarmak için ana yöntem Substring'dir. Kapsamlı dize işlemeye dayanan veri işlem hatları için kullanımı, performans kayıplarına neden olabileceğinden:

1. Alt dizeyi tutmak için yeni bir dize oluşturur.
2. Özgün dizedeki karakterlerin bir alt kümesini yeni dizeye kopyalar.

Bu ayırma ve kopyalama işlemi, aşağıdaki örnekte gösterildiği gibi veya Span<T>kullanılarak ReadOnlySpan<T> ortadan kaldırılabilir:

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

Oluşturucular

Name	Description
Span<T>(T)	Belirtilen başvuru etrafında 1 uzunluğunda yeni Span<T> bir oluşturur.
Span<T>(T[], Int32, Int32)	Belirtilen dizinden başlayarak dizinin belirtilen sayıda öğesini içeren yeni Span<T> bir nesne oluşturur.
Span<T>(T[])	Belirtilen dizinin tamamı boyunca yeni Span<T> bir nesne oluşturur.
Span<T>(Void*, Int32)	Belirtilen bellek adresinden başlayan belirli sayıda Span<T> öğeden yeni T bir nesne oluşturur.

Özellikler

Name	Description
Empty	Boş Span<T> bir nesne döndürür.
IsEmpty	Geçerli Span<T> değerin boş olup olmadığını gösteren bir değer döndürür.
Item[Int32]	Belirtilen sıfır tabanlı dizindeki öğesini alır.
Length	Geçerli aralığın uzunluğunu döndürür.

Yöntemler

Name	Description
Clear()	Bu Span<T> nesnenin içeriğini temizler.
CopyTo(Span<T>)	Bunun Span<T> içeriğini hedefine Span<T>kopyalar.
Equals(Object)	Geçersiz. Bu yönteme yapılan çağrılar desteklenmez.
Fill(T)	Bu yayılma alanının öğelerini belirtilen değerle doldurur.
GetEnumerator()	Bu Span<T>için bir numaralandırıcı döndürür.
GetHashCode()	Geçersiz. Bir NotSupportedExceptionatar.
GetPinnableReference()	Sabitleme için kullanılabilecek T türünde bir nesneye başvuru döndürür. Bu yöntem .NET derleyicileri desteklemeye yöneliktir ve kullanıcı kodu tarafından çağrılması amaçlanmamıştır.
Slice(Int32, Int32)	Belirtilen uzunlukta belirtilen bir dizinden başlayarak geçerli yayılma alanının bir dilimini oluşturur.
Slice(Int32)	Belirtilen dizinde başlayan geçerli yayılma alanının dışında bir dilim oluşturur.
ToArray()	Bu yayılma alanının içeriğini yeni bir diziye kopyalar.
ToString()	Bu Span<T> nesnenin dize gösterimini döndürür.
TryCopyTo(Span<T>)	Geçerli Span<T> değeri bir hedefe Span<T> kopyalamayı dener ve kopyalama işleminin başarılı olup olmadığını gösteren bir değer döndürür.

İşleçler

Name	Description
Equality(Span<T>, Span<T>)	İki Span<T> nesnenin eşit olup olmadığını gösteren bir değer döndürür.
Implicit(ArraySegment<T> to Span<T>)	öğesinin örtük bir dönüştürmesini ArraySegment<T> tanımlar Span<T>.
Implicit(Span<T> to ReadOnlySpan<T>)	öğesinin örtük bir dönüştürmesini Span<T> tanımlar ReadOnlySpan<T>.
Implicit(T[] to Span<T>)	Bir diziye örtük bir dönüştürme tanımlar Span<T>.
Inequality(Span<T>, Span<T>)	İki Span<T> nesnenin eşit olup olmadığını gösteren bir değer döndürür.

Uzantı Metotları

Name	Description
BinarySearch<T,TComparable>(Span<T>, TComparable)	Belirtilen Span<T> genel türü kullanarak bir değerin tamamını sıralanmış TComparable olarak arar.
BinarySearch<T,TComparer>(Span<T>, T, TComparer)	Belirtilen Span<T> genel türü kullanarak belirtilen değerin tamamını sıralanmış TComparer olarak arar.
BinarySearch<T>(Span<T>, IComparable<T>)	Belirtilen Span<T> genel arabirimi kullanarak bir değerin tamamını sıralanmış IComparable<T> olarak arar.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	ve spanarasında other paylaşılan tüm ortak ön eklerin uzunluğunu bulur.
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>)	ve spanarasında other paylaşılan tüm ortak ön eklerin uzunluğunu bulur.
Contains<T>(Span<T>, T)	Belirtilen değerin bir span içinde bulunup bulunmadığını gösterir.
ContainsAny<T>(Span<T>, ReadOnlySpan<T>)	Belirtilenlerden values herhangi birinin oluşumunu arar ve bulunursa döndürür true . Bulunamazsa döndürür false.
ContainsAny<T>(Span<T>, SearchValues<T>)	Belirtilenlerden values herhangi birinin oluşumunu arar ve bulunursa döndürür true . Bulunamazsa döndürür false.
ContainsAny<T>(Span<T>, T, T, T)	, veya value0 öğesinin value1value2belirtilen yayılma alanında bir oluşumunu arar.
ContainsAny<T>(Span<T>, T, T)	veya örneğini value0 arar ve bulunursa döndürürvalue1.true Bulunamazsa döndürür false.
ContainsAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen span'da belirtilen dışında valuesbir değer arar.
ContainsAnyExcept<T>(Span<T>, SearchValues<T>)	Belirtilen span'da belirtilen dışında valuesbir değer arar.
ContainsAnyExcept<T>(Span<T>, T, T, T)	, value0veya value1dışındaki value2herhangi bir değeri arar.
ContainsAnyExcept<T>(Span<T>, T, T)	Belirtilen span'da veya value0dışında value1 bir değer arar.
ContainsAnyExcept<T>(Span<T>, T)	Belirtilen span'da belirtilen dışında valuebir değer arar.
ContainsAnyExceptInRange<T>(Span<T>, T, T)	ile lowInclusivearasındaki highInclusive aralığın dışında herhangi bir değeri arar.
ContainsAnyInRange<T>(Span<T>, T, T)	ile dahil aralığındaki lowInclusive herhangi bir değeri arar ve bulunursa döndürürhighInclusive.true Bulunamazsa döndürür false.
Count<T>(Span<T>, ReadOnlySpan<T>)	içinde belirtilenlerin value kaç kez gerçekleştiğini spansayar.
Count<T>(Span<T>, T)	içinde belirtilenlerin value kaç kez gerçekleştiğini spansayar.
EndsWith<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen sıranın bir yayılma alanının sonunda görünüp görünmeyeceğini belirler.
IndexOf<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen diziyi arar ve ilk oluşumunun dizinini döndürür.
IndexOf<T>(Span<T>, T)	Belirtilen değeri arar ve ilk oluşumunun dizinini döndürür.
IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen değerlerden herhangi birinin ilk dizinini arar.
IndexOfAny<T>(Span<T>, SearchValues<T>)	Belirtilen değerlerden herhangi birinin ilk dizinini arar.
IndexOfAny<T>(Span<T>, T, T, T)	Belirtilen değerlerden herhangi birinin ilk dizinini arar.
IndexOfAny<T>(Span<T>, T, T)	Belirtilen değerlerden herhangi birinin ilk dizinini arar.
IndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen valuesdışında herhangi bir değerin ilk dizinini arar.
IndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Belirtilen valuesdışında herhangi bir değerin ilk dizinini arar.
IndexOfAnyExcept<T>(Span<T>, T, T, T)	, value0veya value1dışındaki value2herhangi bir değerin ilk dizinini arar.
IndexOfAnyExcept<T>(Span<T>, T, T)	Belirtilen iki değer dışındaki herhangi bir değerin ilk dizinini arar.
IndexOfAnyExcept<T>(Span<T>, T)	Belirtilen valuedışında herhangi bir değerin ilk dizinini arar.
IndexOfAnyExceptInRange<T>(Span<T>, T, T)	ile lowInclusivearasındaki highInclusive aralığın dışındaki herhangi bir değerin ilk dizinini arar.
IndexOfAnyInRange<T>(Span<T>, T, T)	ile lowInclusivearasındaki highInclusive aralıktaki herhangi bir değerin ilk dizinini (dahil) arar.
LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen diziyi arar ve son oluşumunun dizinini döndürür.
LastIndexOf<T>(Span<T>, T)	Belirtilen değeri arar ve son oluşumunun dizinini döndürür.
LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen değerlerden herhangi birinin son dizinini arar.
LastIndexOfAny<T>(Span<T>, SearchValues<T>)	Belirtilen değerlerden herhangi birinin son dizinini arar.
LastIndexOfAny<T>(Span<T>, T, T, T)	Belirtilen değerlerden herhangi birinin son dizinini arar.
LastIndexOfAny<T>(Span<T>, T, T)	Belirtilen değerlerden herhangi birinin son dizinini arar.
LastIndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen valuesdışında herhangi bir değerin son dizinini arar.
LastIndexOfAnyExcept<T>(Span<T>, SearchValues<T>)	Belirtilen valuesdışında herhangi bir değerin son dizinini arar.
LastIndexOfAnyExcept<T>(Span<T>, T, T, T)	Belirtilen value0, value1veya value2dışındaki herhangi bir değerin son dizinini arar.
LastIndexOfAnyExcept<T>(Span<T>, T, T)	Belirtilen value0 veya value1dışındaki herhangi bir değerin son dizinini arar.
LastIndexOfAnyExcept<T>(Span<T>, T)	Belirtilen valuedışında herhangi bir değerin son dizinini arar.
LastIndexOfAnyExceptInRange<T>(Span<T>, T, T)	ile lowInclusivearasındaki highInclusive aralığın dışında kalan değerlerin son dizinini (dahil) arar.
LastIndexOfAnyInRange<T>(Span<T>, T, T)	ile lowInclusivearasındaki highInclusive aralıktaki herhangi bir değerin son dizinini (dahil) arar.
Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)	Bir yayılma alanının ve salt okunur bir yayılma alanının bellekte çakışıp çakışmadığını belirler ve öğe uzaklığını döndürür.
Overlaps<T>(Span<T>, ReadOnlySpan<T>)	Bir yayılma alanının ve salt okunur bir yayılma alanının bellekte çakışıp çakışmadığını belirler.
Replace<T>(Span<T>, T, T, IEqualityComparer<T>)	oldValue öğesinin tüm oluşumlarını newValue ile değiştirir.
Replace<T>(Span<T>, T, T)	oldValue öğesinin tüm oluşumlarını newValue ile değiştirir.
ReplaceAny<T>(Span<T>, SearchValues<T>, T)	içindeki span öğelerden values herhangi birinin tüm oluşumlarında öğesini ile newValuedeğiştirir.
ReplaceAnyExcept<T>(Span<T>, SearchValues<T>, T)	içindekiler span dışında valuestüm öğeleri ile newValuedeğiştirir.
Reverse<T>(Span<T>)	Tüm yayılma alanındaki öğelerin sırasını tersine çevirir.
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)	IComparable{T} kullanarak öğeleri karşılaştırarak bir yayılma alanının ve salt okunur bir yayılma alanının göreli sırasını belirler. CompareTo(T).
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)	kullanarak IEqualityComparer<T>öğeleri karşılaştırarak iki dizinin eşit olup olmadığını belirler.
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)	IEquatable{T} kullanarak öğeleri karşılaştırarak bir yayılma alanının ve salt okunur bir yayılma alanının eşit olup olmadığını belirler. Eşittir(T).
Sort<T,TComparer>(Span<T>, TComparer)	öğesini kullanarak Span<T>içindeki öğeleri sıralarTComparer.
Sort<T>(Span<T>, Comparison<T>)	Belirtilen Span<T>öğesini kullanarak içindeki öğeleri sıralarComparison<T>.
Sort<T>(Span<T>)	öğesinin her öğesinin Span<T> uygulamasını kullanarak içindeki öğeleri IComparable<T>sıralarSpan<T>.
Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)	Belirtilen karşılaştırıcıyı kullanan ilk Span<T> anahtarlara göre bir çift yayılma alanı (biri anahtarları, diğeri de ilgili öğeleri içeren) sıralar.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)	Belirtilen karşılaştırmayı kullanan ilk Span<T> anahtarlara göre bir çift yayılma alanı (biri anahtarları, diğeri de ilgili öğeleri içeren) sıralar.
Sort<TKey,TValue>(Span<TKey>, Span<TValue>)	Her anahtarın uygulanmasını kullanan Span<T> ilk IComparable<T> anahtarlara göre bir çift yayılma alanı (biri anahtarları, diğeri de ilgili öğeleri içeren) sıralar.
StartsWith<T>(Span<T>, ReadOnlySpan<T>)	Belirtilen bir sıranın bir yayılma alanının başında görünüp görünmeyeceğini belirler.
ToImmutableArray<T>(Span<T>)	Yayılmayı sabit bir diziye dönüştürür.
Trim<T>(Span<T>, ReadOnlySpan<T>)	Salt okunur bir yayılma alanında belirtilen bir öğe kümesinin tüm baştaki ve sondaki oluşumlarını bir yayılma alanından kaldırır.
Trim<T>(Span<T>, T)	Belirtilen öğenin tüm baştaki ve sondaki oluşumlarını bir span'dan kaldırır.
TrimEnd<T>(Span<T>, ReadOnlySpan<T>)	Salt okunur bir yayılma alanında belirtilen bir öğe kümesinin sondaki tüm oluşumlarını bir yayılma alanından kaldırır.
TrimEnd<T>(Span<T>, T)	Belirtilen öğenin tüm sondaki oluşumlarını bir span'dan kaldırır.
TrimStart<T>(Span<T>, ReadOnlySpan<T>)	Salt okunur bir yayılma alanında belirtilen bir öğe kümesinin baştaki tüm oluşumlarını yayılma alanından kaldırır.
TrimStart<T>(Span<T>, T)	Belirtilen öğenin tüm baştaki oluşumlarını span'dan kaldırır.

Ayrıca bkz.

• Bellek ve span ile ilgili türler
• Bellek<T> ve Span<T> kullanım yönergeleri