Regex.Split Método

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición donde se encuentran dos guiones adyacentes.

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. En el ejemplo siguiente se usa el patrón de expresión regular [a-z]+ para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz devuelta es 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 expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

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 .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 adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. 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. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

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 vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación.

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

• Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

• Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

• Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

• elementos del lenguaje de expresiones regulares

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición donde se encuentran dos guiones adyacentes.

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. En el ejemplo siguiente se usa el patrón de expresión regular [a-z]+ para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz devuelta es 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 expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

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 .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 adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. 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. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

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 vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación.

La excepción RegexMatchTimeoutException se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método . Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• elementos del lenguaje de expresiones regulares

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. El parámetro count especifica el número máximo de subcadenas en las que se divide la cadena input; la última cadena contiene el resto sin dividir de la cadena. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible. El parámetro startat define el punto en el que comienza la búsqueda del primer delimitador (se puede usar para omitir el espacio en blanco inicial).

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

Si no se encuentran coincidencias desde la posición count+1 de la cadena, el método devuelve una matriz de un elemento que contiene la cadena input. 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.

Si hay varias coincidencias adyacentes entre sí y el número de coincidencias encontradas es al menos dos menos que count, se inserta una cadena vacía en la matriz. Del mismo modo, si se encuentra una coincidencia en startat, que es el primer carácter de la cadena, el primer elemento de la matriz devuelta es una cadena vacía. Es decir, las cadenas vacías resultantes de coincidencias adyacentes se cuentan para determinar si el número de subcadenas coincidentes es igual a count. En el ejemplo siguiente, la expresión regular \d+ se usa para buscar la posición inicial de la primera subcadena de caracteres numéricos en una cadena y, a continuación, para dividir la cadena un máximo de tres veces a partir de esa posición. 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,

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 divididas. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si el número de coincidencias ha alcanzado count. Por ejemplo, dividir la cadena '"apple-apricot-plum-pear-pomegranate-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.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'

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 .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia dentro del primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer las palabras individuales de una cadena. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra vertical. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra vertical; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

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 vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. En el ejemplo siguiente se divide la cadena "characters" en tantos elementos como contiene la cadena de entrada, empezando por el carácter "a". Dado que la cadena null coincide con el final de la cadena de entrada, se inserta una cadena null al final de la matriz devuelta.

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}

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena input se divide tantas veces como sea posible. Si no se encuentra pattern en la cadena input, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir 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 encuentran dos guiones adyacentes, como se muestra en el código siguiente.

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. En el ejemplo siguiente se usa el patrón de expresión regular \d+ para dividir una cadena de entrada en caracteres numéricos. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la matriz devuelta es 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 expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

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 .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 adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. 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. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

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 vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. Por ejemplo:

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.

La excepción RegexMatchTimeoutException se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método . Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• elementos del lenguaje de expresiones regulares

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de entrada original.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir 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 encuentran dos guiones adyacentes, como se muestra en el código siguiente.

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. En el ejemplo siguiente se usa el patrón de expresión regular \d+ para dividir una cadena de entrada en caracteres numéricos. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la matriz devuelta es 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 expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

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 .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 adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. 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. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

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 vacía, Split(String) dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. Por ejemplo:

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.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Devoluciones

Matriz de cadenas.

Excepciones

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. El parámetro count especifica el número máximo de subcadenas en las que se puede dividir la cadena input; la última cadena contiene el resto sin dividir de la cadena. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible.

Si hay varias coincidencias adyacentes entre sí o si se encuentra una coincidencia al principio o al final de input, y el número de coincidencias encontradas es al menos dos menos que count, se inserta una cadena vacía en la matriz. Es decir, las cadenas vacías resultantes de coincidencias adyacentes o de coincidencias al principio o al final de la cadena de entrada se cuentan para determinar si el número de subcadenas coincidentes es igual a count. En el ejemplo siguiente, la expresión regular /d+ se usa para dividir una cadena de entrada que incluya uno o varios dígitos decimales en un máximo de tres subcadenas. Dado que el principio de la cadena de entrada coincide con el patrón de expresión regular, el primer elemento de matriz contiene String.Empty, el segundo contiene el primer conjunto de caracteres alfabéticos en la cadena de entrada y el tercero contiene el resto de la cadena que sigue a la tercera coincidencia.

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 divididas. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si el número de coincidencias ha alcanzado count. Por ejemplo, dividir la cadena "apple-apricot-plum-pear-banana" en un máximo de cuatro subcadenas da como resultado una matriz de siete elementos, como se muestra en el código siguiente.

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 .NET Framework. En .NET Framework 1.0 y 1.1, solo se incluye texto capturado del primer conjunto de paréntesis de captura en la matriz devuelta. A partir de .NET Framework 2.0, se agrega todo el texto capturado a la matriz devuelta. 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 a count. Por ejemplo, en el código siguiente, una expresión regular usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. A continuación, la llamada al método Split(String, Int32) especifica un máximo de dos elementos en la matriz devuelta. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, el método devuelve una matriz de cadenas de dos elementos. Si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, el método devuelve una matriz de cadenas de tres elementos.

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 vacía, Split(String, Int32) dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. En el ejemplo siguiente se divide la cadena "caracteres" en tantos elementos como haya en la cadena de entrada. Dado que la cadena null coincide con el principio de la cadena de entrada, se inserta una cadena null al principio de la matriz devuelta. Esto hace que el décimo elemento conste de los dos caracteres al final de la cadena de entrada.

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}

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida