Span<T> Span<T> Span<T> Span<T> Struct

Definice

Poskytuje reprezentaci typu a bezpečné paměti pro souvislý region libovolné paměti.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)

Parametry typu

T

Typ položek v Span<T>.The type of items in the Span<T>.

Dědičnost

Poznámky

Span<T>je Struktura ref , která je přidělena zásobníku místo na spravované haldě.Span<T> is a ref struct that is allocated on the stack rather than on the managed heap. Typy referenční struktury mají několik omezení, aby bylo zajištěno, že nelze povýšit na spravovanou haldu, včetně toho, že nemohou být zabalené, nelze je přiřadit proměnným dynamic typu Objectnebo jakémukoli typu rozhraní, nemohou být pole v odkazový typ a nemůže být použit napříč await hranicemi a. yieldRef 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. Kromě toho volání dvou metod, Equals(Object) a GetHashCodevyvolávají NotSupportedExceptiona.In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

Důležité

Vzhledem k tomu, že se jedná o typ Span<T> pouze zásobníku, není vhodný pro mnoho scénářů, které vyžadují ukládání odkazů na vyrovnávací paměti v haldě.Because it is a stack-only type, Span<T> is unsuitable for many scenarios that require storing references to buffers on the heap. To je pravdivé například rutiny, které provádí volání asynchronní metody.This is true, for example, of routines that make asynchronous method calls. V takových scénářích můžete použít doplňkový System.Memory<T> typ a. System.ReadOnlyMemory<T>For such scenarios, you can use the complementary System.Memory<T> and System.ReadOnlyMemory<T> types.

Pro rozsahy, které reprezentují neproměnlivé struktury nebo System.ReadOnlySpan<T>jen pro čtení, použijte.For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

Rozsah<T > a paměťSpan<T> and memory

Span<T> Představuje souvislou oblast libovolné paměti.A Span<T> represents a contiguous region of arbitrary memory. Span<T> Instance se často používá k uchování prvků pole nebo části pole.A Span<T> instance is often used to hold the elements of an array or a portion of an array. Na rozdíl od pole může Span<T> instance ale odkazovat na spravovanou paměť, nativní paměť nebo paměť spravovanou v zásobníku.Unlike an array, however, a Span<T> instance can point to managed memory, native memory, or memory managed on the stack. Následující příklad vytvoří Span<Byte> z pole: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

Následující příklad vytvoří Span<Byte> z nativní paměti z 100 bajtů.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

Následující příklad používá C# klíčové slovo stackalloc k přidělení 100 bajtů paměti v zásobníku: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

Vzhledem Span<T> k tomu, že se jedná o abstrakci přes libovolný blok paměti, Span<T> metody třídy a metody Span<T> s parametry fungují na Span<T> jakémkoli objektu bez ohledu na druh paměti, kterou zapouzdřuje.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. Například každý z samostatných sekcí kódu, který inicializuje rozsah a vypočítá součet jeho prvků, lze změnit na jedinou inicializaci a metody výpočtu, jak ukazuje následující příklad: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

Rozsah<T > a poleSpan<T> and arrays

Při zalamování pole Span<T> může být zabalení celého pole, stejně jako v příkladech v sekci > rozsahu<T a paměti .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. Vzhledem k tomu, že podporuje Span<T> vytváření řezů, může také ukazovat na libovolný souvislý rozsah v rámci pole.Because it supports slicing, Span<T> can also point to any contiguous range within the array.

Následující příklad vytvoří řez ze středních pěti prvků pole celé číslo s 10 prvky.The following example creates a slice of the middle five elements of a 10-element integer array. Všimněte si, že kód zdvojnásobí hodnoty každého celého čísla v řezu.Note that the code doubles the values of each integer in the slice. Jak ukazuje výstup, změny provedené v rozpětí se projeví v hodnotách pole.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

Rozpětí<T > a řezůSpan<T> and slices

Span<T>obsahuje dvě přetížení Slice metody, která tvoří řez mimo aktuální rozsah, který začíná zadaným indexem.Span<T> includes two overloads of the Slice method that form a slice out of the current span that starts at a specified index. Díky tomu je možné považovat data za Span<T> sadu logických bloků dat, které mohou být zpracovány podle potřeby pomocí částí kanálu zpracování dat s minimálním dopadem na výkon.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. Například vzhledem k tomu, že moderní serverové protokoly jsou často založené na textu, manipulace s řetězci a podřetězci jsou obzvláště důležité.For example, since modern server protocols are often text-based, manipulation of strings and substrings is particularly important. Ve třídě je Substringhlavní metodou pro extrakci podřetězců. StringIn the String class, the major method for extracting substrings is Substring. U datových kanálů, které spoléhají na rozsáhlou manipulaci s řetězci, jejich použití nabízí některé antipokuty výkonu, protože:For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

  1. Vytvoří nový řetězec pro uložení podřetězce.Creates a new string to hold the substring.

  2. Zkopíruje podmnožinu znaků z původního řetězce do nového řetězce.Copies a subset of the characters from the original string to the new string.

Tato operace přidělení a kopírování může být eliminována buď Span<T> pomocí, nebo ReadOnlySpan<T>, jak ukazuje následující příklad: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

Konstruktory

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

Vytvoří nový Span<T> objekt za celým zadaným polem.Creates a new Span<T> object over the entirety of a specified array.

Span<T>(Void*, Int32) Span<T>(Void*, Int32) Span<T>(Void*, Int32) Span<T>(Void*, Int32)

Vytvoří nový Span<T> objekt ze zadaného T počtu prvků počínaje zadanou adresou paměti.Creates a new Span<T> object from a specified number of T elements starting at a specified memory address.

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

Vytvoří nový Span<T> objekt, který obsahuje zadaný počet prvků pole, počínaje zadaným indexem.Creates a new Span<T> object that includes a specified number of elements of an array starting at a specified index.

Vlastnosti

Empty Empty Empty Empty

Vrátí prázdný Span<T> objekt.Returns an empty Span<T> object.

IsEmpty IsEmpty IsEmpty IsEmpty

Vrátí hodnotu, která označuje, zda je Span<T> aktuální hodnota prázdná.Returns a value that indicates whether the current Span<T> is empty.

Item[Int32] Item[Int32] Item[Int32] Item[Int32]

Získá element v zadaném indexu založeném na nule.Gets the element at the specified zero-based index.

Length Length Length Length

Vrátí délku aktuálního rozsahu.Returns the length of the current span.

Metody

Clear() Clear() Clear() Clear()

Vymaže obsah tohoto Span<T> objektu.Clears the contents of this Span<T> object.

CopyTo(Span<T>) CopyTo(Span<T>) CopyTo(Span<T>) CopyTo(Span<T>)

Zkopíruje obsah tohoto Span<T> obsahu do cílového umístění Span<T>.Copies the contents of this Span<T> into a destination Span<T>.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Volání této metody nejsou podporována.Calls to this method are not supported.

Fill(T) Fill(T) Fill(T) Fill(T)

Vyplní prvky tohoto rozsahu zadanou hodnotou.Fills the elements of this span with a specified value.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Vrátí enumerátor pro this Span<T>.Returns an enumerator for this Span<T>.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Vyvolá výjimku NotSupportedException.Throws a NotSupportedException.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

Vrátí odkaz na element Span<T> s indexem s hodnotou nula.Returns a reference to the element of the Span<T> at index zero.

Slice(Int32) Slice(Int32) Slice(Int32) Slice(Int32)

Vytvoří řez z aktuálního rozsahu, který začíná zadaným indexem.Forms a slice out of the current span that begins at a specified index.

Slice(Int32, Int32) Slice(Int32, Int32) Slice(Int32, Int32) Slice(Int32, Int32)

Vytvoří řez z aktuálního rozsahu začínajícího zadaným indexem o zadanou délku.Forms a slice out of the current span starting at a specified index for a specified length.

ToArray() ToArray() ToArray() ToArray()

Zkopíruje obsah tohoto rozsahu do nového pole.Copies the contents of this span into a new array.

ToString() ToString() ToString() ToString()

Vrátí řetězcovou reprezentaci tohoto Span<T> objektu.Returns the string representation of this Span<T> object.

TryCopyTo(Span<T>) TryCopyTo(Span<T>) TryCopyTo(Span<T>) TryCopyTo(Span<T>)

Pokusí se zkopírovat aktuální Span<T> cíl do cíle Span<T> a vrátí hodnotu, která označuje, zda operace kopírování proběhla úspěšně.Attempts to copy the current Span<T> to a destination Span<T> and returns a value that indicates whether the copy operation succeeded.

Operátory

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

Vrátí hodnotu, která označuje, zda Span<T> jsou dva objekty stejné.Returns a value that indicates whether two Span<T> objects are equal.

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

Definuje implicitní převod ArraySegment<T> typu Span<T>na.Defines an implicit conversion of an ArraySegment<T> to a Span<T>.

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

Definuje implicitní převod typu Span<T> ReadOnlySpan<T>na.Defines an implicit conversion of a Span<T> to a ReadOnlySpan<T>.

Implicit(T[] to Span<T>) Implicit(T[] to Span<T>) Implicit(T[] to Span<T>) Implicit(T[] to Span<T>)

Definuje implicitní převod pole na Span<T>.Defines an implicit conversion of an array to a Span<T>.

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

Vrátí hodnotu, která označuje, zda Span<T> dva objekty nejsou stejné.Returns a value that indicates whether two Span<T> objects are not equal.

Metody rozšíření

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

Vyhledá celý seřazený Span<T> údaj o hodnotě pomocí zadaného IComparable<T> obecného rozhraní.Searches an entire sorted Span<T> for a value using the specified IComparable<T> generic interface.

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

Vyhledá celé řazení Span<T> zadané hodnoty pomocí zadaného TComparer obecného typu.Searches an entire sorted Span<T> for a specified value using the specified TComparer generic type.

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

Vyhledá celé řazení Span<T> hodnoty pomocí zadaného TComparable obecného typu.Searches an entire sorted Span<T> for a value using the specified TComparable generic type.

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

Označuje, zda je zadaná hodnota nalezena v rozpětí.Indicates whether a specified value is found in a span. Hodnoty se porovnávají pomocí IEquatable {T}. Equals (T).Values are compared using IEquatable{T}.Equals(T).

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

Určuje, zda se zadaná sekvence zobrazuje na konci rozsahu.Determines whether the specified sequence appears at the end of a span.

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

Vyhledá zadanou hodnotu a vrátí index svého prvního výskytu.Searches for the specified value and returns the index of its first occurrence. Hodnoty se porovnávají pomocí IEquatable {T}. Equals (T).Values are compared using IEquatable{T}.Equals(T).

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

Vyhledá zadanou sekvenci a vrátí index jeho prvního výskytu.Searches for the specified sequence and returns the index of its first occurrence. Hodnoty se porovnávají pomocí IEquatable {T}. Equals (T).Values are compared using IEquatable{T}.Equals(T).

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

Vyhledá první index libovolné z určených hodnot podobný volání metody IndexOf několikrát s logickým operátorem OR.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) IndexOfAny<T>(Span<T>, T, T, T) IndexOfAny<T>(Span<T>, T, T, T) IndexOfAny<T>(Span<T>, T, T, T)

Vyhledá první index libovolné z určených hodnot podobný volání metody IndexOf několikrát s logickým operátorem OR.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>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

Vyhledá první index libovolné z určených hodnot podobný volání metody IndexOf několikrát s logickým operátorem OR.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) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T)

Vyhledá zadanou hodnotu a vrátí index posledního výskytu.Searches for the specified value and returns the index of its last occurrence. Hodnoty se porovnávají pomocí IEquatable {T}. Equals (T).Values are compared using IEquatable{T}.Equals(T).

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

Vyhledá zadanou sekvenci a vrátí index posledního výskytu.Searches for the specified sequence and returns the index of its last occurrence. Hodnoty se porovnávají pomocí IEquatable {T}. Equals (T).Values are compared using IEquatable{T}.Equals(T).

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

Vyhledá poslední index některé z určených hodnot, podobně jako volání metody LastIndexOf v rámci logického operátoru OR.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) LastIndexOfAny<T>(Span<T>, T, T, T) LastIndexOfAny<T>(Span<T>, T, T, T) LastIndexOfAny<T>(Span<T>, T, T, T)

Vyhledá poslední index některé z určených hodnot, podobně jako volání metody LastIndexOf v rámci logického operátoru OR.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>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

Vyhledá poslední index některé z určených hodnot, podobně jako volání metody LastIndexOf v rámci logického operátoru OR.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>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>)

Určuje, zda se rozsah a rozsah určený jen pro čtení překrývá v paměti.Determines whether a span and a read-only span overlap in memory.

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

Určuje, zda se rozsah a rozsah jen pro čtení překrývají v paměti a výstup posunu prvku.Determines whether a span and a read-only span overlap in memory and outputs the element offset.

Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>)

Obrátí sekvenci prvků v celém rozsahu.Reverses the sequence of the elements in the entire span.

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

Určuje relativní pořadí rozsahu a rozsah jen pro čtení porovnáním prvků pomocí rozhraní IComparable {T}. 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>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)

Určuje, zda je rozsah a rozsah, který je jen pro čtení, shodný s porovnáním prvků pomocí IEquatable {T}. Equals (T).Determines whether a span and a read-only span are equal by comparing the elements using IEquatable{T}.Equals(T).

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

Určuje, zda se zadaná sekvence zobrazuje na začátku rozsahu.Determines whether a specified sequence appears at the start of a span.

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

Odebere všechny úvodní a koncové výskyty zadaného elementu z rozsahu.Removes all leading and trailing occurrences of a specified element from a span.

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

Odebere všechny úvodní a koncové výskyty sady prvků určených v rozsahu určeném jen pro čtení z rozsahu.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) TrimEnd<T>(Span<T>, T) TrimEnd<T>(Span<T>, T) TrimEnd<T>(Span<T>, T)

Odebere všechny koncové výskyty zadaného elementu z rozsahu.Removes all trailing occurrences of a specified element from a span.

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

Odebere všechny koncové výskyty sady prvků určených v rozsahu určeném pouze pro čtení z rozsahu.Removes all trailing occurrences of a set of elements specified in a read-only span from a span.

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

Odebere všechny úvodní výskyty zadaného elementu z rozsahu.Removes all leading occurrences of a specified element from the span.

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

Odebere všechny úvodní výskyty sady prvků určených v rozsahu určeném pouze pro čtení z rozsahu.Removes all leading occurrences of a set of elements specified in a read-only span from the span.

Platí pro