Regex.Split Regex.Split Regex.Split Regex.Split Method

Definición

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por una coincidencia de expresión regular.Splits an input string into an array of substrings at the positions defined by a regular expression match.

Sobrecargas

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Las opciones especificadas modifican la operación de coincidencia.Specified options modify the matching operation.

Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La búsqueda del patrón de expresión regular se inicia en la posición de carácter especificada de la cadena de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, Int32) Split(String, Int32) Split(String, Int32) Split(String, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String) Split(String) Split(String) Split(String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un modelo de expresión regular especificado en el constructor Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, String) Split(String, String) Split(String, String) Split(String, String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to split.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Devoluciones

String[]

Matriz de cadenas.A string array.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es una combinación bit a bit válida de valores RegexOptions .options is not a valid bitwise combination of RegexOptions values.

o bien-or- matchTimeout es negativo, cero o mayor que 24 días aproximadamente.matchTimeout is negative, zero, or greater than approximately 24 days.

Se agotó un tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split(Char[]) al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La cadena se divide tantas veces como sea posible.The string is split as many times as possible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es input la cadena original.If no delimiter is found, the return value contains one element whose value is the original input string.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Las expresiones regulares compiladas que se Split usan en las llamadas a métodos estáticos se almacenan en caché automáticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para administrar la duración de las expresiones regulares compiladas, use Split los métodos de instancia.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por ejemplo, la división de una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentren dos guiones adyacentes.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. En el ejemplo siguiente se usa el patrón [a-z]+ de expresión regular para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz String.Emptydevuelta es.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si se usan paréntesis de captura en una Regex.Split expresión, se incluye cualquier texto capturado en la matriz de cadenas resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por ejemplo, si divide la cadena "ciruela-pera" en un guion colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En el .NET Framework 1,0 y 1,1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicionales no se incluye en la matriz devuelta.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado también se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra diagonal.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, excluye los caracteres de barra diagonal; Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, los incluye.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si la expresión regular puede coincidir con la cadena Split vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

El matchTimeout parámetro especifica cuánto tiempo un método de coincidencia de patrones debe intentar buscar una coincidencia antes de que se agote el tiempo de espera. Establecer un intervalo de tiempo de espera evita que las expresiones regulares que dependen de un retroceso excesivo parezcan dejar de responder cuando procesan entradas que contienen coincidencias cercanas.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Para obtener más información, vea procedimientos recomendados para expresiones regulares y retroceso.For more information, see Best Practices for Regular Expressions and Backtracking. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce RegexMatchTimeoutException una excepción.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeoutinvalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si se deshabilitan los tiempos de espera InfiniteMatchTimeoutespecificados, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Sin embargo, solo debe deshabilitar los tiempos de espera en las siguientes condiciones:However, you should disable time-outs only under the following conditions: : Cuando la entrada procesada por una expresión regular se deriva de una fuente conocida y de confianza o está formada por texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Esto excluye el texto que los usuarios han introducido dinámicamente.This excludes text that has been dynamically input by users.

-Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla de forma eficaz las coincidencias, las no coincidencias y las coincidencias cercanas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que producen un retroceso excesivo al procesar una coincidencia cercana.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Consulte también:

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Las opciones especificadas modifican la operación de coincidencia.Specified options modify the matching operation.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to split.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.A bitwise combination of the enumeration values that provide options for matching.

Devoluciones

String[]

Matriz de cadenas.An array of strings.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es una combinación bit a bit válida de valores RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split(Char[]) al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La cadena se divide tantas veces como sea posible.The string is split as many times as possible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es input la cadena original.If no delimiter is found, the return value contains one element whose value is the original input string.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Las expresiones regulares compiladas que se Split usan en las llamadas a métodos estáticos se almacenan en caché automáticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para administrar la duración de las expresiones regulares compiladas, use Split los métodos de instancia.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por ejemplo, la división de una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentren dos guiones adyacentes.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. En el ejemplo siguiente se usa el patrón [a-z]+ de expresión regular para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz String.Emptydevuelta es.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si se usan paréntesis de captura en una Regex.Split expresión, se incluye cualquier texto capturado en la matriz de cadenas resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por ejemplo, si divide la cadena "ciruela-pera" en un guion colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En el .NET Framework 1,0 y 1,1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicionales no se incluye en la matriz devuelta.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado también se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra diagonal.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, excluye los caracteres de barra diagonal; Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, los incluye.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si la expresión regular puede coincidir con la cadena Split vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

Se RegexMatchTimeoutException produce la excepción si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo Regex.InfiniteMatchTimeoutde espera es, no se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, InfiniteMatchTimeoutse utiliza el valor, que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consulte también:

Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La búsqueda del patrón de expresión regular se inicia en la posición de carácter especificada de la cadena de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);
public string[] Split (string input, int count, int startat);
member this.Split : string * int * int -> string[]
Public Function Split (input As String, count As Integer, startat As Integer) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to be split.

count
Int32 Int32 Int32 Int32

Número máximo de veces que puede llevarse a cabo la división.The maximum number of times the split can occur.

startat
Int32 Int32 Int32 Int32

Posición de carácter de la cadena de entrada donde comenzará la búsqueda.The character position in the input string where the search will begin.

Devoluciones

String[]

Matriz de cadenas.An array of strings.

Excepciones

startat es menor que cero o mayor que la longitud de input.startat is less than zero or greater than the length of input.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. El count parámetro especifica el número máximo de subcadenas en las que input se divide la cadena; la última cadena contiene el resto de la cadena sin dividir.The count parameter specifies the maximum number of substrings into which the input string is split; the last string contains the unsplit remainder of the string. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible.A count value of zero provides the default behavior of splitting as many times as possible. El startat parámetro define el punto en el que comienza la búsqueda del primer delimitador (se puede usar para omitir el espacio en blanco inicial).The startat parameter defines the point at which the search for the first delimiter begins (this can be used for skipping leading white space).

Si no se encuentra ninguna coincidencia en countla posición + 1 de la cadena, el método devuelve una matriz de un solo elemento que input contiene la cadena.If no matches are found from the count+1 position in the string, the method returns a one-element array that contains the input string. Si se encuentran una o varias coincidencias, el primer elemento de la matriz devuelta contiene la primera parte de la cadena del primer carácter hasta un carácter antes de la coincidencia.If one or more matches are found, the first element of the returned array contains the first portion of the string from the first character up to one character before the match.

Si hay varias coincidencias adyacentes entre sí y el número de coincidencias encontradas es al countmenos dos menos que, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another and the number of matches found is at least two less than count, an empty string is inserted into the array. Del mismo modo, si se encuentra una startatcoincidencia en, que es el primer carácter de la cadena, el primer elemento de la matriz devuelta es una cadena vacía.Similarly, if a match is found at startat, which is the first character in the string, the first element of the returned array is an empty string. Es decir, las cadenas vacías que se derivan de coincidencias adyacentes se cuentan para determinar si el número de countsubcadenas coincidentes es igual a.That is, empty strings that result from adjacent matches are counted in determining whether the number of matched substrings equals count. En el ejemplo siguiente, la expresión \d+ regular se usa para buscar la posición inicial de la primera subcadena de caracteres numéricos de una cadena y, a continuación, dividir la cadena un máximo de tres veces a partir de esa posición.In the following example, the regular expression \d+ is used to find the starting position of the first substring of numeric characters in a string, and then to split the string a maximum of three times starting at that position. Dado que el patrón de expresión regular coincide con el principio de la cadena de entrada, la matriz de cadenas devuelta consta de una cadena vacía, una cadena alfabética de cinco caracteres y el resto de la cadena.Because the regular expression pattern matches the beginning of the input string, the returned string array consists of an empty string, a five-character alphabetic string, and the remainder of the string,

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si se usan paréntesis de captura en una expresión regular, cualquier texto capturado se incluye en la matriz de cadenas de división.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si se ha alcanzado countel número de coincidencias.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Por ejemplo, la división de la cadena "" Apple-albaricoque-ciruela-pera-Granada-piña-melocotón "en un máximo de cuatro subcadenas a partir del carácter 15 de la cadena da como resultado una matriz de siete elementos, como se muestra en el código siguiente.For example, splitting the string '"apple-apricot-plum-pear-pomegranate-pineapple-peach" into a maximum of four substrings beginning at character 15 in the string results in a seven-element array, as the following code shows.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En .NET Framework 1,0 y 1,1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicionales no se incluye en la matriz devuelta.In .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado también se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer las palabras individuales de una cadena.For example, the following code uses two sets of capturing parentheses to extract the individual words in a string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra vertical.The first set of capturing parentheses captures the hyphen, and the second set captures the vertical bar. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, excluye los caracteres de barra vertical; Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, los incluye.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the vertical bar characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Si la expresión regular puede coincidir con la cadena Split vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. En el ejemplo siguiente se divide la cadena "Characters" en todos los elementos que contiene la cadena de entrada, comenzando por el carácter "a".The following example splits the string "characters" into as many elements as the input string contains, starting with the character "a". Dado que la cadena nula coincide con el final de la cadena de entrada, se inserta una cadena nula al final de la matriz devuelta.Because the null string matches the end of the input string, a null string is inserted at the end of the returned array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Se RegexMatchTimeoutException produce la excepción si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera Regex.Regex(String, RegexOptions, TimeSpan) especificado por el constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no se define ningún tiempo de espera en Regex la llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de Regex.InfiniteMatchTimeouttiempo de espera es, no se produce ninguna excepción.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Consulte también:

Split(String, Int32) Split(String, Int32) Split(String, Int32) Split(String, Int32)

Divide una cadena de entrada por un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count);
public string[] Split (string input, int count);
member this.Split : string * int -> string[]
Public Function Split (input As String, count As Integer) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to be split.

count
Int32 Int32 Int32 Int32

Número máximo de veces que puede llevarse a cabo la división.The maximum number of times the split can occur.

Devoluciones

String[]

Matriz de cadenas.An array of strings.

Excepciones

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. El count parámetro especifica el número máximo de subcadenas en las que input se puede dividir la cadena; la última cadena contiene el resto de la cadena sin dividir.The count parameter specifies the maximum number of substrings into which the input string can be split; the last string contains the unsplit remainder of the string. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible.A count value of zero provides the default behavior of splitting as many times as possible.

Si hay varias coincidencias adyacentes entre sí o si se encuentra una coincidencia al principio o al inputfinal de, y el número de coincidencias encontradas es al countmenos dos menor que, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another or if a match is found at the beginning or end of input, and the number of matches found is at least two less than count, an empty string is inserted into the array. Es decir, las cadenas vacías que se derivan de coincidencias adyacentes o de coincidencias al principio o al final de la cadena de entrada se cuentan para determinar si countel número de subcadenas coincidentes es igual a.That is, empty strings that result from adjacent matches or from matches at the beginning or end of the input string are counted in determining whether the number of matched substrings equals count. En el ejemplo siguiente, la expresión /d+ regular se usa para dividir una cadena de entrada que incluye uno o más dígitos decimales en un máximo de tres subcadenas.In the following example, the regular expression /d+ is used to split an input string that includes one or more decimal digits into a maximum of three substrings. Dado que el principio de la cadena de entrada coincide con el patrón de expresión regular, el String.Emptyprimer elemento de la matriz contiene, el segundo contiene el primer conjunto de caracteres alfabéticos de la cadena de entrada y el tercero contiene el resto de la cadena. que sigue a la tercera coincidencia.Because the beginning of the input string matches the regular expression pattern, the first array element contains String.Empty, the second contains the first set of alphabetic characters in the input string, and the third contains the remainder of the string that follows the third match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si se usan paréntesis de captura en una expresión regular, cualquier texto capturado se incluye en la matriz de cadenas de división.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si se ha alcanzado countel número de coincidencias.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Por ejemplo, la división de la cadena "Apple-albaricoque-ciruela-pera-banana" en un máximo de cuatro subcadenas da como resultado una matriz de siete elementos, como se muestra en el código siguiente.For example, splitting the string "apple-apricot-plum-pear-banana" into a maximum of four substrings results in a seven-element array, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En el .NET Framework 1,0 y 1,1, solo se incluye en la matriz devuelta el texto capturado del primer conjunto de paréntesis de captura.In the .NET Framework 1.0 and 1.1, only captured text from the first set of capturing parentheses is included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is added to the returned array. Sin embargo, los elementos de la matriz devuelta que contienen texto capturado no se cuentan para determinar si el número de subcadenas coincidentes es igual counta.However, elements in the returned array that contain captured text are not counted in determining whether the number of matched substrings equals count. Por ejemplo, en el código siguiente, una expresión regular utiliza dos conjuntos de paréntesis de captura para extraer los elementos de una fecha de una cadena de fecha.For example, in the following code, a regular expression uses two sets of capturing parentheses to extract the elements of a date from a date string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra diagonal.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. La llamada al Split(String, Int32) método especifica un máximo de dos elementos en la matriz devuelta.The call to the Split(String, Int32) method then specifies a maximum of two elements in the returned array. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, el método devuelve una matriz de cadenas de dos elementos.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, the method returns a two-element string array. Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, el método devuelve una matriz de cadenas de tres elementos.If it is compiled and run under the .NET Framework 2.0 or later versions, the method returns a three-element string array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007' 

Si la expresión regular puede coincidir con la cadena Split(String, Int32) vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split(String, Int32) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. En el ejemplo siguiente se divide la cadena "Characters" en tantos elementos como se encuentren en la cadena de entrada.The following example splits the string "characters" into as many elements as there are in the input string. Dado que la cadena nula coincide con el principio de la cadena de entrada, se inserta una cadena nula al principio de la matriz devuelta.Because the null string matches the beginning of the input string, a null string is inserted at the beginning of the returned array. Esto hace que el décimo elemento conste de los dos caracteres al final de la cadena de entrada.This causes the tenth element to consist of the two characters at the end of the input string.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Se RegexMatchTimeoutException produce la excepción si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera Regex.Regex(String, RegexOptions, TimeSpan) especificado por el constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no se define ningún tiempo de espera en Regex la llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de Regex.InfiniteMatchTimeouttiempo de espera es, no se produce ninguna excepción.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Consulte también:

Split(String) Split(String) Split(String) Split(String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un modelo de expresión regular especificado en el constructor Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);
public string[] Split (string input);
member this.Split : string -> string[]
Public Function Split (input As String) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to split.

Devoluciones

String[]

Matriz de cadenas.An array of strings.

Excepciones

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split(Char[]) al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La cadena se divide tantas veces como sea posible.The string is split as many times as possible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de entrada original.If no delimiter is found, the return value contains one element whose value is the original input string.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por ejemplo, la división de una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentren dos guiones adyacentes, como se muestra en el código siguiente.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. En el ejemplo siguiente se usa el patrón \d+ de expresión regular para dividir una cadena de entrada en caracteres numéricos.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la String.Emptymatriz devuelta es.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si se usan paréntesis de captura en una Regex.Split expresión, se incluye cualquier texto capturado en la matriz de cadenas resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por ejemplo, si divide la cadena "ciruela-pera" en un guion colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En el .NET Framework 1,0 y 1,1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicionales no se incluye en la matriz devuelta.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado también se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra diagonal.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, excluye los caracteres de barra diagonal; Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, los incluye.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si la expresión regular puede coincidir con la cadena Split(String) vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split(String) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Por ejemplo:For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }
Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

Tenga en cuenta que la matriz devuelta también incluye una cadena vacía al principio y al final de la matriz.Note that the returned array also includes an empty string at the beginning and end of the array.

Se RegexMatchTimeoutException produce la excepción si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera Regex.Regex(String, RegexOptions, TimeSpan) especificado por el constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no se define ningún tiempo de espera en Regex la llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de Regex.InfiniteMatchTimeouttiempo de espera es, no se produce ninguna excepción.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Consulte también:

Split(String, String) Split(String, String) Split(String, String) Split(String, String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);
public static string[] Split (string input, string pattern);
static member Split : string * string -> string[]
Public Shared Function Split (input As String, pattern As String) As String()

Parámetros

input
String String String String

Cadena que se va a dividir.The string to split.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias.The regular expression pattern to match.

Devoluciones

String[]

Matriz de cadenas.An array of strings.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Comentarios

Los Regex.Split métodos son similares String.Split al método, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La input cadena se divide tantas veces como sea posible.The input string is split as many times as possible. Si pattern no se encuentra en la input cadena, el valor devuelto contiene un elemento cuyo valor es la input cadena original.If pattern is not found in the input string, the return value contains one element whose value is the original input string.

El pattern parámetro se compone de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Las expresiones regulares compiladas que se Split usan en las llamadas a métodos estáticos se almacenan en caché automáticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para administrar la duración de las expresiones regulares compiladas, use Split los métodos de instancia.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por ejemplo, la división de una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentren dos guiones adyacentes, como se muestra en el código siguiente.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. En el ejemplo siguiente se usa el patrón \d+ de expresión regular para dividir una cadena de entrada en caracteres numéricos.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la String.Emptymatriz devuelta es.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si se usan paréntesis de captura en una Regex.Split expresión, se incluye cualquier texto capturado en la matriz de cadenas resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por ejemplo, si divide la cadena "ciruela-pera" en un guion colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de la .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. En el .NET Framework 1,0 y 1,1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicionales no se incluye en la matriz devuelta.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir del .NET Framework 2,0, todo el texto capturado también se agrega a la matriz devuelta.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. El primer conjunto de paréntesis de captura captura el guión y el segundo conjunto captura la barra diagonal.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si el código de ejemplo se compila y se ejecuta en el .NET Framework 1,0 o 1,1, excluye los caracteres de barra diagonal; Si se compila y se ejecuta en el .NET Framework 2,0 o versiones posteriores, los incluye.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si la expresión regular puede coincidir con la cadena Split vacía, dividirá la cadena en una matriz de cadenas de un solo carácter, ya que el delimitador de cadena vacía se puede encontrar en cada ubicación.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Por ejemplo:For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Tenga en cuenta que la matriz devuelta también incluye una cadena vacía al principio y al final de la matriz.Note that the returned array also includes an empty string at the beginning and end of the array.

Se RegexMatchTimeoutException produce la excepción si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo Regex.InfiniteMatchTimeoutde espera es, no se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, InfiniteMatchTimeoutse utiliza el valor, que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consulte también:

Se aplica a