Regex.EnumerateSplits Método

Definición

Espacio de nombres:

System.Text.RegularExpressions

Ensamblado:

System.Text.RegularExpressions.dll

Sobrecargas

EnumerateSplits(ReadOnlySpan<Char>)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.
EnumerateSplits(ReadOnlySpan<Char>, Int32)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.
EnumerateSplits(ReadOnlySpan<Char>, String)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.
EnumerateSplits(ReadOnlySpan<Char>, Int32, Int32)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.
EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.
EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)	Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

EnumerateSplits(ReadOnlySpan<Char>)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input);

public System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input);

member this.EnumerateSplits : ReadOnlySpan<char> -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Function EnumerateSplits (input As ReadOnlySpan(Of Char)) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator para iterar las coincidencias.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>) es similar al comportamiento de Split(String), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>) no. Y si se especifica RightToLeft, Split(String) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.

EnumerateSplits(ReadOnlySpan<Char>, Int32)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count);

public System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input, int count);

member this.EnumerateSplits : ReadOnlySpan<char> * int -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Function EnumerateSplits (input As ReadOnlySpan(Of Char), count As Integer) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

count

Int32

Número máximo de veces que se puede producir la división. Si es 0, todas las divisiones están disponibles.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator para iterar las coincidencias.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>, Int32) es similar al comportamiento de Split(String, Int32), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String, Int32) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>, Int32) no. Y si se especifica RightToLeft, Split(String, Int32) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>, Int32) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.

EnumerateSplits(ReadOnlySpan<Char>, String)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 static System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, System::String ^ pattern);

public static System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input, string pattern);

static member EnumerateSplits : ReadOnlySpan<char> * string -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Shared Function EnumerateSplits (input As ReadOnlySpan(Of Char), pattern As String) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator recorrer en iteración las divisiones alrededor de las coincidencias.

Excepciones

ArgumentNullException

pattern es null.

RegexParseException

Error de análisis de expresiones regulares.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>, String) es similar al comportamiento de Split(String, String), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String, String) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>, String) no. Y si se especifica RightToLeft, Split(String, String) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>, String) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.

EnumerateSplits(ReadOnlySpan<Char>, Int32, Int32)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count, int startat);

public System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input, int count, int startat);

member this.EnumerateSplits : ReadOnlySpan<char> * int * int -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Function EnumerateSplits (input As ReadOnlySpan(Of Char), count As Integer, startat As Integer) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

count

Int32

Número máximo de veces que se puede producir la división. Si es 0, todas las divisiones están disponibles.

startat

Int32

Posición de carácter de base cero en la que se va a iniciar la búsqueda.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator para iterar las coincidencias.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>, Int32, Int32) es similar al comportamiento de Split(String, Int32, Int32), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String, Int32, Int32) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>, Int32, Int32) no. Y si se especifica RightToLeft, Split(String, Int32, Int32) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>, Int32, Int32) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.

EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 static System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member EnumerateSplits : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Shared Function EnumerateSplits (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

options

RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones para la coincidencia.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator recorrer en iteración las divisiones alrededor de las coincidencias.

Excepciones

ArgumentNullException

pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions.

RegexParseException

Error de análisis de expresiones regulares.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions) es similar al comportamiento de Split(String, String, RegexOptions), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String, String, RegexOptions) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions) no. Y si se especifica RightToLeft, Split(String, String, RegexOptions) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.

EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Busca un intervalo de entrada para todas las apariciones de una expresión regular y devuelve un Regex.ValueSplitEnumerator para recorrer en iteración las divisiones alrededor de las coincidencias.

public:
 static System::Text::RegularExpressions::Regex::ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Regex.ValueSplitEnumerator EnumerateSplits (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member EnumerateSplits : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex.ValueSplitEnumerator

Public Shared Function EnumerateSplits (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Regex.ValueSplitEnumerator

Parámetros

input

ReadOnlySpan<Char>

Intervalo que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

options

RegexOptions

Combinación bit a bit de los valores de enumeración que especifican opciones para la coincidencia.

matchTimeout

TimeSpan

Intervalo de tiempo de espera o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

Devoluciones

Regex.ValueSplitEnumerator

Un Regex.ValueSplitEnumerator recorrer en iteración las divisiones alrededor de las coincidencias.

Excepciones

ArgumentNullException

pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions o matchTimeout es negativo, cero o mayor que aproximadamente 24 días.

RegexParseException

Error de análisis de expresiones regulares.

Comentarios

El comportamiento de EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) es similar al comportamiento de Split(String, String, RegexOptions, TimeSpan), lo que genera las divisiones una a la vez como parte de la iteración mediante el enumerador resultante en lugar de todo a la vez como parte de una sola matriz. Sin embargo, hay algunas diferencias notables. Split(String, String, RegexOptions, TimeSpan) incluirá el contenido de los grupos de captura en las divisiones resultantes, mientras que EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) no. Y si se especifica RightToLeft, Split(String, String, RegexOptions, TimeSpan) invertirá el orden de las divisiones resultantes de izquierda a derecha, mientras que EnumerateSplits(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan) producirá las divisiones en el orden en que se encuentran de derecha a izquierda.

Cada coincidencia no se producirá realmente hasta que se invoque MoveNext() en el enumerador, con una coincidencia realizada por MoveNext() llamada. Dado que la evaluación de la coincidencia se produce de forma diferida, los cambios realizados en la entrada pasada entre llamadas a MoveNext() pueden afectar a los resultados de la coincidencia; estos cambios deben evitarse y no se admiten.