Span<T> Yapı

Tanım

İsteğe bağlı rastgele bellek bölgesinin tür ve bellek açısından güvenli bir gösterimini sağlar.Provides a type- and memory-safe representation of a contiguous region of arbitrary memory.

generic <typename T>
public value class Span
public struct Span<T>
type Span<'T> = struct
Public Structure Span(Of T)

Tür Parametreleri

T

İçindeki öğelerin türü Span<T> .The type of items in the Span<T>.

Devralma
Span<T>

Açıklamalar

Span<T> , yönetilen yığında değil, yığına ayrılan bir başvuru yapısı .Span<T> is a ref struct that is allocated on the stack rather than on the managed heap. Ref struct türlerinin, kutulamamaları, bir tür değişkenlerine atanamazlar, Object dynamic ya da herhangi bir arabirim türüne atanamazlar ve bunlar arasında await ve yield sınırlarda kullanılamaz olması dahil olmak üzere, yönetilen yığına yükseltilebilmesi için çeşitli kısıtlamalar vardır.Ref struct types have a number of restrictions to ensure that they cannot be promoted to the managed heap, including that they can't be boxed, they can't be assigned to variables of type Object, dynamic or to any interface type, they can't be fields in a reference type, and they can't be used across await and yield boundaries. Ayrıca, iki yönteme çağrı yapın Equals(Object) ve GetHashCode bir oluşturur NotSupportedException .In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

Önemli

Yalnızca yığın türünde olduğundan, yığındaki Span<T> arabelleklere başvuruların depolanmasını gerektiren birçok senaryo için uygun değildir.Because it is a stack-only type, Span<T> is unsuitable for many scenarios that require storing references to buffers on the heap. Bu, örneğin, zaman uyumsuz yöntem çağıran yordamlar için geçerlidir.This is true, for example, of routines that make asynchronous method calls. Bu tür senaryolarda, tamamlayıcı System.Memory<T> ve System.ReadOnlyMemory<T> türlerini kullanabilirsiniz.For such scenarios, you can use the complementary System.Memory<T> and System.ReadOnlyMemory<T> types.

Sabit veya salt okuma yapılarını temsil eden yayılmalar için kullanın System.ReadOnlySpan<T> .For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

Yayılma <T> ve bellekSpan<T> and memory

Bir Span<T> , rastgele belleğin bitişik bir bölgesini temsil eder.A Span<T> represents a contiguous region of arbitrary memory. Bir Span<T> örnek genellikle bir dizinin veya bir dizinin bir kısmının öğelerini tutmak için kullanılır.A Span<T> instance is often used to hold the elements of an array or a portion of an array. Ancak, bir dizinin aksine, bir Span<T> örnek yönetilen bellek, yerel bellek veya yığında yönetilen bellek üzerine işaret edebilir.Unlike an array, however, a Span<T> instance can point to managed memory, native memory, or memory managed on the stack. Aşağıdaki örnek bir diziden bir oluşturur Span<Byte> :The following example creates a Span<Byte> from an array:

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

Aşağıdaki örnek, Span<Byte> 100 bayttan oluşan yerel bellekten bir oluşturur:The following example creates a Span<Byte> from 100 bytes of native memory:

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

Aşağıdaki örnek, yığın üzerinde 100 bayt bellek ayırmak için C# stackalloc anahtar sözcüğünü kullanır:The following example uses the C# stackalloc keyword to allocate 100 bytes of memory on the 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

Span<T>, Rastgele bir bellek bloğunun üzerinde bir soyutlama olduğundan, Span<T> sınıf yöntemleri ve parametreleri olan Yöntemler, Span<T> Span<T> kapsülleyen bellek türüne bakılmaksızın herhangi bir nesne üzerinde çalışır.Because Span<T> is an abstraction over an arbitrary block of memory, methods of the Span<T> class and methods with Span<T> parameters operate on any Span<T> object regardless of the kind of memory it encapsulates. Örneğin, aşağıdaki örnekte gösterildiği gibi, yayılma alanını başlatacak ve öğelerinin toplamını hesaplayan kodun ayrı bölümlerinin her biri tek başlatma ve hesaplama yöntemlerine değiştirilebilir:For example, each of the separate sections of code that initialize the span and calculate the sum of its elements can be changed into single initialization and calculation methods, as the following example illustrates:

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

Yayılma <T> ve dizilerSpan<T> and arrays

Bir diziyi sarmaladığı zaman, Span<T> yayılma <T> ve bellek bölümündeki örneklerde olduğu gibi, tüm diziyi kaydırabilirler.When it wraps an array, Span<T> can wrap an entire array, as it did in the examples in the Span<T> and memory section. Dilimleme desteklediğinden, Span<T> dizi içinde herhangi bir bitişik aralığa da işaret edebilir.Because it supports slicing, Span<T> can also point to any contiguous range within the array.

Aşağıdaki örnek 10 öğeli tamsayı dizisinin ikinci beş öğesi için bir dilim oluşturur.The following example creates a slice of the middle five elements of a 10-element integer array. Kodun, dilimin içindeki her bir tamsayının değerlerini çift katına bulunduğunu unutmayın.Note that the code doubles the values of each integer in the slice. Çıktıda gösterildiği gibi, yayılma tarafından yapılan değişiklikler dizinin değerlerine yansıtılır.As the output shows, the changes made by the span are reflected in the values of the array.

using System;

namespace span
{
    class Program
    {
        static void Main(string[] args)
        {
            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

Yayılma <T> ve dilimlerSpan<T> and slices

Span<T>Slicebelirtilen dizinde başlayan geçerli yayılımın dışına bir dilim oluşturan metodun iki aşırı yüklemesini içerir.Span<T> includes two overloads of the Slice method that form a slice out of the current span that starts at a specified index. Bu, verileri bir Span<T> veri işleme işlem hattının bölümlerinin gerektiği şekilde işleyebileceği bir mantıksal parçalar kümesi olarak, en düşük performans etkisinden değerlendirmek mümkün hale getirir.This makes it possible to treat the data in a Span<T> as a set of logical chunks that can be processed as needed by portions of a data processing pipeline with minimal performance impact. Örneğin, modern sunucu protokolleri genellikle metin tabanlı olduğundan dizelerin ve alt dizelerin işlenmesi özellikle önemlidir.For example, since modern server protocols are often text-based, manipulation of strings and substrings is particularly important. StringSınıfında, alt dizeleri ayıklamak için ana yöntem Substring .In the String class, the major method for extracting substrings is Substring. Kapsamlı dize düzenlemesi kullanan veri işlem hatları için kullanımı, bu yana bazı performans cezaları sunar:For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

  1. Alt dizeyi tutacak yeni bir dize oluşturur.Creates a new string to hold the substring.

  2. Özgün dizeden yeni dizeye karakterlerin bir alt kümesini kopyalar.Copies a subset of the characters from the original string to the new string.

Bu ayırma ve kopyalama işlemi, Span<T> ReadOnlySpan<T> Aşağıdaki örnekte gösterildiği gibi, veya kullanılarak ortadan kaldırılabilir:This allocation and copy operation can be eliminated by using either Span<T> or ReadOnlySpan<T>, as the following example shows:

using System;

class Program
{
    static void Main()
    {
        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

Oluşturucular

Span<T>(T[])

Span<T>Belirtilen dizinin tamamı üzerinde yeni bir nesne oluşturur.Creates a new Span<T> object over the entirety of a specified array.

Span<T>(T[], Int32, Int32)

Span<T>Belirtilen dizinden başlayarak bir dizinin belirtilen sayıda öğesini içeren yeni bir nesne oluşturur.Creates a new Span<T> object that includes a specified number of elements of an array starting at a specified index.

Span<T>(Void*, Int32)

Span<T>Belirtilen bir bellek adresinden başlayarak belirtilen sayıda öğeden yeni bir nesne oluşturur T .Creates a new Span<T> object from a specified number of T elements starting at a specified memory address.

Özellikler

Empty

Boş bir Span<T> nesne döndürür.Returns an empty Span<T> object.

IsEmpty

Geçerli değerin boş olup olmadığını gösteren bir değer döndürür Span<T> .Returns a value that indicates whether the current Span<T> is empty.

Item[Int32]

Belirtilen sıfır tabanlı dizindeki öğeyi alır.Gets the element at the specified zero-based index.

Length

Geçerli yayılma alanının uzunluğunu döndürür.Returns the length of the current span.

Yöntemler

Clear()

Bu nesnenin içeriğini temizler Span<T> .Clears the contents of this Span<T> object.

CopyTo(Span<T>)

Bunun içeriğini Span<T> bir hedefe kopyalar Span<T> .Copies the contents of this Span<T> into a destination Span<T>.

Equals(Object)
Kullanımdan kalktı.

Bu metoda yapılan çağrılar desteklenmez.Calls to this method are not supported.

Fill(T)

Bu yayılma alanının öğelerini belirtilen değerle doldurur.Fills the elements of this span with a specified value.

GetEnumerator()

Bunun için bir Numaralandırıcı döndürür Span<T> .Returns an enumerator for this Span<T>.

GetHashCode()
Kullanımdan kalktı.

Bir oluşturur NotSupportedException .Throws a NotSupportedException.

GetPinnableReference()

Sıfır dizinindeki öğesinin öğesine bir başvuru döndürür Span<T> .Returns a reference to the element of the Span<T> at index zero.

Slice(Int32)

Belirtilen dizinde başlayan geçerli yayılımın bir dilimini oluşturur.Forms a slice out of the current span that begins at a specified index.

Slice(Int32, Int32)

Belirtilen bir dizin için belirtilen bir dizinden başlayarak geçerli yayılma alanının dışına bir dilim oluşturur.Forms a slice out of the current span starting at a specified index for a specified length.

ToArray()

Bu yayılımın içeriğini yeni bir diziye kopyalar.Copies the contents of this span into a new array.

ToString()

Bu nesnenin dize gösterimini döndürür Span<T> .Returns the string representation of this Span<T> object.

TryCopyTo(Span<T>)

Geçerli bir hedefe kopyalamayı dener Span<T> Span<T> ve kopyalama işleminin başarılı olup olmadığını gösteren bir değer döndürür.Attempts to copy the current Span<T> to a destination Span<T> and returns a value that indicates whether the copy operation succeeded.

İşleçler

Equality(Span<T>, Span<T>)

İki nesnenin eşit olup olmadığını gösteren bir değer döndürür Span<T> .Returns a value that indicates whether two Span<T> objects are equal.

Implicit(ArraySegment<T> to Span<T>)

' A örtülü dönüşümünü tanımlar ArraySegment<T> Span<T> .Defines an implicit conversion of an ArraySegment<T> to a Span<T>.

Implicit(Span<T> to ReadOnlySpan<T>)

' A örtülü dönüşümünü tanımlar Span<T> ReadOnlySpan<T> .Defines an implicit conversion of a Span<T> to a ReadOnlySpan<T>.

Implicit(T[] to Span<T>)

Bir dizinin örtük bir şekilde dönüştürülmesini tanımlar Span<T> .Defines an implicit conversion of an array to a Span<T>.

Inequality(Span<T>, Span<T>)

İki nesnenin eşit olup olmadığını gösteren bir değer döndürür Span<T> .Returns a value that indicates whether two Span<T> objects are not equal.

Uzantı Metotları

BinarySearch<T>(Span<T>, IComparable<T>)

Span<T>Belirtilen genel arabirimi kullanarak bir değer için bir bütün sıralanmasını arar IComparable<T> .Searches an entire sorted Span<T> for a value using the specified IComparable<T> generic interface.

BinarySearch<T,TComparer>(Span<T>, T, TComparer)

Belirtilen Span<T> genel türü kullanarak belirtilen bir değer için bir bütün olarak bir sıralama arar TComparer .Searches an entire sorted Span<T> for a specified value using the specified TComparer generic type.

BinarySearch<T,TComparable>(Span<T>, TComparable)

Span<T>Belirtilen genel türü kullanarak bir değer için tüm sıralanmış bir değeri arar TComparable .Searches an entire sorted Span<T> for a value using the specified TComparable generic type.

Contains<T>(Span<T>, T)

Bir yayılma alanında belirtilen değerin bulunup bulunmadığını gösterir.Indicates whether a specified value is found in a span. Değerler IEquatable {T} kullanılarak karşılaştırılır. Eşittir (T).Values are compared using IEquatable{T}.Equals(T).

EndsWith<T>(Span<T>, ReadOnlySpan<T>)

Belirtilen dizinin bir yayılımın sonunda görünüp görünmeyeceğini belirler.Determines whether the specified sequence appears at the end of a span.

IndexOf<T>(Span<T>, T)

Belirtilen değeri arar ve ilk oluşumunun dizinini döndürür.Searches for the specified value and returns the index of its first occurrence. Değerler IEquatable {T} kullanılarak karşılaştırılır. Eşittir (T).Values are compared using IEquatable{T}.Equals(T).

IndexOf<T>(Span<T>, ReadOnlySpan<T>)

Belirtilen diziyi arar ve ilk oluşumunun dizinini döndürür.Searches for the specified sequence and returns the index of its first occurrence. Değerler IEquatable {T} kullanılarak karşılaştırılır. Eşittir (T).Values are compared using IEquatable{T}.Equals(T).

IndexOfAny<T>(Span<T>, T, T)

Mantıksal OR işleciyle IndexOf 'un birkaç kez çağrılmasına benzer şekilde, belirtilen değerlerin her birinin ilk dizinini arar.Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

IndexOfAny<T>(Span<T>, T, T, T)

Mantıksal OR işleciyle IndexOf 'un birkaç kez çağrılmasına benzer şekilde, belirtilen değerlerin her birinin ilk dizinini arar.Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

Mantıksal OR işleciyle IndexOf 'un birkaç kez çağrılmasına benzer şekilde, belirtilen değerlerin her birinin ilk dizinini arar.Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

LastIndexOf<T>(Span<T>, T)

Belirtilen değeri arar ve en son oluşumun dizinini döndürür.Searches for the specified value and returns the index of its last occurrence. Değerler IEquatable {T} kullanılarak karşılaştırılır. Eşittir (T).Values are compared using IEquatable{T}.Equals(T).

LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)

Belirtilen diziyi arar ve en son oluşumun dizinini döndürür.Searches for the specified sequence and returns the index of its last occurrence. Değerler IEquatable {T} kullanılarak karşılaştırılır. Eşittir (T).Values are compared using IEquatable{T}.Equals(T).

LastIndexOfAny<T>(Span<T>, T, T)

, Bir mantıksal OR işleciyle LastIndexOf 'ı birkaç kez çağırmaya benzer şekilde, belirtilen değerlerden herhangi birinin son dizinini arar.Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

LastIndexOfAny<T>(Span<T>, T, T, T)

, Bir mantıksal OR işleciyle LastIndexOf 'ı birkaç kez çağırmaya benzer şekilde, belirtilen değerlerden herhangi birinin son dizinini arar.Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

, Bir mantıksal OR işleciyle LastIndexOf 'ı birkaç kez çağırmaya benzer şekilde, belirtilen değerlerden herhangi birinin son dizinini arar.Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

Overlaps<T>(Span<T>, ReadOnlySpan<T>)

Bir yayılma ve salt okunurdur bir yayılımın bellek içinde örtüşme olup olmadığını belirler.Determines whether a span and a read-only span overlap in memory.

Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)

Bir yayılımın ve salt okunurdur bir yayılımın bellekte örtüşmesini ve öğenin kaydırılacağını belirler.Determines whether a span and a read-only span overlap in memory and outputs the element offset.

Reverse<T>(Span<T>)

Tüm yayılma alanındaki öğelerin dizisini tersine çevirir.Reverses the sequence of the elements in the entire span.

SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)

IComparable {T} kullanılarak öğeleri karşılaştırarak bir yayılma alanının göreli sırasını ve salt okunurdur belirler. CompareTo (T).Determines the relative order of a span and a read-only span by comparing the elements using IComparable{T}.CompareTo(T).

SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)

IEquatable {T} kullanılarak öğelerin karşılaştırılmasıyla bir yayılma ve salt okunurdur. Eşittir (T).Determines whether a span and a read-only span are equal by comparing the elements using IEquatable{T}.Equals(T).

Sort<T>(Span<T>)

Öğelerinin Span<T> IComparable<T> her bir öğesinin uygulamasını kullanarak tüm öğelerini sıralar. Span<T>Sorts the elements in the entire Span<T> using the IComparable<T> implementation of each element of the Span<T>

Sort<T>(Span<T>, Comparison<T>)

Tüm öğeleri Span<T> belirtilen kullanarak sıralar Comparison<T> .Sorts the elements in the entire Span<T> using the specified Comparison<T>.

Sort<T,TComparer>(Span<T>, TComparer)

Öğesinin tamamında öğelerini Span<T> kullanarak sıralar TComparer .Sorts the elements in the entire Span<T> using the TComparer.

Sort<TKey,TValue>(Span<TKey>, Span<TValue>)

Span<T>Her bir anahtarın uygulamasını kullanarak ilk içindeki anahtarlara bağlı olarak, yayılmaları çiftini (anahtarları ve ilgili öğeleri içeren diğeri) sıralar IComparable<T> .Sorts a pair of spans (one containing the keys and the other containing the corresponding items) based on the keys in the first Span<T> using the IComparable<T> implementation of each key.

Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)

Belirtilen karşılaştırmadan önce içindeki anahtarlara bağlı olarak, yayılmaların çiftini (anahtarları ve diğer öğeleri içeren bir tane) sıralar Span<T> .Sorts a pair of spans (one containing the keys and the other containing the corresponding items) based on the keys in the first Span<T> using the specified comparison.

Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)

Belirtilen karşılaştırıcıyı kullanarak ilk içindeki anahtarlara bağlı olarak, yayılmaları çiftini (anahtarları ve ilgili öğeleri içeren diğeri) sıralar Span<T> .Sorts a pair of spans (one containing the keys and the other containing the corresponding items) based on the keys in the first Span<T> using the specified comparer.

StartsWith<T>(Span<T>, ReadOnlySpan<T>)

Belirtilen bir dizinin bir yayılma başlangıcında görünüp görünmeyeceğini belirler.Determines whether a specified sequence appears at the start of a span.

Trim<T>(Span<T>, T)

Belirli bir öğenin tüm önde gelen ve sondaki tekrarlamalarını bir yayılım öğesinden kaldırır.Removes all leading and trailing occurrences of a specified element from a span.

Trim<T>(Span<T>, ReadOnlySpan<T>)

Bir yayılımın salt okunurdur bir yayılma alanında belirtilen bir öğe kümesinin tüm önde gelen ve sondaki oluşumlarını kaldırır.Removes all leading and trailing occurrences of a set of elements specified in a read-only span from a span.

TrimEnd<T>(Span<T>, T)

Belirtilen öğenin tüm sondaki oluşumlarını bir yayılım öğesinden kaldırır.Removes all trailing occurrences of a specified element from a span.

TrimEnd<T>(Span<T>, ReadOnlySpan<T>)

Bir yayılımın salt okunurdur bir yayılma alanında belirtilen öğelerin kümesinin tüm sondaki oluşumlarını kaldırır.Removes all trailing occurrences of a set of elements specified in a read-only span from a span.

TrimStart<T>(Span<T>, T)

Belirli bir öğenin tüm önde gelen oluşumlarını yayılım öğesinden kaldırır.Removes all leading occurrences of a specified element from the span.

TrimStart<T>(Span<T>, ReadOnlySpan<T>)

Yayılımın salt okunurdur bir yayılma alanında belirtilen öğelerin kümesinin tüm önde gelen oluşumlarını kaldırır.Removes all leading occurrences of a set of elements specified in a read-only span from the span.

Şunlara uygulanır

Ayrıca bkz.