String.Split String.Split String.Split String.Split Method

Definição

Retorna uma matriz de cadeia de caracteres que contém as subcadeias de caracteres nesta instância delimitadas por elementos de uma cadeia de caracteres especificada ou da matriz de caracteres Unicode.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

Sobrecargas

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nas cadeias de caracteres de uma matriz.Splits a string into a maximum number of substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres com base nas cadeias de caracteres em uma matriz.Splits a string into substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings based on the characters in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array. Especifique também o número máximo de subcadeias de caracteres a serem retornadas.You also specify the maximum number of substrings to return.

Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings that are based on the characters in an array.

Comentários

Splité usado para quebrar uma cadeia de caracteres delimitada em subcadeias de caracteres.Split is used to break a delimited string into substrings. Você pode usar uma matriz de caracteres para especificar zero, um ou vários caracteres delimitadores (o Split(Char[]) método), ou você pode usar uma matriz de caracteres para especificar zero, uma ou várias seqüências de caracteres de delimitação.You can use either a character array to specify zero, one, or multiple delimiting characters (the Split(Char[]) method), or you can use a character array to specify zero, one, or multiple delimiting strings. Sobrecargas do Split método permitem limitar o número de subcadeias de caracteres retornadas pelo método (o Split(Char[], Int32) método), para determinar se as cadeias de caracteres vazias estão incluídas nas subcadeias Split(Char[], StringSplitOptions) retornadas (os métodos e Split(String[], StringSplitOptions) , ou fazer ambos (os Split(Char[], Int32, StringSplitOptions) métodos e Split(String[], Int32, StringSplitOptions) ).Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.The C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternativas para String. SplitAlternatives to String.Split

O Split método nem sempre é a melhor maneira de quebrar uma cadeia de caracteres delimitada em subcadeias de caracteres.The Split method is not always the best way to break a delimited string into substrings. Se você não quiser extrair todas as subcadeias de caracteres delimitadas ou se quiser analisar uma cadeia de caracteres com base em um padrão, em vez de um conjunto de caracteres delimitadores, considere as alternativas a seguir.If you don't want to extract all of the substrings of a delimited string, or if you want to parse a string based on a pattern instead of a set of delimiter characters, consider the following alternatives.

Expressões regularesRegular expressions

Se as cadeias de caracteres estiverem em conformidade com um padrão fixo, você poderá usar uma expressão regular para extrair e manipular seus elementos.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Por exemplo, se as cadeias de caracteres assumirem o formato " númerodo operando denúmero ", você poderá usar uma expressão regular para extrair e manipular os elementos da cadeia de caracteres.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Veja um exemplo:Here's an example:

   String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                            "42 - 18", "12 * 7",
                            "2, 4, 6, 8" };
   String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";
   foreach (var expression in expressions)
      foreach (System.Text.RegularExpressions.Match m in 
      System.Text.RegularExpressions.Regex.Matches(expression, pattern)) {
         int value1 = Int32.Parse(m.Groups[1].Value);
         int value2 = Int32.Parse(m.Groups[3].Value);
         switch (m.Groups[2].Value)
         {
            case "+":
               Console.WriteLine("{0} = {1}", m.Value, value1 + value2);
               break;
            case "-":
               Console.WriteLine("{0} = {1}", m.Value, value1 - value2);
               break;
            case "*":
               Console.WriteLine("{0} = {1}", m.Value, value1 * value2);
               break;
            case "/":
               Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2);
               break;
         }
      }
// The example displays the following output:
//       16 + 21 = 37
//       31 * 3 = 93
//       28 / 3 = 9.33
//       42 - 18 = 24
//       12 * 7 = 84
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim expressions() As String = { "16 + 21", "31 * 3", "28 / 3",
                                      "42 - 18", "12 * 7",
                                      "2, 4, 6, 8" }

      Dim pattern As String = "(\d+)\s+([-+*/])\s+(\d+)"
      For Each expression In expressions
         For Each m As Match in Regex.Matches(expression, pattern)
            Dim value1 As Integer = Int32.Parse(m.Groups(1).Value)
            Dim value2 As Integer = Int32.Parse(m.Groups(3).Value)
            Select Case m.Groups(2).Value
               Case "+"
                  Console.WriteLine("{0} = {1}", m.Value, value1 + value2)
               Case "-"
                  Console.WriteLine("{0} = {1}", m.Value, value1 - value2)
               Case "*"
                  Console.WriteLine("{0} = {1}", m.Value, value1 * value2)
               Case "/"
                  Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2)
            End Select
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       16 + 21 = 37
'       31 * 3 = 93
'       28 / 3 = 9.33
'       42 - 18 = 24
'       12 * 7 = 84

O padrão (\d+)\s+([-+*/])\s+(\d+) de expressão regular é definido da seguinte maneira:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

PadrãoPattern DescriçãoDescription
(\d+) Corresponde a um ou mais dígitos decimais.Match one or more decimal digits. Este é o primeiro grupo de captura.This is the first capturing group.
\s+ Corresponder um ou mais caracteres de espaço em branco.Match one or more white-space characters.
([-+*/]) Corresponder um sinal de operador aritmético (+,-, * ou/).Match an arithmetic operator sign (+, -, *, or /). Este é o segundo grupo de captura.This is the second capturing group.
\s+ Corresponder um ou mais caracteres de espaço em branco.Match one or more white-space characters.
(\d+) Corresponde a um ou mais dígitos decimais.Match one or more decimal digits. Este é o terceiro grupo de captura.This is the third capturing group.

Você também pode usar uma expressão regular para extrair subseqüências de uma cadeia de caracteres com base em um padrão, em vez de um conjunto fixo de caracteres.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Esse é um cenário comum quando uma dessas condições ocorre:This is a common scenario when either of these conditions occurs:

  • Um ou mais dos caracteres delimitadores nem sempre servem como um delimitador String na instância.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • A sequência e o número de caracteres do delimitador são variáveis ou são desconhecidos.The sequence and number of delimiter characters is variable or unknown.

Por exemplo, o Split método não pode ser usado para dividir a cadeia de caracteres a seguir, \n porque o C#número de vbCrLf caracteres (in) ou (em Visual Basic) é variável, e eles nem sempre servem como delimitadores.For example, the Split method cannot be used to split the following string, because the number of \n (in C#) or vbCrLf (in Visual Basic) characters is variable, and they don't always serve as delimiters.

[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]  
\n[Some more captured text:\n   Option1\n   Option2][Terse text.]  

Uma expressão regular pode dividir essa cadeia de caracteres facilmente, como mostra o exemplo a seguir.A regular expression can split this string easily, as the following example shows.

String input = "[This is captured\ntext.]\n\n[\n" +
               "[This is more captured text.]\n]\n" +
               "[Some more captured text:\n   Option1" +
               "\n   Option2][Terse text.]";
String pattern = @"\[([^\[\]]+)\]";
int ctr = 0;
foreach (System.Text.RegularExpressions.Match m in 
   System.Text.RegularExpressions.Regex.Matches(input, pattern))
   Console.WriteLine("{0}: {1}", ++ctr, m.Groups[1].Value);
// The example displays the following output:
//       1: This is captured
//       text.
//       2: This is more captured text.
//       3: Some more captured text:
//          Option1
//          Option2
//       4: Terse text.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = String.Format("[This is captured{0}text.]" +
                                          "{0}{0}[{0}[This is more " +
                                          "captured text.]{0}{0}" +
                                          "[Some more captured text:" +
                                          "{0}   Option1" +
                                          "{0}   Option2][Terse text.]",
                                          vbCrLf)
      Dim pattern As String = "\[([^\[\]]+)\]"
      Dim ctr As Integer = 0
      For Each m As Match In Regex.Matches(input, pattern)
         ctr += 1
         Console.WriteLine("{0}: {1}", ctr, m.Groups(1).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       1: This is captured
'       text.
'       2: This is more captured text.
'       3: Some more captured text:
'          Option1
'          Option2
'       4: Terse text.

O padrão \[([^\[\]]+)\] de expressão regular é definido da seguinte maneira:The regular expression pattern \[([^\[\]]+)\] is defined like this:

PadrãoPattern DescriçãoDescription
\[ Corresponde a um colchete de abertura.Match an opening bracket.
([^\[\]]+) Corresponder qualquer caractere que não seja um colchete de abertura ou de fechamento uma ou mais vezes.Match any character that is not an opening or a closing bracket one or more times. Este é o primeiro grupo de captura.This is the first capturing group.
\] Corresponde a um colchete de fechamento.Match a closing bracket.

O Regex.Split método é quase idêntico ao String.Split, exceto pelo fato de que ele divide uma cadeia de caracteres com base em um padrão de expressão regular em vez de um conjunto de caracteres fixo.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. Por exemplo, o exemplo a seguir usa Regex.Split o método para dividir uma cadeia de caracteres que contém subcadeias de caracteres delimitadas por várias combinações de hifens e outros caracteres.For example, the following example uses the Regex.Split method to split a string that contains substrings delimited by various combinations of hyphens and other characters.

String input = "abacus -- alabaster - * - atrium -+- " +
               "any -*- actual - + - armoire - - alarm";
String pattern = @"\s-\s?[+*]?\s?-\s";
String[] elements = System.Text.RegularExpressions.Regex.Split(input, pattern);
foreach (var element in elements)
   Console.WriteLine(element);

// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoire
//       alarm
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "abacus -- alabaster - * - atrium -+- " +
                            "any -*- actual - + - armoir - - alarm"
      Dim pattern As String = "\s-\s?[+*]?\s?-\s"
      Dim elements() As String = Regex.Split(input, pattern)
      For Each element In elements
         Console.WriteLine(element)
      Next
   End Sub
End Module
' The example displays the following output:
'       abacus
'       alabaster
'       atrium
'       any
'       actual
'       armoir
'       alarm

O padrão \s-\s?[+*]?\s?-\s de expressão regular é definido da seguinte maneira:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

PadrãoPattern DescriçãoDescription
\s- Corresponder a um caractere de espaço em branco seguido por um hífen.Match a white-space character followed by a hyphen.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
[+*]? Corresponder a zero ou uma ocorrência do caractere + ou *.Match zero or one occurrence of either the + or * character.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
-\s Corresponder um hífen seguido por um caractere de espaço em branco.Match a hyphen followed by a white-space character.

Métodos de pesquisa e o método substringSearch methods and the Substring method

Se você não estiver interessado em todas as subcadeias em uma cadeia de caracteres, talvez prefira trabalhar com um dos métodos de comparação de cadeia de caracteres que retorna o índice no qual a correspondência começa.If you aren't interested in all of the substrings in a string, you might prefer to work with one of the string comparison methods that returns the index at which the match begins. Em seguida, você pode Substring chamar o método para extrair a subcadeia de caracteres desejada.You can then call the Substring method to extract the substring that you want. Os métodos de comparação de cadeia de caracteres incluem:The string comparison methods include:

  • IndexOf, que retorna o índice de base zero da primeira ocorrência de um caractere ou uma cadeia de caracteres em uma instância de cadeia de caracteres.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, que retorna o índice de base zero na instância de cadeia de caracteres atual da primeira ocorrência de qualquer caractere em uma matriz de caracteres.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, que retorna o índice de base zero da última ocorrência de um caractere ou uma cadeia de caracteres em uma instância de cadeia de caracteres.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, que retorna um índice de base zero na instância de cadeia de caracteres atual da última ocorrência de qualquer caractere em uma matriz de caracteres.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

O exemplo a seguir usa IndexOf o método para localizar os períodos em uma cadeia de caracteres.The following example uses the IndexOf method to find the periods in a string. Em seguida, ele Substring usa o método para retornar frases completas.It then uses the Substring method to return full sentences.

String value = "This is the first sentence in a string. " +
               "More sentences will follow. For example, " +
               "this is the third sentence. This is the " +
               "fourth. And this is the fifth and final " +
               "sentence.";
var sentences = new List<String>();
int position = 0;
int start = 0;
// Extract sentences from the string.
do 
{
   position = value.IndexOf('.', start);
   if (position >= 0) 
   {
      sentences.Add(value.Substring(start, position - start + 1).Trim());
      start = position + 1;
   }
} while (position > 0);

// Display the sentences.
foreach (var sentence in sentences)
   Console.WriteLine(sentence);

// The example displays the following output:
//       This is the first sentence in a string.
//       More sentences will follow.
//       For example, this is the third sentence.
//       This is the fourth.
//       And this is the fifth and final sentence.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim value As String = "This is the first sentence in a string. " +
                            "More sentences will follow. For example, " +
                            "this is the third sentence. This is the " +
                            "fourth. And this is the fifth and final " +
                            "sentence."
      Dim sentences As New List(Of String)
      Dim position As Integer = 0
      Dim start As Integer = 0
      ' Extract sentences from the string.
      Do
         position = value.IndexOf("."c, start)
         If position >= 0 Then
            sentences.Add(value.Substring(start, position - start + 1).Trim())
            start = position + 1
         End If
      Loop While position > 0
      
      ' Display the sentences.
      For Each sentence In sentences
         Console.WriteLine(sentence)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence in a string.
'       More sentences will follow.
'       For example, this is the third sentence.
'       This is the fourth.
'       And this is the fifth and final sentence.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()

Parâmetros

separator
Char[]

Uma matriz de caracteres que delimita as subcadeias de caracteres nesta cadeia de caracteres, uma matriz vazia que não contém delimitadores ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

O número máximo de subcadeias de caracteres a serem retornadas.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries para omitir elementos de matriz vazia da matriz retornada; ou None para incluir elementos de matriz vazia na matriz retornada.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta cadeia de caracteres que são delimitadas por um ou mais caracteres em separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exceções

options não é um dos valores StringSplitOptions.options is not one of the StringSplitOptions values.

Exemplos

O exemplo a seguir usa StringSplitOptions a enumeração para incluir ou excluir subcadeias de caracteres Split geradas pelo método.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentários

Os caracteres delimitadores não estão incluídos nos elementos da matriz retornada.Delimiter characters are not included in the elements of the returned array.

Se essa instância não contiver nenhum dos caracteres em separator, ou o count parâmetro for 1, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Caso o parâmetro separator seja null ou não contenha nenhum caractere, os caracteres de espaço em branco devem ser considerados os delimitadores.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Os caracteres de espaço em branco são definidos pelo padrão Unicode e retornam true caso sejam passados para o método Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. No entanto, caso o parâmetro separator na chamada para esta sobrecarga de método seja null, a resolução de sobrecarga do compilador falha.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Para identificar sem ambigüidade o método chamado, seu código deve indicar o tipo de NULL.To unambiguously identify the called method, your code must indicate the type of the null. O exemplo a seguir mostra várias maneiras para identificar sem ambiguidade essa sobrecarga.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((char[]) null, 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

Se o count parâmetro for zero ou o options parâmetro for RemoveEmptyEntries e o comprimento dessa instância for zero, uma matriz vazia será retornada.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Cada elemento de separator define um caractere delimitador à parte.Each element of separator defines a separate delimiter character. Caso o parâmetro options seja None e dois delimitadores sejam adjacentes ou um delimitador esteja no início ou no fim dessa instância, o elemento da matriz correspondente contém Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se houver mais de count subcadeias de caracteres nessa instância, as primeiras count 1 subcadeias de caracteres serão retornadas no primeiro count (a) menos 1 elemento do valor de retorno e os caracteres restantes nessa instância serão retornados no último elemento do valor de retorno.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count for maior que o número de subcadeias de caracteres, as subcadeias de caracteres disponíveis serão retornadas e nenhuma exceção será lançada.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Considerações sobre desempenhoPerformance Considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Caso o aplicativo exija desempenho ideal ou em caso de gerenciamento da alocação da memória ser importante no aplicativo, considere o uso do método IndexOf ou IndexOfAny, e opcionalmente o método de Compare para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Caso você esteja dividindo uma cadeia de caracteres em um separador de caractere, use o método IndexOf ou IndexOfAny para localizar um caractere separador na cadeia de caracteres.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Caso você esteja dividindo uma cadeia de caracteres em uma cadeia de caracteres separadora, use o método IndexOf ou de IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parâmetros

separator
Char Char Char Char

Retornos

String[]

Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nas cadeias de caracteres de uma matriz.Splits a string into a maximum number of substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()

Parâmetros

separator
String[]

Uma matriz de cadeia de caracteres que delimita as subcadeias nessa cadeia de caracteres, uma matriz vazia que não contém delimitadores, ou null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

O número máximo de subcadeias de caracteres a serem retornadas.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries para omitir elementos de matriz vazia da matriz retornada; ou None para incluir elementos de matriz vazia na matriz retornada.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta cadeia de caracteres que são delimitadas por uma ou mais cadeias de caracteres em separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exceções

options não é um dos valores StringSplitOptions.options is not one of the StringSplitOptions values.

Exemplos

O exemplo a seguir usa StringSplitOptions a enumeração para incluir ou excluir subcadeias de caracteres Split geradas pelo método.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentários

Detalhes do valor de retornoReturn value details

As cadeias de caracteres delimitadores não são incluídas nos elementos da matriz retornada.Delimiter strings are not included in the elements of the returned array.

Se essa instância não contiver nenhuma das cadeias de separatorcaracteres ou o count parâmetro for 1, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the strings in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Caso o parâmetro separator seja null ou não contenha nenhum caractere, os caracteres de espaço em branco devem ser considerados os delimitadores.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Os caracteres de espaço em branco são definidos pelo padrão Unicode e retornam true caso sejam passados para o método Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. No entanto, caso o parâmetro separator na chamada para esta sobrecarga de método seja null, a resolução de sobrecarga do compilador falha.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Para identificar sem ambigüidade o método chamado, seu código deve indicar o tipo de null.To unambiguously identify the called method, your code must indicate the type of the null. O exemplo a seguir mostra várias maneiras para identificar sem ambiguidade essa sobrecarga.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

Se o count parâmetro for zero ou o options parâmetro for RemoveEmptyEntries e o comprimento dessa instância for zero, uma matriz vazia será retornada.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Cada elemento de separator define um delimitador separado que consiste em um ou mais caracteres.Each element of separator defines a separate delimiter that consists of one or more characters. Caso o parâmetro options seja None e dois delimitadores sejam adjacentes ou um delimitador esteja no início ou no fim dessa instância, o elemento da matriz correspondente contém Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se houver mais de count subcadeias de caracteres nessa instância, as primeiras count 1 subcadeias de caracteres serão retornadas no primeiro count (a) menos 1 elemento do valor de retorno e os caracteres restantes nessa instância serão retornados no último elemento do valor de retorno.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count for maior que o número de subcadeias de caracteres, as subcadeias de caracteres disponíveis serão retornadas e nenhuma exceção será lançada.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

A matriz de separadorThe separator array

Se qualquer um dos elementos em separator consistir em vários caracteres, a subcadeia de caracteres inteira será considerada um delimitador.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Por exemplo, se um dos elementos em separator for "10", tentar dividir a cadeia de caracteres "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." retorna esta matriz de quatro elementos: {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Detalhes da comparaçãoComparison details

O Split método extrai as subcadeias de caracteres nesta cadeia de caracteres que são delimitadas por uma ou mais cadeias separator no parâmetro e retorna essas subcadeias de caracteres como elementos de uma matriz.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

O Split método procura delimitadores executando comparações usando regras de classificação ordinal que diferenciam maiúsculas de minúsculas.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Para obter mais informações sobre as classificações de palavras, cadeias de System.Globalization.CompareOptions caracteres e ordinais, consulte a enumeração.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

O Split método ignora qualquer elemento de separator cujo valor seja null ou a cadeia de caracteres vazia ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Para evitar resultados ambíguos quando as separator cadeias de caracteres no têm Split caractere em comum, o método prossegue do início até o fim do valor da instância e corresponde ao primeiro elemento em separator que é igual a um delimitador no cópia.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. A ordem na qual as subcadeias de caracteres são encontradas na instância tem precedência sobre a ordem separatordos elementos no.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Por exemplo, considere uma instância cujo valor é "abcdef".For example, consider an instance whose value is "abcdef". Se o primeiro elemento em separator era "ef" e o segundo elemento era "bcde", o resultado da operação Split seria "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". Isso ocorre porque a subcadeia de caracteres na instância, "bcde", é encontrada e corresponde a um separator elemento em antes que a subcadeia de caracteres "f" seja encontrada.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

No entanto, se o primeiro separator elemento de era "BCD" e o segundo elemento era "BC", o resultado da operação Split seria "a" e "ef".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be "a" and "ef". Isso ocorre porque "BCD" é o primeiro delimitador separator que corresponde a um delimitador na instância.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Se a ordem dos separadores foi revertida, o primeiro elemento era "BC" e o segundo elemento era "BCD", o resultado seria "a" e "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be "a" and "def".

Considerações sobre desempenhoPerformance considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Caso o aplicativo exija desempenho ideal ou em caso de gerenciamento da alocação da memória ser importante no aplicativo, considere o uso do método IndexOf ou IndexOfAny, e opcionalmente o método de Compare para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Caso você esteja dividindo uma cadeia de caracteres em um separador de caractere, use o método IndexOf ou IndexOfAny para localizar um caractere separador na cadeia de caracteres.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Caso você esteja dividindo uma cadeia de caracteres em uma cadeia de caracteres separadora, use o método IndexOf ou de IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres com base nas cadeias de caracteres em uma matriz.Splits a string into substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()

Parâmetros

separator
String[]

Uma matriz de cadeia de caracteres que delimita as subcadeias nessa cadeia de caracteres, uma matriz vazia que não contém delimitadores, ou null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries para omitir elementos de matriz vazia da matriz retornada; ou None para incluir elementos de matriz vazia na matriz retornada.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta cadeia de caracteres que são delimitadas por uma ou mais cadeias de caracteres em separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exceções

options não é um dos valores StringSplitOptions.options is not one of the StringSplitOptions values.

Exemplos

O exemplo a seguir ilustra a diferença nas matrizes retornadas chamando o método String.Split(String[], StringSplitOptions) de uma cadeia options de caracteres com StringSplitOptions.None seu StringSplitOptions.RemoveEmptyEntriesparâmetro igual a e.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

   string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
   string[] stringSeparators = new string[] {"[stop]"};
   string[] result;
   
   // Display the original string and delimiter string.
   Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
   Console.WriteLine();
   Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                     stringSeparators[0]);
   Console.WriteLine();                           
      
   // Split a string delimited by another string and return all elements.
   result = source.Split(stringSeparators, StringSplitOptions.None);
   Console.WriteLine("Result including all elements ({0} elements):", 
                     result.Length);
   Console.Write("   ");
   foreach (string s in result)
   {
      Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
   }
   Console.WriteLine();
   Console.WriteLine();

   // Split delimited by another string and return all non-empty elements.
   result = source.Split(stringSeparators, 
                         StringSplitOptions.RemoveEmptyEntries);
   Console.WriteLine("Result including non-empty elements ({0} elements):", 
                     result.Length);
   Console.Write("   ");
   foreach (string s in result)
   {
      Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
   }
   Console.WriteLine();

   // The example displays the following output:
   //    Splitting the string:
   //       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
   //    
   //    Using the delimiter string:
   //       "[stop]"
   //    
   //    Result including all elements (9 elements):
   //       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
   //    
   //    Result including non-empty elements (3 elements):
   //       'ONE' 'TWO' 'THREE'
Module Example
   Public Sub Main()
      Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
      Dim stringSeparators() As String = {"[stop]"}
      Dim result() As String
      
      ' Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:{0}   '{1}'.", vbCrLf, source)
      Console.WriteLine()
      Console.WriteLine("Using the delimiter string:{0}   '{1}'.", _
                        vbCrLf, stringSeparators(0))
      Console.WriteLine()                          
         
      ' Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None)
      Console.WriteLine("Result including all elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
      Console.WriteLine()

      ' Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, _ 
                            StringSplitOptions.RemoveEmptyEntries)
      Console.WriteLine("Result including non-empty elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Splitting the string:
'       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'    
'    Using the delimiter string:
'       "[stop]"
'    
'    Result including all elements (9 elements):
'       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'    
'    Result including non-empty elements (3 elements):
'       'ONE' 'TWO' 'THREE'

O exemplo a seguir define uma matriz de separadores que incluem Pontuação e caracteres de espaço em branco.The following example defines an array of separators that include punctuation and white-space characters. Passar essa matriz junto com um valor de StringSplitOptions.RemoveEmptyEntries para o Split(String[], StringSplitOptions) método retorna uma matriz que consiste em palavras individuais da cadeia de caracteres.Passing this array along with a value of StringSplitOptions.RemoveEmptyEntries to the Split(String[], StringSplitOptions) method returns an array that consists of the individual words from the string.

string[] separators = {",", ".", "!", "?", ";", ":", " "};
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
   Console.WriteLine(word);
   
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
Module Example
   Public Sub Main()
      Dim separators() As String = {",", ".", "!", "?", ";", ":", " "}
      Dim value As String = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
      Dim words() As String = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
      For Each word In words
         Console.WriteLine(word)
      Next   
   End Sub
End Module
' The example displays the following output:
'       The
'       handsome
'       energetic
'       young
'       dog
'       was
'       playing
'       with
'       his
'       smaller
'       more
'       lethargic
'       litter
'       mate

Observe que o método é chamado com o options argumento definido como StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Isso impede que a matriz retornada inclua String.Empty valores que representem correspondências de subcadeias de caracteres vazias entre sinais de Pontuação e caracteres de espaço em branco.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Comentários

Quando uma cadeia de caracteres é delimitada por um conjunto conhecido de cadeias de caracteres Split , você pode usar o método para separá-la em subcadeias de caracteres.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Detalhes do valor de retornoReturn value details

As cadeias de caracteres delimitadores não são incluídas nos elementos da matriz retornada.Delimiter strings are not included in the elements of the returned array. Por exemplo, se a separator matriz incluir a cadeia de caracteres "--" e o valor da instância de cadeia de caracteres atual for "AA--BB-CC", o método retornará uma matriz que contém três elementos: "AA", "BB" e "CC".For example, if the separator array includes the string "--" and the value of the current string instance is "aa--bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se essa instância não contiver nenhuma das cadeias de separatorcaracteres no, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Se o options parâmetro for RemoveEmptyEntries e o comprimento dessa instância for zero, o método retornará uma matriz vazia.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Cada elemento de separator define um delimitador separado que consiste em um ou mais caracteres.Each element of separator defines a separate delimiter that consists of one or more characters. Se o options argumento for None, e dois delimitadores estiverem adjacentes ou um delimitador for encontrado no início ou no final dessa instância, o elemento de String.Emptymatriz correspondente conterá.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Por exemplo, se separator inclui dois elementos, "-" e "_", o valor da instância de cadeia de caracteres é_"-_AA options -", e o valor do argumento Noneé, o método retorna uma matriz de seqüência com os cinco seguintes elementos:For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a sting array with the following five elements:

  1. String.Empty, que representa a cadeia de caracteres vazia que precede a subcadeia de caracteres "-" no índice 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, que representa a cadeia de caracteres vazia entre a subcadeia de caracteres "-" no índice 0 e a subcadeia de caracteres "" no índice 1.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. "AA","aa",

  4. String.Empty, que representa a cadeia de caracteres vazia que segue a subcadeia de caracteres "" no índice 4.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, que representa a cadeia de caracteres vazia que segue a subcadeia de caracteres "-" no índice 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

A matriz de separadorThe separator array

Se qualquer um dos elementos em separator consistir em vários caracteres, a subcadeia de caracteres inteira será considerada um delimitador.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Por exemplo, se um dos elementos em separator for "10", tentar dividir a cadeia de caracteres "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Retorna a seguinte matriz de quatro elementos: {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Caso o parâmetro separator seja null ou não contenha nenhum caractere, os caracteres de espaço em branco devem ser considerados os delimitadores.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Os caracteres de espaço em branco são definidos pelo padrão Unicode e retornam true caso sejam passados para o método Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Se o separator parâmetro na chamada para essa sobrecarga de método for null, a resolução de sobrecarga do compilador falhará.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Para identificar sem ambigüidade o método chamado, seu código deve indicar o tipo de null.To unambiguously identify the called method, your code must indicate the type of the null. O exemplo a seguir mostra várias maneiras para identificar sem ambiguidade essa sobrecarga.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {},
                     StringSplitOptions.RemoveEmptyEntries)

Detalhes da comparaçãoComparison details

O Split método extrai as subcadeias de caracteres nesta cadeia de caracteres que são delimitadas por uma ou mais cadeias separator no parâmetro e retorna essas subcadeias de caracteres como elementos de uma matriz.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

O Split método procura delimitadores executando comparações usando regras de classificação ordinal que diferenciam maiúsculas de minúsculas.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Para obter mais informações sobre as classificações de palavras, cadeias de System.Globalization.CompareOptions caracteres e ordinais, consulte a enumeração.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

O Split método ignora qualquer elemento de separator cujo valor seja null ou a cadeia de caracteres vazia ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Para evitar os resultados ambíguos quando separator as cadeias de caracteres em Split têm caractere em comum, a operação prossegue desde o início até o fim do valor da instância e corresponde ao primeiro separator elemento em que é igual a um delimitador no cópia.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. A ordem na qual as subcadeias de caracteres são encontradas na instância tem precedência sobre a ordem separatordos elementos no.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Por exemplo, considere uma instância cujo valor é "abcdef".For example, consider an instance whose value is "abcdef". Se o primeiro elemento em separator era "ef" e o segundo elemento era "bcde", o resultado da operação Split seria uma matriz de cadeia de caracteres que contém dois elementos, "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". Isso ocorre porque a subcadeia de caracteres na instância, "bcde", é encontrada e corresponde a um separator elemento em antes que a subcadeia de caracteres "f" seja encontrada.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

No entanto, se o primeiro separator elemento de era "BCD" e o segundo elemento era "BC", o resultado da operação Split seria uma matriz de cadeia de caracteres que contém dois elementos, "a" e "ef".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be a string array that contains two elements, "a" and "ef". Isso ocorre porque "BCD" é o primeiro delimitador separator que corresponde a um delimitador na instância.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Se a ordem dos separadores foi revertida, o primeiro elemento era "BC" e o segundo elemento era "BCD", o resultado seria uma matriz de cadeia de caracteres que contém dois elementos, "a" e "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be a string array that contains two elements, "a" and "def".

Considerações sobre desempenhoPerformance considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Caso o aplicativo exija desempenho ideal ou em caso de gerenciamento da alocação da memória ser importante no aplicativo, considere o uso do método IndexOf ou IndexOfAny, e opcionalmente o método de Compare para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Caso você esteja dividindo uma cadeia de caracteres em um separador de caractere, use o método IndexOf ou IndexOfAny para localizar um caractere separador na cadeia de caracteres.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Caso você esteja dividindo uma cadeia de caracteres em uma cadeia de caracteres separadora, use o método IndexOf ou de IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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

public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parâmetros

Retornos

String[]

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings based on the characters in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()

Parâmetros

separator
Char[]

Uma matriz de caracteres que delimita as subcadeias de caracteres nesta cadeia de caracteres, uma matriz vazia que não contém delimitadores ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries para omitir elementos de matriz vazia da matriz retornada; ou None para incluir elementos de matriz vazia na matriz retornada.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta cadeia de caracteres que são delimitadas por um ou mais caracteres em separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exceções

options não é um dos valores StringSplitOptions.options is not one of the StringSplitOptions values.

Exemplos

O exemplo a seguir usa StringSplitOptions a enumeração para incluir ou excluir subcadeias de caracteres Split geradas pelo método.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine("1a )The original string is \"{0}\".", s1);
Console.WriteLine("The delimiter character is '{0}'.\n", 
                   charSeparators[0]);

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine("2a) The original string is \"{0}\".", s2);
Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " + 
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
    {
        Console.Write("<{0}>", entry);
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Comentários

Detalhes do valor de retornoReturn value details

Os caracteres delimitadores (os separator caracteres na matriz) não são incluídos nos elementos da matriz retornada.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Por exemplo, se a separator matriz incluir o caractere "-" e o valor da instância atual da cadeia de caracteres for "AA-BB-CC", o método retornará uma matriz que contém três elementos: "AA", "BB" e "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se essa instância não contiver nenhum dos caracteres em separator, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Se o options parâmetro for RemoveEmptyEntries e o comprimento dessa instância for zero, o método retornará uma matriz vazia.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Cada elemento de separator define um delimitador separado que consiste em um único caractere.Each element of separator defines a separate delimiter that consists of a single character. Se o options argumento for None, e dois delimitadores estiverem adjacentes ou um delimitador for encontrado no início ou no final dessa instância, o elemento de String.Emptymatriz correspondente conterá.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Por exemplo, se separator inclui dois elementos, "-" e "_", o valor da instância de cadeia de caracteres é_"-_AA options -", e o valor do argumento Noneé, o método retorna uma matriz de cadeia de caracteres com os cinco seguintes elementos:For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

  1. String.Empty, que representa a cadeia de caracteres vazia que precede o caractere "-" no índice 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, que representa a cadeia de caracteres vazia entre o caractere "-" no índice 0 e o caractere "" no índice 1.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. "AA","aa",

  4. String.Empty, que representa a cadeia de caracteres vazia que segue o caractere "" no índice 4.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. String.Empty, que representa a cadeia de caracteres vazia que segue o caractere "-" no índice 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

A matriz de separadorThe separator array

Caso o parâmetro separator seja null ou não contenha nenhum caractere, os caracteres de espaço em branco devem ser considerados os delimitadores.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Os caracteres de espaço em branco são definidos pelo padrão Unicode e retornam true caso sejam passados para o método Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Se o separator parâmetro na chamada para essa sobrecarga de método for null, a resolução de sobrecarga do compilador falhará.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Para identificar sem ambigüidade o método chamado, seu código deve indicar o tipo de null.To unambiguously identify the called method, your code must indicate the type of the null. O exemplo a seguir mostra várias maneiras para identificar sem ambiguidade essa sobrecarga.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((char[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 
                     StringSplitOptions.RemoveEmptyEntries)

Detalhes da comparaçãoComparison details

O Split método extrai as subcadeias de caracteres nesta cadeia de caracteres que são delimitadas por um ou mais caracteres separator no parâmetro e retorna essas subcadeias de caracteres como elementos de uma matriz.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

O Split método procura delimitadores executando comparações usando regras de classificação ordinal que diferenciam maiúsculas de minúsculas.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Para obter mais informações sobre as classificações de palavras, cadeias de System.Globalization.CompareOptions caracteres e ordinais, consulte a enumeração.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerações sobre desempenhoPerformance Considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Caso o aplicativo exija desempenho ideal ou em caso de gerenciamento da alocação da memória ser importante no aplicativo, considere o uso do método IndexOf ou IndexOfAny, e opcionalmente o método de Compare para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Caso você esteja dividindo uma cadeia de caracteres em um separador de caractere, use o método IndexOf ou IndexOfAny para localizar um caractere separador na cadeia de caracteres.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Caso você esteja dividindo uma cadeia de caracteres em uma cadeia de caracteres separadora, use o método IndexOf ou de IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array. Especifique também o número máximo de subcadeias de caracteres a serem retornadas.You also specify the maximum number of substrings to return.

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

Parâmetros

separator
Char[]

Uma matriz de caracteres que delimita as subcadeias de caracteres nesta cadeia de caracteres, uma matriz vazia que não contém delimitadores ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

O número máximo de subcadeias de caracteres a serem retornadas.The maximum number of substrings to return.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta instância que são delimitadas por um ou mais caracteres em separator.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exceções

Exemplos

O exemplo a seguir demonstra count como o afeta o número de cadeias de caracteres retornadas por. SplitThe following example demonstrates how count affects the number of strings returned by Split.

string delimStr = " ,.:";
char [] delimiter = delimStr.ToCharArray();
string words = "one two,three:four.";
string [] split = null;

Console.WriteLine("The delimiters are -{0}-", delimStr);
for (int x = 1; x <= 5; x++) 
{
   split = words.Split(delimiter, x);
   Console.WriteLine("\ncount = {0,2} ..............", x);
   foreach (var s in split) 
   {
       Console.WriteLine("-{0}-", s);
   }
}

// The example displays the following output:
//       The delimiters are - ,.:-
//       count =  1 ..............
//       -one two,three:four.-
//       count =  2 ..............
//       -one-
//       -two,three:four.-
//       count =  3 ..............
//       -one-
//       -two-
//       -three:four.-
//       count =  4 ..............
//       -one-
//       -two-
//       -three-
//       -four.-
//       count =  5 ..............
//       -one-
//       -two-
//       -three-
//       -four-
//       --
Public Class StringSplit2
   Public Shared Sub Main()
      
      Dim delimStr As String = " ,.:"
      Dim delimiter As Char() = delimStr.ToCharArray()
      Dim words As String = "one two,three:four."
      Dim split As String() = Nothing
      
      Console.WriteLine("The delimiters are -{0}-", delimStr)
      Dim x As Integer
      For x = 1 To 5
         split = words.Split(delimiter, x)
         Console.WriteLine(ControlChars.Cr + "count = {0,2} ..............", x)
         Dim s As String
         For Each s In  split
            Console.WriteLine("-{0}-", s)
         Next s
      Next x
   End Sub 
End Class 
' The example displays the following output:
'       The delimiters are - ,.:-
'       count =  1 ..............
'       -one two,three:four.-
'       count =  2 ..............
'       -one-
'       -two,three:four.-
'       count =  3 ..............
'       -one-
'       -two-
'       -three:four.-
'       count =  4 ..............
'       -one-
'       -two-
'       -three-
'       -four.-
'       count =  5 ..............
'       -one-
'       -two-
'       -three-
'       -four-
'       --

Comentários

Os caracteres delimitadores não estão incluídos nos elementos da matriz retornada.Delimiter characters are not included in the elements of the returned array.

Se essa instância não contiver nenhum dos caracteres em separator, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Se count for zero, uma matriz vazia será retornada.If count is zero, an empty array is returned.

Caso o parâmetro separator seja null ou não contenha nenhum caractere, os caracteres de espaço em branco devem ser considerados os delimitadores.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Os caracteres de espaço em branco são definidos pelo padrão Unicode e retornam true caso sejam passados para o método Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Cada elemento de separator define um caractere delimitador à parte.Each element of separator defines a separate delimiter character. Se dois delimitadores estiverem adjacentes ou um delimitador for encontrado no início ou no final dessa instância, o elemento de matriz Emptycorrespondente conterá.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se houver mais de count subcadeias de caracteres nessa instância, as primeiras count 1 subcadeias de caracteres serão retornadas no primeiro count (a) menos 1 elemento do valor de retorno e os caracteres restantes nessa instância serão retornados no último elemento do valor de retorno.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count for maior que o número de subcadeias de caracteres, as subcadeias de caracteres disponíveis serão retornadas e nenhuma exceção será lançada.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

A tabela a seguir fornece exemplos.The following table provides examples.

Valor da cadeia de caracteresString value SeparadorSeparator ContagemCount Matriz retornadaReturned array
"42, 12, 19""42, 12, 19" novo Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c "," "c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)
22 {"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19" novo Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
Banana"Banana" novo Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
22 {"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
novo Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
11 {"Darb\nSmarba"} (C#){"Darb\nSmarba"} (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
novo Char [] nulo (C#)new Char[] null (C#)

Char() = NothingChar() = Nothing
22 {"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
novo Char [] nulo (C#)new Char[] null (C#)

Char() = NothingChar() = Nothing
100100 {"Darb", "Smarba"}{"Darb", "Smarba"}

Considerações sobre desempenhoPerformance Considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Caso o aplicativo exija desempenho ideal ou em caso de gerenciamento da alocação da memória ser importante no aplicativo, considere o uso do método IndexOf ou IndexOfAny, e opcionalmente o método de Compare para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Caso você esteja dividindo uma cadeia de caracteres em um separador de caractere, use o método IndexOf ou IndexOfAny para localizar um caractere separador na cadeia de caracteres.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Caso você esteja dividindo uma cadeia de caracteres em uma cadeia de caracteres separadora, use o método IndexOf ou de IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Veja também

Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parâmetros

separator
Char Char Char Char

Retornos

String[]

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

public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parâmetros

Retornos

String[]

Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings that are based on the characters in an array.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()

Parâmetros

separator
Char[]

Uma matriz de caracteres que delimita as subcadeias de caracteres nesta cadeia de caracteres, uma matriz vazia que não contém delimitadores ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

Retornos

String[]

Uma matriz cujos elementos contêm as subcadeias de caracteres desta instância que são delimitadas por um ou mais caracteres em separator.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Para obter mais informações, consulte a seção Comentários.For more information, see the Remarks section.

Exemplos

O exemplo a seguir demonstra como extrair palavras individuais de um bloco de texto tratando espaço em branco e marcas de Pontuação como delimitadores.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. A matriz de caracteres passada para separator o parâmetro String.Split(Char[]) do método consiste em um caractere de espaço e um caractere de tabulação, juntamente com alguns símbolos de Pontuação comuns.The character array passed to the separator parameter of the String.Split(Char[]) method consists of a space character and a tab character, together with some common punctuation symbols.

string words = "This is a list of words, with: a bit of punctuation" +
               "\tand a tab character.";

string [] split = words.Split(new Char [] {' ', ',', '.', ':', '\t' });

foreach (string s in split) 
{

    if (s.Trim() != "")
        Console.WriteLine(s);
}

// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character
Public Class SplitTest
    Public Shared Sub Main()
        Dim words As String = "This is a list of words, with: a bit of punctuation" + _
                              vbTab + "and a tab character."
        Dim split As String() = words.Split(New [Char]() {" "c, ","c, "."c, ":"c, CChar(vbTab) })
                
        For Each s As String In  split
            If s.Trim() <> "" Then
                Console.WriteLine(s)
            End If
        Next s
    End Sub
End Class
' The example displays the following output to the console:
'       This
'       is
'       a
'       list
'       of
'       words
'       with
'       a
'       bit
'       of
'       punctuation
'       and
'       a
'       tab
'       character

Comentários

Quando uma cadeia é delimitada por um conjunto conhecido de caracteres, você pode usar o Split(Char[]) método para separá-la em subcadeias.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Detalhes do valor de retornoReturn value details

Os caracteres delimitadores não estão incluídos nos elementos da matriz retornada.Delimiter characters are not included in the elements of the returned array. Por exemplo, se a matriz de separador incluir o caractere "-" e o valor da instância de cadeia de caracteres atual for "AA-BB-CC", o método retornará uma matriz que contém três elementos: "AA", "BB" e "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se essa instância não contiver nenhum dos caracteres em separator, a matriz retornada consistirá em um único elemento que contém essa instância.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Cada elemento de separator define um caractere delimitador à parte.Each element of separator defines a separate delimiter character. Se dois delimitadores estiverem adjacentes ou um delimitador for encontrado no início ou no final dessa instância, o elemento correspondente na matriz retornada conterá Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. Estes são alguns exemplos:Here are some examples:

Valor da cadeia de caracteresString value SeparadorSeparator Matriz retornadaReturned array
"42, 12, 19""42, 12, 19" novo Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c, "" c}) (Visual Basic)Char() = {","c, " "c}) (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19" novo Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Banana"Banana" novo Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
novo Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null (C#)null (C#)

Nada (Visual Basic)Nothing (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}

A matriz de separadorThe separator array

Cada elemento do separador define um delimitador separado que consiste em um único caractere.Each element of separator defines a separate delimiter that consists of a single character. Se o separator argumento for null ou não contiver caracteres, o método tratará caracteres de espaço em branco como delimitadores.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Caracteres de espaço em branco são definidos pelo padrão Unicode; elas retornam true se são passadas para Char.IsWhiteSpace o método.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String. Split (Char []) e resolução de sobrecarga do compiladorString.Split(Char[]) and compiler overload resolution

Embora o parâmetro único para essa sobrecarga de String.Split seja uma matriz de caracteres, você pode chamá-lo com um único caractere, como mostra o exemplo a seguir.Although the single parameter for this overload of String.Split is a character array, you can call it with a single character, as the following example shows.

String value = "This is a short string.";
Char delimiter = 's';
String[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
   Console.WriteLine(substring);
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
Module Example
   Public Sub Main()
      Dim value As String = "This is a short string."
      Dim delimiter As Char = "s"c
      Dim substrings() As String = value.Split(delimiter)
      For Each substring In substrings
         Console.WriteLine(substring)
      Next
   End Sub
End Module
' The example displays the following output:
'     Thi
'      i
'      a
'     hort
'     tring.

Como o separator parâmetro é decorado com ParamArrayAttribute o atributo, os compiladores interpretarão um único caractere como uma matriz de caracteres de elemento único.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Esse não é o caso para outras String.Split sobrecargas que incluem um separator parâmetro; você deve transmitir explicitamente essas sobrecargas de uma matriz de caracteres separator como o argumento.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Detalhes da comparaçãoComparison details

O Split(Char[]) método extrai as subcadeias de caracteres nesta cadeia de caracteres delimitadas por um ou mais caracteres separator na matriz e retorna essas subcadeias como elementos de uma matriz.The Split(Char[]) method extracts the substrings in this string that are delimited by one or more of the characters in the separator array, and returns those substrings as elements of an array.

O Split(Char[]) método procura delimitadores executando comparações usando regras de classificação ordinal que diferenciam maiúsculas de minúsculas.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Para obter mais informações sobre as classificações de palavras, cadeias de System.Globalization.CompareOptions caracteres e ordinais, consulte a enumeração.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerações sobre desempenhoPerformance Considerations

Os métodos Split alocam memória para o objeto de matriz retornado e um objeto String para cada elemento da matriz.The Split methods allocate memory for the returned array object and a String object for each array element. Se seu aplicativo exigir um desempenho ideal ou se o gerenciamento de alocação de memória for crítico em seu aplicativo IndexOf , IndexOfAny considere usar o método ou.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Você também tem a opção de usar o Compare método para localizar uma subcadeia de caracteres dentro de uma cadeia de caracteres.You also have the option of using the Compare method to locate a substring within a string.

Para dividir uma cadeia de caracteres em um caractere separador IndexOfAny , use o IndexOf método ou para localizar um caractere separador na cadeia de caracteres.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Para dividir uma cadeia de caracteres em uma cadeia de caracteres IndexOf separadora, use o método ou IndexOfAny para localizar o primeiro caractere da cadeia de caracteres separadora.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Em seguida, use o método Compare para determinar se os caracteres depois desse primeiro caractere são iguais aos caracteres restantes da cadeia de caracteres separadora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Além disso, caso o mesmo conjunto de caracteres seja usado para dividir cadeias de caracteres em várias chamadas de método Split, considere criar uma matriz única e referencie-a em cada chamada de método.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Isso reduz significativamente a sobrecarga adicional de cada chamada de método.This significantly reduces the additional overhead of each method call.

Notas aos Chamadores

No .NET Framework 3,5.NET Framework 3.5 e em versões anteriores, caso o método Split(Char[]) receba um separator que é null ou não contém nenhum caractere, o método usa um conjunto um pouco diferente de caracteres para dividir a cadeia de caracteres do método Trim(Char[]) para cortar a cadeia de caracteres.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partir do .NET Framework 4, ambos os métodos usam um conjunto idêntico de caracteres de espaço em branco Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Veja também

Aplica-se a