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

Definição

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por uma correspondência de expressão regular.Splits an input string into an array of substrings at the positions defined by a regular expression match.

Sobrecargas

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

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

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. A pesquisa do padrão de expressão regular é iniciada em uma posição de caractere especificada na cadeia de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

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

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado no construtor Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to split.

pattern
String String String String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retornos

String[]

Uma matriz de cadeia de caracteres.A string array.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

- ou --or- matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.matchTimeout is negative, zero, or greater than approximately 24 days.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split(Char[]) ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. A cadeia de caracteres é dividida quantas vezes for possível.The string is split as many times as possible. Se nenhum delimitador for encontrado, o valor de retorno conterá um elemento cujo input valor é a cadeia de caracteres original.If no delimiter is found, the return value contains one element whose value is the original input string.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondente.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

As expressões regulares compiladas usadas em chamadas Split para métodos estáticos são armazenadas em cache automaticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para gerenciar o tempo de vida de expressões regulares compiladas por conta Split própria, use os métodos de instância.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se várias correspondências forem adjacentes umas das outras, uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. 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 onde dois hifens adjacentes são encontrados.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

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 fim da matriz retornada.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. O exemplo a seguir usa o padrão [a-z]+ de expressão regular para dividir uma cadeia de caracteres de entrada em qualquer caractere alfabético maiúsculo ou minúsculo.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Como a cadeia de caracteres começa e termina com caracteres alfabéticos correspondentes, o valor do primeiro e último elemento da matriz retornada String.Emptyé.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

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

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

Se a captura de parênteses for usada Regex.Split em uma expressão, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por exemplo, se você dividir a cadeia de caracteres "Black-pêra" em um hífen colocado dentro dos parênteses de captura, a matriz retornada incluirá um elemento String que contém o hífen.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

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

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. 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.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado também é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. 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.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. 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 no .NET Framework 2,0 ou versões posteriores, ele os incluirá.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

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

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

O matchTimeout parâmetro especifica quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. A definição de um intervalo de tempo limite impede que expressões regulares que dependem de retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Para obter mais informações, consulte práticas recomendadas para expressões regulares e retrocesso.For more information, see Best Practices for Regular Expressions and Backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método lançará RegexMatchTimeoutException uma exceção.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeoutsubstitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notas aos Chamadores

Recomendamos que você defina o matchTimeout parâmetro para um valor apropriado, como dois segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se você desabilitar os tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferece um desempenho ligeiramente melhor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. No entanto, você deve desabilitar o tempo limite somente sob as seguintes condições:However, you should disable time-outs only under the following conditions: -Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Isso exclui o texto que foi inserido dinamicamente pelos usuários.This excludes text that has been dynamically input by users.

-Quando o padrão de expressão regular foi totalmente testado para garantir que ele lide com as correspondências, não correspondentes e correspondências próximas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando o padrão de expressão regular não contém nenhum elemento de linguagem que seja conhecido por causar um retrocesso excessivo ao processar uma correspondência próxima.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Veja também

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to split.

pattern
String String String String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

Retornos

String[]

Uma matriz de cadeias de caracteres.An array of strings.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split(Char[]) ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. A cadeia de caracteres é dividida quantas vezes for possível.The string is split as many times as possible. Se nenhum delimitador for encontrado, o valor de retorno conterá um elemento cujo input valor é a cadeia de caracteres original.If no delimiter is found, the return value contains one element whose value is the original input string.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondente.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

As expressões regulares compiladas usadas em chamadas Split para métodos estáticos são armazenadas em cache automaticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para gerenciar o tempo de vida de expressões regulares compiladas por conta Split própria, use os métodos de instância.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se várias correspondências forem adjacentes umas das outras, uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. 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 onde dois hifens adjacentes são encontrados.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

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 fim da matriz retornada.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. O exemplo a seguir usa o padrão [a-z]+ de expressão regular para dividir uma cadeia de caracteres de entrada em qualquer caractere alfabético maiúsculo ou minúsculo.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Como a cadeia de caracteres começa e termina com caracteres alfabéticos correspondentes, o valor do primeiro e último elemento da matriz retornada String.Emptyé.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

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

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

Se a captura de parênteses for usada Regex.Split em uma expressão, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por exemplo, se você dividir a cadeia de caracteres "Black-pêra" em um hífen colocado dentro dos parênteses de captura, a matriz retornada incluirá um elemento String que contém o hífen.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

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

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. 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.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado também é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. 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.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. 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 no .NET Framework 2,0 ou versões posteriores, ele os incluirá.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

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

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

A RegexMatchTimeoutException exceção 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.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. 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á lançada.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual o método é chamado.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o InfiniteMatchTimeoutvalor, que impedirá o tempo limite do método, será usado.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. 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 que você defina o intervalo de tempo limite.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Veja também

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

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. A pesquisa do padrão de expressão regular é iniciada em uma posição de caractere especificada na cadeia de entrada.The search for the regular expression pattern starts at a specified character position in the input string.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to be split.

count
Int32 Int32 Int32 Int32

O número máximo de vezes que a divisão pode ocorrer.The maximum number of times the split can occur.

startat
Int32 Int32 Int32 Int32

A posição do caractere na cadeia de caracteres de entrada em que a pesquisa será iniciada.The character position in the input string where the search will begin.

Retornos

String[]

Uma matriz de cadeias de caracteres.An array of strings.

Exceções

startat é menor que zero ou maior que o tamanho de input.startat is less than zero or greater than the length of input.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. O count parâmetro especifica o número máximo de subcadeias de caracteres em input que a cadeia de caracteres é dividida; a última cadeia de caracteres contém o restante de divisão da cadeia de caracteres.The count parameter specifies the maximum number of substrings into which the input string is split; the last string contains the unsplit remainder of the string. Um count valor de zero fornece o comportamento padrão de divisão o máximo possível de vezes.A count value of zero provides the default behavior of splitting as many times as possible. O startat parâmetro define o ponto no qual a pesquisa do primeiro delimitador começa (isso pode ser usado para ignorar o espaço em branco à esquerda).The startat parameter defines the point at which the search for the first delimiter begins (this can be used for skipping leading white space).

Se nenhuma correspondência for encontrada countna posição + 1 na cadeia de caracteres, o método retornará uma matriz de um elemento que contém a cadeia de input caracteres.If no matches are found from the count+1 position in the string, the method returns a one-element array that contains the input string. 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.If one or more matches are found, the first element of the returned array contains the first portion of the string from the first character up to one character before the match.

Se várias correspondências forem adjacentes umas às outras e o número de correspondências encontradas for pelo menos countduas menores, uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another and the number of matches found is at least two less than count, an empty string is inserted into the array. Da mesma forma, se uma correspondência for startatencontrada em, que é o primeiro caractere na cadeia de caracteres, o primeiro elemento da matriz retornada será uma cadeia de caracteres vazia.Similarly, if a match is found at startat, which is the first character in the string, the first element of the returned array is an empty string. Ou seja, cadeias vazias que resultam de correspondências adjacentes são contadas para determinar se o número countde subcadeias de caracteres correspondentes é igual a.That is, empty strings that result from adjacent matches are counted in determining whether the number of matched substrings equals count. No exemplo a seguir, a expressão \d+ regular é 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 iniciando nessa posição.In the following example, the regular expression \d+ is used to find the starting position of the first substring of numeric characters in a string, and then to split the string a maximum of three times starting at that position. 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ético de cinco caracteres e o restante da cadeia de caracteres,Because the regular expression pattern matches the beginning of the input string, the returned string array consists of an empty string, a five-character alphabetic string, and the remainder of the string,

using System;
using System.Text.RegularExpressions;

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

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

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 de divisão.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. No entanto, todos os elementos de matriz que contêm texto capturado não são contados para determinar se o countnúmero de correspondências foi atingido.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Por exemplo, dividir a cadeia de caracteres "Apple-Apricot-Black-pêra-Pomegranate-Pineapple-pêssego" 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.For example, splitting the string '"apple-apricot-plum-pear-pomegranate-pineapple-peach" into a maximum of four substrings beginning at character 15 in the string results in a seven-element array, as the following code shows.

Imports System.Text.RegularExpressions

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. 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.In .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado também é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. 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.For example, the following code uses two sets of capturing parentheses to extract the individual words in a string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra vertical.The first set of capturing parentheses captures the hyphen, and the second set captures the vertical bar. Se o código de exemplo for compilado e executado no .NET Framework 1,0 ou 1,1, ele excluirá os caracteres de barra vertical; Se ele for compilado e executado no .NET Framework 2,0 ou versões posteriores, ele os incluirá.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the vertical bar characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

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

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

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. O exemplo a seguir divide a cadeia de caracteres "caracteres" em tantos elementos quanto a cadeia de caracteres de entrada contém, começando com o caractere "a".The following example splits the string "characters" into as many elements as the input string contains, starting with the character "a". Como a cadeia de caracteres nula corresponde ao fim da cadeia de caracteres de entrada, uma cadeia de caracteres nula é inserida no final da matriz retornada.Because the null string matches the end of the input string, a null string is inserted at the end of the returned array.

using System;
using System.Text.RegularExpressions;

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

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

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado Regex.Regex(String, RegexOptions, TimeSpan) pelo construtor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 Regex objeto é criado.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na Regex chamada de construtor ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Veja também

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

Divide uma cadeia de entrada no número de vezes máximo especificado em uma matriz de subcadeias de caracteres, nas posições definidas por uma expressão regular especificada no construtor Regex.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to be split.

count
Int32 Int32 Int32 Int32

O número máximo de vezes que a divisão pode ocorrer.The maximum number of times the split can occur.

Retornos

String[]

Uma matriz de cadeias de caracteres.An array of strings.

Exceções

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. O count parâmetro especifica o número máximo de subcadeias de caracteres em input que a cadeia de caracteres pode ser dividida; a última cadeia de caracteres contém o restante de divisão da cadeia de caracteres.The count parameter specifies the maximum number of substrings into which the input string can be split; the last string contains the unsplit remainder of the string. Um count valor de zero fornece o comportamento padrão de divisão o máximo possível de vezes.A count value of zero provides the default behavior of splitting as many times as possible.

Se várias correspondências forem adjacentes umas às outras ou se uma correspondência for encontrada no início ou no inputfinal de e o número de correspondências encontradas for pelo menos duas countmenores que uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another or if a match is found at the beginning or end of input, and the number of matches found is at least two less than count, an empty string is inserted into the array. Ou seja, cadeias vazias que resultam 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 countse o número de subcadeias de caracteres correspondentes é igual a.That is, empty strings that result from adjacent matches or from matches at the beginning or end of the input string are counted in determining whether the number of matched substrings equals count. No exemplo a seguir, a expressão /d+ regular é 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.In the following example, the regular expression /d+ is used to split an input string that includes one or more decimal digits into a maximum of three substrings. Como o início da cadeia de caracteres de entrada corresponde ao padrão de expressão regular, o primeiro String.Emptyelemento de matriz contém, 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 Isso segue a terceira correspondência.Because the beginning of the input string matches the regular expression pattern, the first array element contains String.Empty, the second contains the first set of alphabetic characters in the input string, and the third contains the remainder of the string that follows the third match.

using System;
using System.Text.RegularExpressions;

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

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

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 de divisão.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. No entanto, todos os elementos de matriz que contêm texto capturado não são contados para determinar se o countnúmero de correspondências foi atingido.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Por exemplo, dividir a cadeia de caracteres "Apple-Apricot-Black-pêra-banana" em um máximo de quatro subcadeias de caracteres resulta em uma matriz de sete elementos, como mostra o código a seguir.For example, splitting the string "apple-apricot-plum-pear-banana" into a maximum of four substrings results in a seven-element array, as the following code shows.

using System;
using System.Text.RegularExpressions;

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. No .NET Framework 1,0 e 1,1, somente o texto capturado do primeiro conjunto de parênteses de captura é incluído na matriz retornada.In the .NET Framework 1.0 and 1.1, only captured text from the first set of capturing parentheses is included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is added to the returned array. 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 counta.However, elements in the returned array that contain captured text are not counted in determining whether the number of matched substrings equals count. Por 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.For example, in the following code, a regular expression uses two sets of capturing parentheses to extract the elements of a date from a date string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. A chamada para o Split(String, Int32) método especifica, em seguida, um máximo de dois elementos na matriz retornada.The call to the Split(String, Int32) method then specifies a maximum of two elements in the returned array. 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.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, the method returns a two-element string array. Se ele for compilado e executado sob o .NET Framework 2,0 ou versões posteriores, o método retornará uma matriz de cadeia de caracteres de três elementos.If it is compiled and run under the .NET Framework 2.0 or later versions, the method returns a three-element string array.

using System;
using System.Text.RegularExpressions;

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split(String, Int32) vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split(String, Int32) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. O exemplo a seguir divide a cadeia de caracteres "characters" em quantos elementos existirem na cadeia de caracteres de entrada.The following example splits the string "characters" into as many elements as there are in the input string. 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.Because the null string matches the beginning of the input string, a null string is inserted at the beginning of the returned array. Isso faz com que o décimo elemento consista nos dois caracteres no final da cadeia de caracteres de entrada.This causes the tenth element to consist of the two characters at the end of the input string.

Imports System.Text.RegularExpressions

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

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado Regex.Regex(String, RegexOptions, TimeSpan) pelo construtor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 Regex objeto é criado.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na Regex chamada de construtor ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Veja também

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular especificado no construtor Regex.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to split.

Retornos

String[]

Uma matriz de cadeias de caracteres.An array of strings.

Exceções

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split(Char[]) ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. A cadeia de caracteres é dividida quantas vezes for possível.The string is split as many times as possible. Se nenhum delimitador for encontrado, o valor de retorno conterá um elemento cujo valor é a cadeia de caracteres de entrada original.If no delimiter is found, the return value contains one element whose value is the original input string.

Se várias correspondências forem adjacentes umas das outras, uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por exemplo, a divisão de uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição onde dois hifens adjacentes são encontrados, como mostra o código a seguir.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

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

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

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 fim da matriz retornada.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. O exemplo a seguir usa o padrão \d+ de expressão regular para dividir uma cadeia de caracteres de entrada em caracteres numéricos.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. 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é.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

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

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

Se a captura de parênteses for usada Regex.Split em uma expressão, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por exemplo, se você dividir a cadeia de caracteres "Black-pêra" em um hífen colocado dentro dos parênteses de captura, a matriz retornada incluirá um elemento String que contém o hífen.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. 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.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado também é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. 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.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. 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 no .NET Framework 2,0 ou versões posteriores, ele os incluirá.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split(String) vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split(String) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Por exemplo:For example:

using System;
using System.Text.RegularExpressions;

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

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

Observe que a matriz retornada também inclui uma cadeia de caracteres vazia no início e no final da matriz.Note that the returned array also includes an empty string at the beginning and end of the array.

A RegexMatchTimeoutException exceção será gerada se o tempo de execução da operação de divisão exceder o intervalo de tempo limite especificado Regex.Regex(String, RegexOptions, TimeSpan) pelo construtor.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 Regex objeto é criado.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na Regex chamada de construtor ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Veja também

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

Divide uma cadeia de caracteres de entrada em uma matriz de subcadeias de caracteres nas posições definidas por um padrão de expressão regular.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

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

Parâmetros

input
String String String String

A cadeia de caracteres a ser dividida.The string to split.

pattern
String String String String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

Retornos

String[]

Uma matriz de cadeias de caracteres.An array of strings.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

Os Regex.Split métodos são semelhantes String.Split ao método, exceto pelo Regex.Split fato de dividir a cadeia de caracteres em um delimitador determinado por uma expressão regular em vez de um conjunto de caracteres.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. A input cadeia de caracteres é dividida quantas vezes for possível.The input string is split as many times as possible. Se pattern não for encontrado input na cadeia de caracteres, o valor de retorno conterá um elemento cujo valor input é a cadeia de caracteres original.If pattern is not found in the input string, the return value contains one element whose value is the original input string.

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondente.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

As expressões regulares compiladas usadas em chamadas Split para métodos estáticos são armazenadas em cache automaticamente.Compiled regular expressions used in calls to static Split methods are automatically cached. Para gerenciar o tempo de vida de expressões regulares compiladas por conta Split própria, use os métodos de instância.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se várias correspondências forem adjacentes umas das outras, uma cadeia de caracteres vazia será inserida na matriz.If multiple matches are adjacent to one another, an empty string is inserted into the array. Por exemplo, a divisão de uma cadeia de caracteres em um único hífen faz com que a matriz retornada inclua uma cadeia de caracteres vazia na posição onde dois hifens adjacentes são encontrados, como mostra o código a seguir.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

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

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

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 fim da matriz retornada.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. O exemplo a seguir usa o padrão \d+ de expressão regular para dividir uma cadeia de caracteres de entrada em caracteres numéricos.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. 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é.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

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

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

Se a captura de parênteses for usada Regex.Split em uma expressão, qualquer texto capturado será incluído na matriz de cadeia de caracteres resultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Por exemplo, se você dividir a cadeia de caracteres "Black-pêra" em um hífen colocado dentro dos parênteses de captura, a matriz retornada incluirá um elemento String que contém o hífen.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

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

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

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

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.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. 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.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. A partir do .NET Framework 2,0, todo o texto capturado também é adicionado à matriz retornada.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. 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.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. O primeiro conjunto de parênteses de captura captura o hífen, e o segundo conjunto captura a barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. 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 no .NET Framework 2,0 ou versões posteriores, ele os incluirá.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

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

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

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

Se a expressão regular puder corresponder à cadeia de caracteres Split vazia, o dividirá a cadeia de caracteres em uma matriz de cadeias de caracteres de caractere único porque o delimitador de cadeia de caracteres vazia pode ser encontrado em cada local.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Por exemplo:For example:

using System;
using System.Text.RegularExpressions;

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

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

Observe que a matriz retornada também inclui uma cadeia de caracteres vazia no início e no final da matriz.Note that the returned array also includes an empty string at the beginning and end of the array.

A RegexMatchTimeoutException exceção 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.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. 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á lançada.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual o método é chamado.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o InfiniteMatchTimeoutvalor, que impedirá o tempo limite do método, será usado.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. 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 que você defina o intervalo de tempo limite.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Veja também

Aplica-se a