String.Split Metoda

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)

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)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie podanego separatora znaków.Splits a string into a maximum number substrings based on the provided character separator.

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)

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)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie podanego separatora ciągu.Splits a string into a maximum number of substrings based on the provided string separator.

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)

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)

Dzieli ciąg na podciągi na podstawie podanego separatora znaków.Splits a string into substrings based on the provided character separator.

Split(String, StringSplitOptions)

Dzieli ciąg na podciągi, które są oparte na podanym separatorze ciągu.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

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

Uwagi

Split jest używany 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 (Metoda Split(Char[])) lub użyć tablicy znaków, 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 Split pozwalają ograniczyć liczbę podciągów zwracanych przez metodę (metodę Split(Char[], Int32)), aby określić, czy puste ciągi są uwzględniane w zwracanych podciągach (Split(Char[], StringSplitOptions) i Split(String[], StringSplitOptions) metodami, czy też do obu (Split(Char[], Int32, StringSplitOptions) i Split(String[], Int32, StringSplitOptions) metod).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).

Alternatywy dla ciągu. SplitAlternatives to String.Split

Metoda Split nie zawsze najlepszym sposobem na podzielenie 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

(\d+)\s+([-+*/])\s+(\d+) wzorzec 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 wystąpieniu String.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 Metoda Split nie może być używana do dzielenia poniższego ciągu, ponieważ liczba znaków \n (in C#) lub vbCrLf (w Visual Basic) jest zmienna i nie zawsze są jako ograniczniki.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 Regex.Split jest niemal identyczna z String.Split, z tą różnicą, że dzieli ciąg na podstawie wzorca wyrażenia regularnego, a nie stałego zestawu znaków.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. Na przykład poniższy przykład używa metody Regex.Split, 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

\s-\s?[+*]?\s?-\s wzorzec 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ć metodę Substring, 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 metodę IndexOf, aby znaleźć okresy w ciągu.The following example uses the IndexOf method to find the periods in a string. Następnie używa metody Substring, aby zwracać pełne zdania.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)

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

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

options
StringSplitOptions

RemoveEmptyEntries, aby 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.

Atrybuty

Wyjątki

count jest ujemna.count is negative.

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

Przykłady

Poniższy przykład używa wyliczenia StringSplitOptions, aby uwzględnić lub wykluczyć podciągi wygenerowane przez metodę Split.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 żadnych znaków w separatorlub parametr count 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 separator jest null lub nie zawiera żadnych znaków, przyjmuje się, że znaki odstępu są ogranicznikami.If 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 zwracają true, jeśli są przesyłane do metody Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Jeśli jednak separator parametr w wywołaniu tego przeciążenia metody jest 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 count ma wartość zero lub parametr options jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, zwracana jest pusta tablica.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Każdy element separator definiuje oddzielny znak ogranicznika.Each element of separator defines a separate delimiter character. Jeśli parametr options jest None, a 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 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 się więcej niż count podciągów, 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 ostatnim elemencie 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.

Uwagi dotyczące wydajnościPerformance Considerations

Metody Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny i opcjonalnie metodę Compare, 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie podanego separatora znaków.Splits a string into a maximum number substrings based on the provided character separator.

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

Znak, który ogranicza podciągi w tym wystąpieniu.A character that delimits the substrings in this instance.

count
Int32

Maksymalna liczba oczekiwanych elementów w tablicy.The maximum number of elements expected in the array.

options
StringSplitOptions

Jedna z wartości wyliczenia, która określa, czy operacja split powinna pomijać puste podciągi z wartości zwracanej.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Zwraca

String[]

Tablica, której elementy zawierają maksymalnie count podciągów z tego wystąpienia, które są rozdzielane przez separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Uwagi

Jeśli ciąg został już podzielony count-1 razy, ale nie osiągnięto końca ciągu, ostatni ciąg w zwróconej tablicy będzie zawierał pozostałe końcowe podciągi tego wystąpienia, bez zmian.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

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 zawiera brak ograniczników lub null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

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

options
StringSplitOptions

RemoveEmptyEntries, aby 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.

Atrybuty

Wyjątki

count jest ujemna.count is negative.

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

Przykłady

Poniższy przykład używa wyliczenia StringSplitOptions, aby uwzględnić lub wykluczyć podciągi wygenerowane przez metodę Split.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 separatorlub parametr count 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 separator jest null lub nie zawiera żadnych znaków, przyjmuje się, że znaki odstępu są ogranicznikami.If 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 zwracają true, jeśli są przesyłane do metody Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Jeśli jednak separator parametr w wywołaniu tego przeciążenia metody jest 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 count ma wartość zero lub parametr options jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, zwracana jest pusta tablica.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

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 options jest None, a 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 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 się więcej niż count podciągów, 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 ostatnim elemencie 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 Split wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden ciąg w parametrze separator i zwraca te podciągi jako elementy tablicy.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Metoda Split 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 zawiera System.Globalization.CompareOptions Wyliczenie.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

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

Aby uniknąć niejednoznacznych wyników, gdy ciągi w separator zawierają znaki we wspólnym, Metoda Split przechodzi od początku do końca wartości wystąpienia i dopasowuje pierwszy element w separator, który jest równy ogranicznikowi w wystąpieniu.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ł "EF", a drugi element miał wartość "bcde", wynikiem operacji Split będzie "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 do elementu w separator 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 był "bcd", a drugi element miał wartość "BC", wynikiem operacji podziału będzie "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 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 Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny i opcjonalnie metodę Compare, 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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)

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 zawiera brak ograniczników lub null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

RemoveEmptyEntries, aby 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.

Atrybuty

Wyjątki

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

Przykłady

Poniższy przykład ilustruje różnicę w tablicach zwracanych przez wywołanie metody String.Split(String[], StringSplitOptions) ciągu z parametrem options 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 do metody Split(String[], StringSplitOptions) 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 argumentem options ustawionym na StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Zapobiega to dołączeniu przez zwracaną tablicę wartości String.Empty, 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 rozdzielony przez znany zestaw ciągów, można użyć metody Split, 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 tablica separator 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 options jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, metoda zwróci pustą tablicę.If 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 options jest None, a dwa ograniczniki są przyległe lub ogranicznik jest znaleziony na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Na przykład jeśli separator zawiera dwa elementy, "-" i "_", wartość wystąpienia ciągu to "-_AA-_" i wartość argumentu options jest None, metoda zwraca tablicę Sting z następującymi pięcioma elementami: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 separator jest null lub nie zawiera żadnych znaków, przyjmuje się, że znaki odstępu są ogranicznikami.If 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 zwracają true, jeśli są przesyłane do metody Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jeśli separator parametr w wywołaniu tego przeciążenia metody jest null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem.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[]), 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 Split wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden ciąg w parametrze separator i zwraca te podciągi jako elementy tablicy.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Metoda Split 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 zawiera System.Globalization.CompareOptions Wyliczenie.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

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

Aby uniknąć niejednoznacznych wyników, gdy ciągi w separator zawierają znaki we wspólnym, operacja Split przechodzi od początku do końca wartości wystąpienia i dopasowuje pierwszy element w separator, który jest równy ogranicznikowi w wystąpieniu.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 miał wartość "EF", a drugi element miał wartość "bcde", wynikiem operacji Split jest 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 do elementu w separator 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 miał wartość "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 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 Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny i opcjonalnie metodę Compare, 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie podanego separatora ciągu.Splits a string into a maximum number of substrings based on the provided string separator.

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

separator
String

Ciąg, który ogranicza podciągi w tym wystąpieniu.A string that delimits the substrings in this instance.

count
Int32

Maksymalna liczba oczekiwanych elementów w tablicy.The maximum number of elements expected in the array.

options
StringSplitOptions

Jedna z wartości wyliczenia, która określa, czy operacja split powinna pomijać puste podciągi z wartości zwracanej.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Zwraca

String[]

Tablica, której elementy zawierają maksymalnie count podciągów z tego wystąpienia, które są rozdzielane przez separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Uwagi

Jeśli ciąg został już podzielony count-1 razy, ale nie osiągnięto końca ciągu, ostatni ciąg w zwróconej tablicy będzie zawierał pozostałe końcowe podciągi tego wystąpienia, bez zmian.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

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

RemoveEmptyEntries, aby 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.

Atrybuty

Wyjątki

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

Przykłady

Poniższy przykład używa wyliczenia StringSplitOptions, aby uwzględnić lub wykluczyć podciągi wygenerowane przez metodę Split.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 tablicy separator) 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 tablica separator 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 żadnych 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 options jest RemoveEmptyEntries i długość tego wystąpienia wynosi zero, metoda zwróci pustą tablicę.If 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 options jest None, a dwa ograniczniki są przyległe lub ogranicznik jest znaleziony na początku lub na końcu tego wystąpienia, odpowiadający element tablicy zawiera String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Na przykład jeśli separator zawiera dwa elementy, "-" i "_", wartość wystąpienia ciągu to "-_AA-_" i wartość argumentu options jest None, metoda zwraca tablicę ciągów z następującymi pięcioma elementami: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 znakiem "" 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 separator jest null lub nie zawiera żadnych znaków, przyjmuje się, że znaki odstępu są ogranicznikami.If 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 zwracają true, jeśli są przesyłane do metody Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jeśli separator parametr w wywołaniu tego przeciążenia metody jest null, rozpoznawanie przeciążenia kompilatora kończy się niepowodzeniem.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(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 Split wyodrębnia podciągi w tym ciągu, które są rozdzielane przez co najmniej jeden znak w parametrze separator i zwraca te podciągi jako elementy tablicy.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

Metoda Split 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 zawiera System.Globalization.CompareOptions Wyliczenie.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Uwagi dotyczące wydajnościPerformance Considerations

Metody Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny i opcjonalnie metodę Compare, 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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)

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

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

count jest ujemna.count is negative.

Przykłady

Poniższy przykład ilustruje, jak count ma wpływ na liczbę 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 żadnych 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 wynosi zero, zwracana jest pusta tablica.If count is zero, an empty array is returned.

Jeśli parametr separator jest null lub nie zawiera żadnych znaków, przyjmuje się, że znaki odstępu są ogranicznikami.If 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 zwracają true, jeśli są przesyłane do metody Char.IsWhiteSpace.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 się więcej niż count podciągów, 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 ostatnim elemencie 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ągowaString 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"}

Uwagi dotyczące wydajnościPerformance Considerations

Metody Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny i opcjonalnie metodę Compare, 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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)

Dzieli ciąg na podciągi na podstawie podanego separatora znaków.Splits a string into substrings based on the provided character separator.

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

Znak, który ogranicza podciągi w tym ciągu.A character that delimits the substrings in this string.

options
StringSplitOptions

Jedna z wartości wyliczenia, która określa, czy operacja split powinna pomijać puste podciągi z wartości zwracanej.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Zwraca

String[]

Tablica, której elementy zawierają podciągi z tego wystąpienia, które są rozdzielane przez separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(String, StringSplitOptions)

Dzieli ciąg na podciągi, które są oparte na podanym separatorze ciągu.Splits a string into substrings that are based on the provided string separator.

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

separator
String

Ciąg, który ogranicza podciągi w tym ciągu.A string that delimits the substrings in this string.

options
StringSplitOptions

Jedna z wartości wyliczenia, która określa, czy operacja split powinna pomijać puste podciągi z wartości zwracanej.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Zwraca

String[]

Tablica, której elementy zawierają podciągi z tego wystąpienia, które są rozdzielane przez separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(Char[])

Dzieli ciąg na podciągi, które są oparte na znakach w tablicy separatorów.Splits a string into substrings that are based on the characters in the separator 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 metody String.Split(Char[]) składa się ze znaku spacji i znaku tabulacji wraz z niektórymi typowymi symbolami interpunkcyjnych.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ć metody Split(Char[]), 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 żadnych 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 zwróconej 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ągowaString 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 separator jest null lub nie zawiera żadnych znaków, Metoda traktuje znaki odstępu jako ograniczniki.If 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, jeśli są one przesyłane do metody Char.IsWhiteSpace.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 separator jest uzupełniony atrybutem ParamArrayAttribute, kompilatory interpretują pojedynczy znak jako jednoelementowy tablicę znaków.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. W przypadku innych przeciążeń String.Split, które zawierają parametr separator; należy jawnie przekazać te przeciążenia tablicę znaków jako argument separator.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 Split(Char[]) wyodrębnia podciągi w tym ciągu, które są rozdzielane przez jeden lub więcej znaków w tablicy separator i zwraca te podciągi jako elementy tablicy.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.

Metoda Split(Char[]) 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 zawiera System.Globalization.CompareOptions Wyliczenie.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Uwagi dotyczące wydajnościPerformance Considerations

Metody Split przydzielają pamięć dla zwróconego obiektu array i obiektu String dla każdego elementu tablicy.The 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 metody IndexOf lub IndexOfAny.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 metody Compare 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 metody IndexOf 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 metody IndexOf 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 wywołaniach metod Split, 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

W Program .NET Framework 3,5.NET Framework 3.5 i starszych wersjach, jeśli Split(Char[]) Metoda jest przenoszona separator null lub nie zawiera żadnych znaków, metoda użyje nieco innego zestawu znaków, aby podzielić ciąg niż Metoda Trim(Char[]), aby przyciąć 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