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

Definicja

Zwraca tablicę ciągów zawierającą podciągi w tym wystąpieniu, które są ograniczone przez elementy określonego ciągu lub tablicy znaków 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.

Przeciążenia

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

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.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)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie ciągów w tablicy.Splits a string into a maximum number of substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.You can specify whether the substrings include empty array elements.

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

Dzieli ciąg na podciągi na podstawie ciągów w tablicy.Splits a string into substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.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)

Dzieli ciąg na podciągi w oparciu o znaki w tablicy.Splits a string into substrings based on the characters in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.You can specify whether the substrings include empty array elements.

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

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.Splits a string into a maximum number of substrings based on the characters in an array. Należy również określić maksymalną liczbę podciągów do zwrócenia.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[])

Dzieli ciąg na podciągi, które są oparte na znakach w tablicy.Splits a string into substrings that are based on the characters in an array.

Uwagi

Splitsłuży do dzielenia ciągu rozdzielonego na podciągi.Split is used to break a delimited string into substrings. Można użyć tablicy znaków, aby określić zero, jeden lub wiele znaków ograniczających ( Split(Char[]) Metoda) lub użyć tablicy znakowej, aby określić zero, jeden lub wiele ciągów, które mają być ograniczone.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. Przeciążenia metody pozwalają ograniczyć liczbę podciągów zwracanych przez metodę Split(Char[], Int32) (Metoda), aby określić, czy puste ciągi są zawarte w zwracanych podciągach ( Split(Char[], StringSplitOptions) i Split(String[], StringSplitOptions) metodach lub Split Aby wykonać obie metody ( Split(Char[], Int32, StringSplitOptions) i 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).

Uwaga

Przykłady języka C#, w tym artykule są uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.The C# examples in this article run in the Try.NET inline code runner and playground. Wybierz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.Select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternatywy dla ciągu. SplitAlternatives to String.Split

Split Metoda nie zawsze jest najlepszym sposobem na rozbicie rozdzielanego ciągu na podciągi.The Split method is not always the best way to break a delimited string into substrings. Jeśli nie chcesz wyodrębnić wszystkich podciągów z rozdzielonym ciągiem lub jeśli chcesz przeanalizować ciąg na podstawie wzorca zamiast zestawu znaków ogranicznika, weź pod uwagę następujące alternatywy.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.

Wyrażenia regularneRegular expressions

Jeśli ciągi są zgodne ze stałym wzorcem, można użyć wyrażenia regularnego, aby wyodrębnić i obsłużyć ich elementy.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Na przykład, jeśli ciągi przyjmują postać " numer operandu numeru " można użyć wyrażenia regularnego , aby wyodrębnić i obsłużyć elementy ciągu.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Oto przykład: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

Wzorzec (\d+)\s+([-+*/])\s+(\d+) wyrażenia regularnego jest zdefiniowany w następujący sposób:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

WzorzecPattern OpisDescription
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s+ Dopasowuje co najmniej jeden znak odstępu.Match one or more white-space characters.
([-+*/]) Dopasowuje znak operatora arytmetycznego (+,-, * lub/).Match an arithmetic operator sign (+, -, *, or /). Jest to druga grupa przechwytywania.This is the second capturing group.
\s+ Dopasowuje co najmniej jeden znak odstępu.Match one or more white-space characters.
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits. Jest to trzecia grupa przechwytywania.This is the third capturing group.

Możesz również użyć wyrażenia regularnego, aby wyodrębnić podciągi z ciągu na podstawie wzorca, a nie stałego zestawu znaków.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Jest to typowy scenariusz, gdy występuje jeden z następujących warunków:This is a common scenario when either of these conditions occurs:

  • Co najmniej jeden znak ogranicznika nie zawsze pełni rolę ogranicznika w String wystąpieniu.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • Sekwencja i liczba znaków ogranicznika są zmienne lub nieznane.The sequence and number of delimiter characters is variable or unknown.

Na przykład Split Metoda nie może być używana do dzielenia poniższego ciągu, ponieważ \n liczba znaków (in C#) lub vbCrLf (w Visual Basic) jest zmienna i nie zawsze są one ogranicznikami.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.]  

Wyrażenie regularne może łatwo podzielić ten ciąg, jak pokazano w poniższym przykładzie.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.

Wzorzec \[([^\[\]]+)\] wyrażenia regularnego jest zdefiniowany w następujący sposób:The regular expression pattern \[([^\[\]]+)\] is defined like this:

WzorzecPattern OpisDescription
\[ Dopasowuje nawias otwierający.Match an opening bracket.
([^\[\]]+) Dopasowuje dowolny znak, który nie jest otwierającym lub zamykającym nawiasem jeden lub więcej razy.Match any character that is not an opening or a closing bracket one or more times. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\] Dopasowuje nawias zamykający.Match a closing bracket.

Metoda jest niemal identyczna z String.Split, z tą różnicą, że dzieli ciąg na podstawie wzorca wyrażenia regularnego zamiast stałego zestawu znaków. Regex.SplitThe 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. Na przykład poniższy przykład używa Regex.Split metody, aby podzielić ciąg, który zawiera podciągi rozdzielone różnymi kombinacjami łączników i innych znaków.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

Wzorzec \s-\s?[+*]?\s?-\s wyrażenia regularnego jest zdefiniowany w następujący sposób:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

WzorzecPattern OpisDescription
\s- Dopasowuje znak odstępu, po którym następuje łącznik.Match a white-space character followed by a hyphen.
\s? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
[+*]? Dopasowanie do zera lub jednego wystąpienia znaku + lub *.Match zero or one occurrence of either the + or * character.
\s? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
-\s Dopasowuje łącznik po którym następuje znak odstępu.Match a hyphen followed by a white-space character.

Metody wyszukiwania i Metoda substringSearch methods and the Substring method

Jeśli nie interesują Cię wszystkie podciągi w ciągu, być może wolisz pracować z jedną z metod porównywania ciągów, która zwraca indeks, w którym rozpoczyna się dopasowanie.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. Następnie można wywołać Substring metodę, aby wyodrębnić żądany podciąg.You can then call the Substring method to extract the substring that you want. Metody porównywania ciągów obejmują:The string comparison methods include:

  • IndexOf, która zwraca indeks (liczony od zera) pierwszego wystąpienia znaku lub ciągu w wystąpieniu ciągu.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, która zwraca indeks (liczony od zera) w bieżącym wystąpieniu ciągu pierwszego wystąpienia dowolnego znaku w tablicy znaków.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, która zwraca indeks (liczony od zera) ostatniego wystąpienia znaku lub ciągu w wystąpieniu ciągu.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, która zwraca indeks (liczony od zera) w bieżącym wystąpieniu ciągu ostatniego wystąpienia dowolnego znaku w tablicy znaków.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

W poniższym przykładzie zastosowano IndexOf metodę, aby znaleźć okresy w ciągu.The following example uses the IndexOf method to find the periods in a string. Następnie używa Substring metody do zwracania pełnych zdań.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)

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.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()

Parametry

separator
Char[]

Tablica znaków, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani 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

Maksymalna liczba podciągów do zwrócenia.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntriesAby pominąć puste elementy tablicy z zwróconej tablicy; lub None , aby uwzględnić puste elementy tablicy w zwracanej tablicy.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Zwraca

String[]

Tablica, której elementy zawierają podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej znaków w separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Wyjątki

optionsnie jest jedną z StringSplitOptions wartości.options is not one of the StringSplitOptions values.

Przykłady

Poniższy przykład używa StringSplitOptions wyliczenia do dołączania lub wykluczania podciągów generowanych Split przez metodę.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]>
'

Uwagi

Znaki ogranicznika nie są uwzględnione w elementach zwróconej tablicy.Delimiter characters are not included in the elements of the returned array.

Jeśli to wystąpienie nie zawiera żadnego ze znaków w separator, count lub parametr ma wartość 1, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.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. Jeśli parametr ma null lub nie zawiera znaków, zakłada się, że znaki odstępu są ogranicznikami. separatorIf the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Znaki odstępu są definiowane przez standard Unicode i zwracane true , jeśli są przesyłane Char.IsWhiteSpace do metody.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Jeśli separator jednak parametr w wywołaniu tego przeciążenia metody ma wartość null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Aby jednoznacznie zidentyfikować wywołaną metodę, kod musi wskazywać typ wartości null.To unambiguously identify the called method, your code must indicate the type of the null. W poniższym przykładzie pokazano kilka sposobów na jednoznaczną identyfikację tego przeciążenia.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)

Jeśli parametr ma wartość zero options lub parametr jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, zwracana jest pusta tablica. countIf the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Każdy element separator definiuje oddzielny znak ogranicznika.Each element of separator defines a separate delimiter character. Jeśli parametr jest Nonei dwa ograniczniki są przyległe lub ogranicznik znajduje się na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera Empty. optionsIf 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.

Jeśli w tym wystąpieniu znajduje count się więcej niż podciągi, pierwsze count minus 1 podciągi są zwracane w pierwszych count minus 1 elementów wartości zwracanej, a pozostałe znaki w tym wystąpieniu są zwracane w ciągu ostatnich element wartości zwracanej.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.

Jeśli count jest większa niż liczba podciągów, zwracane są dostępne podciągi i nie jest zgłaszany żaden wyjątek.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Zagadnienia dotyczące wydajnościPerformance Considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, rozważ użycie IndexOf Compare metody IndexOfAny lub i opcjonalnie metodę, aby zlokalizować podciąg w ciągu.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.

W przypadku dzielenia ciągu na znak separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. W przypadku dzielenia ciągu na ciąg separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.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. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku 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()

Parametry

separator
Char Char Char Char

Zwraca

String[]

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

Dzieli ciąg na maksymalną liczbę podciągów na podstawie ciągów w tablicy.Splits a string into a maximum number of substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.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()

Parametry

separator
String[]

Tablica ciągów, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani 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

Maksymalna liczba podciągów do zwrócenia.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntriesAby pominąć puste elementy tablicy z zwróconej tablicy; lub None , aby uwzględnić puste elementy tablicy w zwracanej tablicy.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Zwraca

String[]

Tablica, której elementy zawierają podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej ciągów w separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Wyjątki

optionsnie jest jedną z StringSplitOptions wartości.options is not one of the StringSplitOptions values.

Przykłady

Poniższy przykład używa StringSplitOptions wyliczenia do dołączania lub wykluczania podciągów generowanych Split przez metodę.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]>
'

Uwagi

Szczegóły wartości zwracanejReturn value details

Ciągi ograniczników nie są uwzględniane w elementach zwracanej tablicy.Delimiter strings are not included in the elements of the returned array.

Jeśli to wystąpienie nie zawiera żadnych ciągów w separator count lub parametr ma wartość 1, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.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. Jeśli parametr ma null lub nie zawiera znaków, zakłada się, że znaki odstępu są ogranicznikami. separatorIf the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Znaki odstępu są definiowane przez standard Unicode i zwracane true , jeśli są przesyłane Char.IsWhiteSpace do metody.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Jeśli separator jednak parametr w wywołaniu tego przeciążenia metody ma wartość null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Aby jednoznacznie zidentyfikować wywołaną metodę, kod musi wskazywać typ null.To unambiguously identify the called method, your code must indicate the type of the null. W poniższym przykładzie pokazano kilka sposobów na jednoznaczną identyfikację tego przeciążenia.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)

Jeśli parametr ma wartość zero options lub parametr jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, zwracana jest pusta tablica. countIf the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Każdy element separator definiuje oddzielny ogranicznik, który składa się z co najmniej jednego znaku.Each element of separator defines a separate delimiter that consists of one or more characters. Jeśli parametr jest Nonei dwa ograniczniki są przyległe lub ogranicznik znajduje się na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera Empty. optionsIf 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.

Jeśli w tym wystąpieniu znajduje count się więcej niż podciągi, pierwsze count minus 1 podciągi są zwracane w pierwszych count minus 1 elementów wartości zwracanej, a pozostałe znaki w tym wystąpieniu są zwracane w ciągu ostatnich element wartości zwracanej.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.

Jeśli count jest większa niż liczba podciągów, zwracane są dostępne podciągi i nie jest zgłaszany żaden wyjątek.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Tablica separatorówThe separator array

Jeśli którykolwiek z elementów w separator składa się z wielu znaków, cały podciąg jest traktowany jako ogranicznik.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Na przykład, jeśli jeden z elementów w separator ma wartość "10", próbuje podzielić ciąg "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." zwraca tablicę czterech elementów: {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Szczegóły porównaniaComparison details

Metoda wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden ciąg separator w parametrze i zwraca te podciągi jako elementy tablicy. SplitThe 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.

Split Metoda szuka ograniczników przez wykonywanie porównań przy użyciu reguł sortowania porządkowego z uwzględnieniem wielkości liter.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Więcej informacji na temat wyrazów, ciągów i sortowania porządkowego znajduje się System.Globalization.CompareOptions w wyliczeniu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Metoda ignoruje wszystkie elementy, separator których wartość jest null lub pusty ciąg (""). SplitThe Split method ignores any element of separator whose value is null or the empty string ("").

Aby uniknąć niejednoznacznych wyników separator Split , gdy ciągi w znaki są wspólne, Metoda przechodzi od początku do końca wartości wystąpienia i dopasowuje pierwszy element w separator , który jest równy ogranicznikowi w np.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. Kolejność, w której są napotkane podciągi, ma pierwszeństwo przed kolejnością elementów w separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Rozważmy na przykład wystąpienie o wartości "abcdef".For example, consider an instance whose value is "abcdef". Jeśli pierwszy element w separator było "EF", a drugi element miał wartość "bcde", wynikiem operacji podziału byłaby "a" i "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". Wynika to z faktu, że podciąg w wystąpieniu ("bcde") został napotkany i pasuje separator do elementu w elemencie przed wystąpieniem podciągu "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Jeśli jednak pierwszy element separator to "bcd", a drugi element miał wartość "BC", wynikiem operacji podziału byłaby "a" i "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". Dzieje się tak, ponieważ "bcd" to pierwszy ogranicznik w programie separator , który pasuje do ogranicznika w wystąpieniu.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Jeśli kolejność separatorów została odwrócona, więc pierwszy element miał wartość "BC", a drugi element to "bcd", wynikiem byłaby "a" i "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".

Zagadnienia dotyczące wydajnościPerformance considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, rozważ użycie IndexOf Compare metody IndexOfAny lub i opcjonalnie metodę, aby zlokalizować podciąg w ciągu.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.

W przypadku dzielenia ciągu na znak separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. W przypadku dzielenia ciągu na ciąg separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.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. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku 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)

Dzieli ciąg na podciągi na podstawie ciągów w tablicy.Splits a string into substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.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()

Parametry

separator
String[]

Tablica ciągów, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani 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

RemoveEmptyEntriesAby pominąć puste elementy tablicy z zwróconej tablicy; lub None , aby uwzględnić puste elementy tablicy w zwracanej tablicy.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Zwraca

String[]

Tablica, której elementy zawierają podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej ciągów w separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Wyjątki

optionsnie jest jedną z StringSplitOptions wartości.options is not one of the StringSplitOptions values.

Przykłady

Poniższy przykład String.Split(String[], StringSplitOptions) ilustruje różnicę w tablicach zwracanych przez wywołanie metody ciągu z jej options parametrem równym StringSplitOptions.None i StringSplitOptions.RemoveEmptyEntries.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'

W poniższym przykładzie zdefiniowano tablicę separatorów, które zawierają znaki interpunkcyjne i odstępy.The following example defines an array of separators that include punctuation and white-space characters. Przekazanie tej tablicy wraz z wartością StringSplitOptions.RemoveEmptyEntries Split(String[], StringSplitOptions) do metody zwraca tablicę, która składa się z pojedynczych wyrazów z ciągu.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

Należy zauważyć, że metoda jest wywoływana z options argumentem ustawionym na StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Zapobiega to dołączeniu String.Empty wartości, które reprezentują puste podciągi między znakami interpunkcyjnymi i znakami odstępu.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Uwagi

Jeśli ciąg jest rozdzielany przez znany zestaw ciągów, można użyć Split metody, aby oddzielić ją na podciągi.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Szczegóły wartości zwracanejReturn value details

Ciągi ograniczników nie są uwzględniane w elementach zwracanej tablicy.Delimiter strings are not included in the elements of the returned array. Na przykład, jeśli separator tablica zawiera ciąg "--", a wartość bieżącego wystąpienia ciągu to "AA--BB-DW", metoda zwraca tablicę zawierającą trzy elementy: "AA", "bb" i "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".

Jeśli to wystąpienie nie zawiera żadnych ciągów w separator, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Jeśli parametr jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, metoda zwraca pustą tablicę. optionsIf the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Każdy element separator definiuje oddzielny ogranicznik, który składa się z co najmniej jednego znaku.Each element of separator defines a separate delimiter that consists of one or more characters. Jeśli argument jest None, a dwa ograniczniki są przyległe lub ogranicznik znajduje się na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera String.Empty. optionsIf 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. Na przykład, jeśli separator zawiera dwa elementy, "-" i "_", wartość wystąpienia ciągu to "-_AA options -_", a wartość argumentu to None, metoda zwraca tablicę Sting z pięć następujących elementów: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, która reprezentuje pusty ciąg poprzedzający podciąg "-" pod indeksem 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, która reprezentuje pusty ciąg między podciągiem "-" w indeksie 0 i podciąg "" pod indeksem 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, która reprezentuje pusty ciąg, który następuje po podciągu "" przy indeksie 4.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, która reprezentuje pusty ciąg, który następuje po podciągu "-" pod indeksem 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Tablica separatorówThe separator array

Jeśli którykolwiek z elementów w separator składa się z wielu znaków, cały podciąg jest traktowany jako ogranicznik.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Na przykład, jeśli jeden z elementów w separator ma wartość "10", próbuje podzielić ciąg "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." zwraca następującą tablicę z czterema elementami: {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Jeśli parametr ma null lub nie zawiera znaków, zakłada się, że znaki odstępu są ogranicznikami. separatorIf the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Znaki odstępu są definiowane przez standard Unicode i zwracane true , jeśli są przesyłane Char.IsWhiteSpace do metody.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jeśli parametr w wywołaniu tego przeciążenia metody jest null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem. separatorIf the separator parameter in the call to this method overload is null, compiler overload resolution fails. Aby jednoznacznie zidentyfikować wywołaną metodę, kod musi wskazywać typ null.To unambiguously identify the called method, your code must indicate the type of the null. W poniższym przykładzie pokazano kilka sposobów na jednoznaczną identyfikację tego przeciążenia.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)

Szczegóły porównaniaComparison details

Metoda wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden ciąg separator w parametrze i zwraca te podciągi jako elementy tablicy. SplitThe 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.

Split Metoda szuka ograniczników przez wykonywanie porównań przy użyciu reguł sortowania porządkowego z uwzględnieniem wielkości liter.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Więcej informacji na temat wyrazów, ciągów i sortowania porządkowego znajduje się System.Globalization.CompareOptions w wyliczeniu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Metoda ignoruje wszystkie elementy, separator których wartość jest null lub pusty ciąg (""). SplitThe Split method ignores any element of separator whose value is null or the empty string ("").

Aby uniknąć niejednoznacznych wyników separator Split , gdy ciągi w znaki są wspólne, operacja przechodzi od początku do końca wartości wystąpienia i dopasowuje pierwszy element w separator , który jest równy ogranicznikowi w np.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. Kolejność, w której są napotkane podciągi, ma pierwszeństwo przed kolejnością elementów w separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Rozważmy na przykład wystąpienie o wartości "abcdef".For example, consider an instance whose value is "abcdef". Jeśli pierwszy element w separator było "EF", a drugi element miał wartość "bcde", wynikiem operacji Split będzie tablica ciągów zawierająca dwa elementy: "a" i "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". Wynika to z faktu, że podciąg w wystąpieniu ("bcde") został napotkany i pasuje separator do elementu w elemencie przed wystąpieniem podciągu "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Jeśli jednak pierwszy element elementu separator to "bcd", a drugi element miał wartość "BC", wynikiem operacji Split jest tablica ciągów zawierająca dwa elementy: "a" i "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". Dzieje się tak, ponieważ "bcd" to pierwszy ogranicznik w programie separator , który pasuje do ogranicznika w wystąpieniu.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Jeśli kolejność separatorów została odwrócona, więc pierwszy element miał wartość "BC", a drugi element to "bcd", wynikiem będzie tablica ciągów zawierająca dwa elementy: "a" i "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".

Zagadnienia dotyczące wydajnościPerformance considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, rozważ użycie IndexOf Compare metody IndexOfAny lub i opcjonalnie metodę, aby zlokalizować podciąg w ciągu.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.

W przypadku dzielenia ciągu na znak separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. W przypadku dzielenia ciągu na ciąg separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.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. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku 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()

Parametry

Zwraca

String[]

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

Dzieli ciąg na podciągi w oparciu o znaki w tablicy.Splits a string into substrings based on the characters in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.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()

Parametry

separator
Char[]

Tablica znaków, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani 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

RemoveEmptyEntriesAby pominąć puste elementy tablicy z zwróconej tablicy; lub None , aby uwzględnić puste elementy tablicy w zwracanej tablicy.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Zwraca

String[]

Tablica, której elementy zawierają podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej znaków w separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Wyjątki

optionsnie jest jedną z StringSplitOptions wartości.options is not one of the StringSplitOptions values.

Przykłady

Poniższy przykład używa StringSplitOptions wyliczenia do dołączania lub wykluczania podciągów generowanych Split przez metodę.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]>
'

Uwagi

Szczegóły wartości zwracanejReturn value details

Znaki ogranicznika (znaki w separator tablicy) nie są uwzględniane w elementach zwracanej tablicy.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Na przykład, jeśli separator tablica zawiera znak "-", a wartość bieżącego wystąpienia ciągu to "AA-BB-CC", metoda zwraca tablicę zawierającą trzy elementy: "AA", "bb" i "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".

Jeśli to wystąpienie nie zawiera żadnego ze znaków w separator, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Jeśli parametr jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, metoda zwraca pustą tablicę. optionsIf the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Każdy element separator definiuje oddzielny ogranicznik, który składa się z pojedynczego znaku.Each element of separator defines a separate delimiter that consists of a single character. Jeśli argument jest None, a dwa ograniczniki są przyległe lub ogranicznik znajduje się na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera String.Empty. optionsIf 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. Na przykład, jeśli separator zawiera dwa elementy, "-" i "_", wartość wystąpienia ciągu to "-_AA options -_", a wartość argumentu to None, metoda zwraca tablicę ciągów z pięć następujących elementów: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, która reprezentuje pusty ciąg poprzedzający znak "-" pod indeksem 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, która reprezentuje pusty ciąg między znakiem "-" w indeksie 0 i znak "" pod indeksem 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, która reprezentuje pusty ciąg, który następuje po znaku "" przy indeksie 4.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. String.Empty, która reprezentuje pusty ciąg, który następuje po znaku "-" pod indeksem 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

Tablica separatorówThe separator array

Jeśli parametr ma null lub nie zawiera znaków, zakłada się, że znaki odstępu są ogranicznikami. separatorIf the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Znaki odstępu są definiowane przez standard Unicode i zwracane true , jeśli są przesyłane Char.IsWhiteSpace do metody.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jeśli parametr w wywołaniu tego przeciążenia metody jest null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem. separatorIf the separator parameter in the call to this method overload is null, compiler overload resolution fails. Aby jednoznacznie zidentyfikować wywołaną metodę, kod musi wskazywać typ null.To unambiguously identify the called method, your code must indicate the type of the null. W poniższym przykładzie pokazano kilka sposobów na jednoznaczną identyfikację tego przeciążenia.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)

Szczegóły porównaniaComparison details

Metoda wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden znak separator w parametrze i zwraca te podciągi jako elementy tablicy. SplitThe 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.

Split Metoda szuka ograniczników przez wykonywanie porównań przy użyciu reguł sortowania porządkowego z uwzględnieniem wielkości liter.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Więcej informacji na temat wyrazów, ciągów i sortowania porządkowego znajduje się System.Globalization.CompareOptions w wyliczeniu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Zagadnienia dotyczące wydajnościPerformance Considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, rozważ użycie IndexOf Compare metody IndexOfAny lub i opcjonalnie metodę, aby zlokalizować podciąg w ciągu.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.

W przypadku dzielenia ciągu na znak separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. W przypadku dzielenia ciągu na ciąg separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.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. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku 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)

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.Splits a string into a maximum number of substrings based on the characters in an array. Należy również określić maksymalną liczbę podciągów do zwrócenia.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()

Parametry

separator
Char[]

Tablica znaków, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani 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

Maksymalna liczba podciągów do zwrócenia.The maximum number of substrings to return.

Zwraca

String[]

Tablica, której elementy zawierają podciągi w tym wystąpieniu, które są rozdzielane przez jeden lub więcej znaków w separator.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Wyjątki

Przykłady

Poniższy przykład ilustruje count wpływ liczby ciągów zwracanych przez Split.The 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-
'       --

Uwagi

Znaki ogranicznika nie są uwzględnione w elementach zwróconej tablicy.Delimiter characters are not included in the elements of the returned array.

Jeśli to wystąpienie nie zawiera żadnego ze znaków w separator, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Jeśli count jest równa zero, zwracana jest pusta tablica.If count is zero, an empty array is returned.

Jeśli parametr ma null lub nie zawiera znaków, zakłada się, że znaki odstępu są ogranicznikami. separatorIf the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Znaki odstępu są definiowane przez standard Unicode i zwracane true , jeśli są przesyłane Char.IsWhiteSpace do metody.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Każdy element separator definiuje oddzielny znak ogranicznika.Each element of separator defines a separate delimiter character. Jeśli dwa ograniczniki są przyległe lub ogranicznik jest znaleziony na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Jeśli w tym wystąpieniu znajduje count się więcej niż podciągi, pierwsze count minus 1 podciągi są zwracane w pierwszych count minus 1 elementów wartości zwracanej, a pozostałe znaki w tym wystąpieniu są zwracane w ciągu ostatnich element wartości zwracanej.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.

Jeśli count jest większa niż liczba podciągów, zwracane są dostępne podciągi i nie jest zgłaszany żaden wyjątek.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

W poniższej tabeli przedstawiono przykłady.The following table provides examples.

Wartość ciąguString value SeparatorSeparator CountCount Tablica zwróconaReturned array
"42, 12, 19""42, 12, 19" New 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" nowy znak [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
Banan"Banana" nowy znak [] {'. '}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)
New 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)
New Char [] null (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)
New Char [] null (C#)new Char[] null (C#)

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

Zagadnienia dotyczące wydajnościPerformance Considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, rozważ użycie IndexOf Compare metody IndexOfAny lub i opcjonalnie metodę, aby zlokalizować podciąg w ciągu.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.

W przypadku dzielenia ciągu na znak separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. W przypadku dzielenia ciągu na ciąg separatora Użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.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. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Zobacz też

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()

Parametry

separator
Char Char Char Char

Zwraca

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()

Parametry

Zwraca

String[]

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

Dzieli ciąg na podciągi, które są oparte na znakach w tablicy.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()

Parametry

separator
Char[]

Tablica znaków, która ogranicza podciągi w tym ciągu, pustą tablicę, która nie zawiera ograniczników ani null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

Zwraca

String[]

Tablica, której elementy zawierają podciągi z tego wystąpienia, które są rozdzielane przez jeden lub więcej znaków w separator.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.For more information, see the Remarks section.

Przykłady

Poniższy przykład ilustruje sposób wyodrębniania pojedynczych wyrazów z bloku tekstu przez traktowanie białych znaków i interpunkcji jako ograniczników.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. Tablica znaków przeniesiona do separator parametru String.Split(Char[]) metody składa się z znaku spacji i znaku tabulacji wraz z niektórymi typowymi symbolami interpunkcji.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

Uwagi

Jeśli ciąg jest rozdzielany przez znany zestaw znaków, można użyć Split(Char[]) metody, aby oddzielić ją na podciągi.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Szczegóły wartości zwracanejReturn value details

Znaki ogranicznika nie są uwzględnione w elementach zwróconej tablicy.Delimiter characters are not included in the elements of the returned array. Na przykład, jeśli tablica separatora zawiera znak "-", a wartość bieżącego wystąpienia ciągu to "AA-BB-CC", metoda zwraca tablicę zawierającą trzy elementy: "AA", "bb" i "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".

Jeśli to wystąpienie nie zawiera żadnego ze znaków w separator, zwracana tablica składa się z pojedynczego elementu, który zawiera to wystąpienie.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Każdy element separator definiuje oddzielny znak ogranicznika.Each element of separator defines a separate delimiter character. Jeśli dwa ograniczniki są przyległe lub ogranicznik znajduje się na początku lub na końcu tego wystąpienia, odpowiadający element w zwracanej tablicy zawiera 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. Oto kilka przykładów:Here are some examples:

Wartość ciąguString value SeparatorSeparator Tablica zwróconaReturned array
"42, 12, 19""42, 12, 19" New 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" nowy znak [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Banan"Banana" nowy znak [] {'. '}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)
New 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#)

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

Tablica separatorówThe separator array

Każdy element separatora definiuje oddzielny ogranicznik, który składa się z pojedynczego znaku.Each element of separator defines a separate delimiter that consists of a single character. Jeśli argument ma null lub nie zawiera znaków, Metoda traktuje znaki odstępu jako ograniczniki. separatorIf the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Znaki odstępu są definiowane przez standard Unicode; zwracają true oneChar.IsWhiteSpace , jeśli są przesyłane do metody.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

Ciąg. Split (Char []) i rozwiązanie przeciążenia kompilatoraString.Split(Char[]) and compiler overload resolution

Chociaż pojedynczy parametr dla tego przeciążenia String.Split jest tablicą znaków, można wywołać ją z pojedynczym znakiem, jak pokazano w poniższym przykładzie.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.

Ponieważ parametr ma ParamArrayAttribute atrybut, kompilatory interpretują pojedynczy znak jako jednoelementowy tablicę znaków. separatorBecause the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. W przypadku innych String.Split przeciążeń, które separator zawierają parametr; należy jawnie przekazać te przeciążenia tablicę znakową jako separator argument.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.

Szczegóły porównaniaComparison details

Metoda wyodrębnia podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej znaków separator w tablicy, i zwraca te podciągi jako elementy tablicy. Split(Char[])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.

Split(Char[]) Metoda szuka ograniczników przez wykonywanie porównań przy użyciu reguł sortowania porządkowego z uwzględnieniem wielkości liter.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Więcej informacji na temat wyrazów, ciągów i sortowania porządkowego znajduje się System.Globalization.CompareOptions w wyliczeniu.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Zagadnienia dotyczące wydajnościPerformance Considerations

Metody przydzielają pamięć dla zwracanego obiektu array String i obiektu dla każdego elementu tablicy. SplitThe Split methods allocate memory for the returned array object and a String object for each array element. Jeśli aplikacja wymaga optymalnej wydajności lub jeśli Zarządzanie alokacją pamięci ma krytyczne znaczenie w aplikacji, należy rozważyć IndexOf użycie IndexOfAny metody lub.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Istnieje również możliwość użycia Compare metody do lokalizowania podciągu w ciągu.You also have the option of using the Compare method to locate a substring within a string.

Aby podzielić ciąg na znak separatora, użyj IndexOf metody lub IndexOfAny , aby zlokalizować znak separatora w ciągu.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Aby podzielić ciąg na ciąg separatora, użyj IndexOf metody lub IndexOfAny , aby zlokalizować pierwszy znak ciągu separatora.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Następnie użyj metody Compare , aby określić, czy znaki po pierwszym znaku są równe pozostałym znakom ciągu separatora.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Ponadto, jeśli ten sam zestaw znaków jest używany do dzielenia ciągów w wielu Split wywołaniach metod, należy rozważyć utworzenie pojedynczej tablicy i odwołanie się do niej w każdym wywołaniu metody.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. Pozwala to znacznie ograniczyć dodatkowe obciążenie każdego wywołania metody.This significantly reduces the additional overhead of each method call.

Uwagi dotyczące wywoływania

separator Trim(Char[]) null W wersjach Split(Char[]) i starszych, jeśli metoda jest przenoszona lub nie zawiera żadnych znaków, metoda używa nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Program .NET Framework 3,5.NET Framework 3.5 Przytnij ciąg.In the Program .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. Począwszy od .NET Framework 4, obie metody używają identycznego zestawu znaków znaku Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Zobacz też

Dotyczy