Regex.Split Método

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeia de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split(Char[]), exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. A cadeia de caracteres é dividida o máximo de vezes possível. Se nenhum delimitador for encontrado, o valor retornado conterá um elemento cujo valor é o original input cadeia de caracteres.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

Se várias correspondências estiverem adjacentes umas às outras, uma cadeia de caracteres vazia será inserida na matriz. Por exemplo, dividir uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição em que dois hifens adjacentes são encontrados.

Se uma correspondência for encontrada no início ou no final da cadeia de caracteres de entrada, uma cadeia de caracteres vazia será incluída no início ou no final da matriz retornada. O exemplo a seguir usa o padrão de expressão regular [a-z]+ para dividir uma cadeia de caracteres de entrada em qualquer caractere alfabético maiúsculo ou minúsculo. Como a cadeia de caracteres começa e termina com caracteres alfabéticos correspondentes, o valor do primeiro e do último elemento da matriz retornada é 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', ''

Se a captura de parênteses for usada em uma expressão Regex.Split, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante. Por exemplo, se você dividir a cadeia de caracteres "plum-pear" em um hífen colocado dentro da captura de parênteses, a matriz retornada incluirá um elemento de cadeia de caracteres que contém o hífen.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, se uma correspondência não for encontrada no primeiro conjunto de parênteses de captura, o texto capturado de parênteses de captura adicionais não será incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado também é adicionado à matriz retornada. Por exemplo, o código a seguir usa dois conjuntos de parênteses de captura para extrair os elementos de uma data, incluindo os delimitadores de data, de uma cadeia de caracteres de data. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra para frente. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, ele excluirá os caracteres de barra; se ele for compilado e executado nas versões do .NET Framework 2.0 ou posterior, ele os inclui.

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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local.

O parâmetro matchTimeout especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de atingir o tempo limite. A configuração de um intervalo de tempo limite impede que expressões regulares que dependem do retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas. Para obter mais informações, consulte práticas recomendadas para expressões regulares e backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma exceção RegexMatchTimeoutException. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.

Notas aos Chamadores

Recomendamos que você defina o parâmetro matchTimeout como um valor apropriado, como dois segundos. Se você desabilitar o tempo limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:

• Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.

• Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule com eficiência correspondências, não correspondências e correspondências próximas.

• Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

• elementos de linguagem de expressão regular

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeias de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split(Char[]), exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. A cadeia de caracteres é dividida o máximo de vezes possível. Se nenhum delimitador for encontrado, o valor retornado conterá um elemento cujo valor é o original input cadeia de caracteres.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

Se várias correspondências estiverem adjacentes umas às outras, uma cadeia de caracteres vazia será inserida na matriz. Por exemplo, dividir uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição em que dois hifens adjacentes são encontrados.

Se uma correspondência for encontrada no início ou no final da cadeia de caracteres de entrada, uma cadeia de caracteres vazia será incluída no início ou no final da matriz retornada. O exemplo a seguir usa o padrão de expressão regular [a-z]+ para dividir uma cadeia de caracteres de entrada em qualquer caractere alfabético maiúsculo ou minúsculo. Como a cadeia de caracteres começa e termina com caracteres alfabéticos correspondentes, o valor do primeiro e do último elemento da matriz retornada é 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', ''

Se a captura de parênteses for usada em uma expressão Regex.Split, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante. Por exemplo, se você dividir a cadeia de caracteres "plum-pear" em um hífen colocado dentro da captura de parênteses, a matriz retornada incluirá um elemento de cadeia de caracteres que contém o hífen.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, se uma correspondência não for encontrada no primeiro conjunto de parênteses de captura, o texto capturado de parênteses de captura adicionais não será incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado também é adicionado à matriz retornada. Por exemplo, o código a seguir usa dois conjuntos de parênteses de captura para extrair os elementos de uma data, incluindo os delimitadores de data, de uma cadeia de caracteres de data. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra para frente. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, ele excluirá os caracteres de barra; se ele for compilado e executado nas versões do .NET Framework 2.0 ou posterior, ele os inclui.

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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual o método é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado. O método estático recomendado para dividir o texto em uma correspondência de padrão é Split(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

• elementos de linguagem de expressão regular

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeias de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split, exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. O parâmetro count especifica o número máximo de subcadeias de caracteres nas quais a cadeia de caracteres input é dividida; a última cadeia de caracteres contém o restante desaplicado da cadeia de caracteres. Um valor count de zero fornece o comportamento padrão de dividir o máximo de vezes possível. O parâmetro startat define o ponto em que a pesquisa para o primeiro delimitador começa (isso pode ser usado para ignorar o espaço em branco à esquerda).

Para obter mais detalhes sobre startat, consulte a seção Comentários do Match(String, Int32).

Se nenhuma correspondência for encontrada na posição count+1 na cadeia de caracteres, o método retornará uma matriz de um elemento que contém a cadeia de caracteres input. Se uma ou mais correspondências forem encontradas, o primeiro elemento da matriz retornada conterá a primeira parte da cadeia de caracteres do primeiro caractere até um caractere antes da correspondência.

Se várias correspondências forem adjacentes umas às outras e o número de correspondências encontradas for pelo menos dois a menos que count, uma cadeia de caracteres vazia será inserida na matriz. Da mesma forma, se uma correspondência for encontrada em startat, que é o primeiro caractere na cadeia de caracteres, o primeiro elemento da matriz retornada será uma cadeia de caracteres vazia. Ou seja, cadeias de caracteres vazias resultantes de correspondências adjacentes são contadas para determinar se o número de subcadeias de caracteres correspondentes é igual a count. No exemplo a seguir, a expressão regular \d+ é usada para localizar a posição inicial da primeira subcadeia de caracteres numéricos em uma cadeia de caracteres e, em seguida, dividir a cadeia de caracteres no máximo três vezes, começando nessa posição. Como o padrão de expressão regular corresponde ao início da cadeia de caracteres de entrada, a matriz de cadeia de caracteres retornada consiste em uma cadeia de caracteres vazia, uma cadeia de caracteres alfabética de cinco caracteres e o restante da cadeia de caracteres,

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'

Se a captura de parênteses for usada em uma expressão regular, qualquer texto capturado será incluído na matriz de cadeias de caracteres divididas. No entanto, quaisquer elementos de matriz que contenham texto capturado não são contados para determinar se o número de correspondências atingiu count. Por exemplo, dividir a cadeia de caracteres '"apple-apricot-plum-pear-pomegranate-pineapple-peach" em um máximo de quatro subcadeias de caracteres começando no caractere 15 na cadeia de caracteres resulta em uma matriz de sete elementos, como mostra o código a seguir.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, se uma correspondência não for encontrada no primeiro conjunto de parênteses de captura, o texto capturado de parênteses de captura adicionais não será incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado também é adicionado à matriz retornada. Por exemplo, o código a seguir usa dois conjuntos de parênteses de captura para extrair as palavras individuais em uma cadeia de caracteres. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra vertical. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, ele excluirá os caracteres da barra vertical; se ele for compilado e executado nas versões do .NET Framework 2.0 ou posterior, ele os inclui.

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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local. O exemplo a seguir divide a cadeia de caracteres "caracteres" em quantos elementos a cadeia de caracteres de entrada contiver, começando com o caractere "a". Como a cadeia de caracteres nula corresponde ao final da cadeia de caracteres de entrada, uma cadeia de caracteres nula é inserida no final da matriz retornada.

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}

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada

Confira também

• linguagem de expressão regular – referência rápida

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeias de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split, exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. A cadeia de caracteres input é dividida o máximo de vezes possível. Se pattern não for encontrado na cadeia de caracteres input, o valor retornado conterá um elemento cujo valor é o input cadeia de caracteres original.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.

Se várias correspondências estiverem adjacentes umas às outras, uma cadeia de caracteres vazia será inserida na matriz. Por exemplo, dividir uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição em que dois hifens adjacentes são encontrados, como mostra o código a seguir.

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'

Se uma correspondência for encontrada no início ou no final da cadeia de caracteres de entrada, uma cadeia de caracteres vazia será incluída no início ou no final da matriz retornada. O exemplo a seguir usa o padrão de expressão regular \d+ para dividir uma cadeia de caracteres de entrada em caracteres numéricos. Como a cadeia de caracteres começa e termina com caracteres numéricos correspondentes, o valor do primeiro e último elemento da matriz retornada é 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', ''

Se a captura de parênteses for usada em uma expressão Regex.Split, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante. Por exemplo, se você dividir a cadeia de caracteres "plum-pear" em um hífen colocado dentro da captura de parênteses, a matriz retornada incluirá um elemento de cadeia de caracteres que contém o hífen.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, se uma correspondência não for encontrada no primeiro conjunto de parênteses de captura, o texto capturado de parênteses de captura adicionais não será incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado também é adicionado à matriz retornada. Por exemplo, o código a seguir usa dois conjuntos de parênteses de captura para extrair os elementos de uma data, incluindo os delimitadores de data, de uma cadeia de caracteres de data. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra para frente. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, ele excluirá os caracteres de barra; se ele for compilado e executado nas versões do .NET Framework 2.0 ou posterior, ele os inclui.

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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local. Por exemplo:

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', ''}

Observe que a matriz retornada também inclui uma cadeia de caracteres vazia no início e no final da matriz.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual o método é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado. O método estático recomendado para dividir o texto em uma correspondência de padrão é Split(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

• elementos de linguagem de expressão regular

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeias de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split(Char[]), exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. A cadeia de caracteres é dividida o máximo de vezes possível. Se nenhum delimitador for encontrado, o valor retornado conterá um elemento cujo valor é a cadeia de caracteres de entrada original.

Se várias correspondências estiverem adjacentes umas às outras, uma cadeia de caracteres vazia será inserida na matriz. Por exemplo, dividir uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição em que dois hifens adjacentes são encontrados, como mostra o código a seguir.

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'

Se uma correspondência for encontrada no início ou no final da cadeia de caracteres de entrada, uma cadeia de caracteres vazia será incluída no início ou no final da matriz retornada. O exemplo a seguir usa o padrão de expressão regular \d+ para dividir uma cadeia de caracteres de entrada em caracteres numéricos. Como a cadeia de caracteres começa e termina com caracteres numéricos correspondentes, o valor do primeiro e último elemento da matriz retornada é 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', ''

Se a captura de parênteses for usada em uma expressão Regex.Split, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante. Por exemplo, se você dividir a cadeia de caracteres "plum-pear" em um hífen colocado dentro da captura de parênteses, a matriz retornada incluirá um elemento de cadeia de caracteres que contém o hífen.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, se uma correspondência não for encontrada no primeiro conjunto de parênteses de captura, o texto capturado de parênteses de captura adicionais não será incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado também é adicionado à matriz retornada. Por exemplo, o código a seguir usa dois conjuntos de parênteses de captura para extrair os elementos de uma data, incluindo os delimitadores de data, de uma cadeia de caracteres de data. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra para frente. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, ele excluirá os caracteres de barra; se ele for compilado e executado nas versões do .NET Framework 2.0 ou posterior, ele os inclui.

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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split(String) dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local. Por exemplo:

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, }

Observe que a matriz retornada também inclui uma cadeia de caracteres vazia no início e no final da matriz.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada

Confira também

• linguagem de expressão regular – referência rápida

Origem:

Regex.Split.cs

Origem:

Regex.Split.cs

Origem:

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

Retornos

Uma matriz de cadeias de caracteres.

Exceções

Comentários

Os métodos Regex.Split são semelhantes ao método String.Split, exceto que Regex.Split divide a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres. O parâmetro count especifica o número máximo de subcadeias de caracteres nas quais a cadeia de caracteres input pode ser dividida; a última cadeia de caracteres contém o restante desaplicado da cadeia de caracteres. Um valor count de zero fornece o comportamento padrão de dividir o máximo de vezes possível.

Se várias correspondências estiverem adjacentes umas às outras ou se uma correspondência for encontrada no início ou no final de input, e o número de correspondências encontradas for pelo menos dois a menos que count, uma cadeia de caracteres vazia será inserida na matriz. Ou seja, cadeias de caracteres vazias resultantes de correspondências adjacentes ou de correspondências no início ou no final da cadeia de caracteres de entrada são contadas para determinar se o número de subcadeias de caracteres correspondentes é igual a count. No exemplo a seguir, a expressão regular /d+ é usada para dividir uma cadeia de caracteres de entrada que inclui um ou mais dígitos decimais em um máximo de três subcadeias de caracteres. Como o início da cadeia de caracteres de entrada corresponde ao padrão de expressão regular, o primeiro elemento de matriz contém String.Empty, o segundo contém o primeiro conjunto de caracteres alfabéticos na cadeia de caracteres de entrada e o terceiro contém o restante da cadeia de caracteres que segue a terceira correspondência.

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'

Se a captura de parênteses for usada em uma expressão regular, qualquer texto capturado será incluído na matriz de cadeias de caracteres divididas. No entanto, quaisquer elementos de matriz que contenham texto capturado não são contados para determinar se o número de correspondências atingiu count. Por exemplo, dividir a cadeia de caracteres "apple-apricot-plum-pear-banana" em um máximo de quatro subcadeias de caracteres resulta em uma matriz de sete elementos, como mostra o código a seguir.

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'

No entanto, quando o padrão de expressão regular inclui vários conjuntos de parênteses de captura, o comportamento desse método depende da versão do .NET Framework. No .NET Framework 1.0 e 1.1, somente o texto capturado do primeiro conjunto de parênteses de captura está incluído na matriz retornada. A partir do .NET Framework 2.0, todo o texto capturado é adicionado à matriz retornada. No entanto, os elementos na matriz retornada que contêm texto capturado não são contados para determinar se o número de subcadeias de caracteres correspondentes é igual a count. Por exemplo, no código a seguir, uma expressão regular usa dois conjuntos de parênteses de captura para extrair os elementos de uma data de uma cadeia de caracteres de data. O primeiro conjunto de captura de parênteses captura o hífen e o segundo conjunto captura a barra para frente. A chamada para o método Split(String, Int32) especifica um máximo de dois elementos na matriz retornada. Se o código de exemplo for compilado e executado no .NET Framework 1.0 ou 1.1, o método retornará uma matriz de cadeia de caracteres de dois elementos. Se ele for compilado e executado nas versões .NET Framework 2.0 ou posterior, o método retornará uma matriz de cadeia de caracteres de três 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'

Se a expressão regular puder corresponder à cadeia de caracteres vazia, Split(String, Int32) dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres únicos porque o delimitador de cadeia de caracteres vazio pode ser encontrado em cada local. O exemplo a seguir divide a cadeia de caracteres "caracteres" em quantos elementos houver na cadeia de caracteres de entrada. Como a cadeia de caracteres nula corresponde ao início da cadeia de caracteres de entrada, uma cadeia de caracteres nula é inserida no início da matriz retornada. Isso faz com que o décimo elemento consista nos dois caracteres no final da cadeia de caracteres 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}

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada

Confira também

• linguagem de expressão regular – referência rápida