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

Définition

Retourne un tableau de chaînes qui contient les sous-chaînes de cette instance, séparées par les éléments d'une chaîne ou d'un tableau de caractères Unicode spécifiés.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

Surcharges

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into a maximum number of substrings based on the characters in an array.

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into a maximum number of substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

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

Fractionne une chaîne en sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

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

Fractionne une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings based on the characters in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into a maximum number of substrings based on the characters in an array. Vous pouvez aussi spécifier le nombre maximal de sous-chaînes à retourner.You also specify the maximum number of substrings to return.

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

Divise une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings that are based on the characters in an array.

Remarques

Splitest utilisé pour diviser une chaîne délimitée en sous-chaînes.Split is used to break a delimited string into substrings. Vous pouvez utiliser un tableau de caractères pour spécifier zéro, un ou plusieurs caractères de délimitation (la Split(Char[]) méthode), ou vous pouvez utiliser un tableau de caractères pour spécifier zéro, une ou plusieurs chaînes de délimitation.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. Les surcharges de Split la méthode vous permettent de limiter le nombre de sous-chaînes retournées par la Split(Char[], Int32) méthode (méthode), pour déterminer si les chaînes vides sont incluses dans les sous-chaînes Split(Char[], StringSplitOptions) retournées (méthodes et Split(String[], StringSplitOptions) , ou pour effectuer les deux ( Split(Char[], Int32, StringSplitOptions) méthodes Split(String[], Int32, StringSplitOptions) et).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).

Notes

Les exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternatives à String. SplitAlternatives to String.Split

La Split méthode n’est pas toujours la meilleure façon de diviser une chaîne délimitée en sous-chaînes.The Split method is not always the best way to break a delimited string into substrings. Si vous ne souhaitez pas extraire toutes les sous-chaînes d’une chaîne délimitée, ou si vous souhaitez analyser une chaîne basée sur un modèle au lieu d’un ensemble de caractères de délimitation, envisagez les alternatives suivantes.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.

Expressions régulièresRegular expressions

Si vos chaînes sont conformes à un modèle fixe, vous pouvez utiliser une expression régulière pour extraire et gérer leurs éléments.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Par exemple, si les chaînes prennent la forme «Number Operand Number», vous pouvez utiliser une expression régulière pour extraire et gérer les éléments de la chaîne.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Voici un exemple :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

Le modèle (\d+)\s+([-+*/])\s+(\d+) d’expression régulière est défini comme suit :The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

MotifPattern DescriptionDescription
(\d+) Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits. Il s'agit du premier groupe de capture.This is the first capturing group.
\s+ Correspond à un ou plusieurs espaces blancs.Match one or more white-space characters.
([-+*/]) Correspond à un signe d’opérateur arithmétique (+,-, * ou/).Match an arithmetic operator sign (+, -, *, or /). Il s'agit du deuxième groupe de capture.This is the second capturing group.
\s+ Correspond à un ou plusieurs espaces blancs.Match one or more white-space characters.
(\d+) Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits. Il s'agit du troisième groupe de capture.This is the third capturing group.

Vous pouvez également utiliser une expression régulière pour extraire des sous-chaînes d’une chaîne basée sur un modèle plutôt qu’un ensemble fixe de caractères.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Il s’agit d’un scénario courant lorsque l’une des conditions suivantes se produit :This is a common scenario when either of these conditions occurs:

  • Un ou plusieurs des caractères de délimiteur ne servent pas toujours de délimiteur dans l' String instance.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • La séquence et le nombre de caractères de délimitation est variable ou inconnu.The sequence and number of delimiter characters is variable or unknown.

Par exemple, la Split méthode ne peut pas être utilisée pour fractionner la chaîne suivante, car \n le nombre C#de caractères vbCrLf (dans) ou (en Visual Basic) est variable, et ils ne servent pas toujours de délimiteurs.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.]  

Une expression régulière peut fractionner cette chaîne facilement, comme le montre l’exemple suivant.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.

Le modèle \[([^\[\]]+)\] d’expression régulière est défini comme suit :The regular expression pattern \[([^\[\]]+)\] is defined like this:

MotifPattern DescriptionDescription
\[ Mettre en correspondance un crochet ouvrant.Match an opening bracket.
([^\[\]]+) Correspond à n’importe quel caractère qui n’est pas une ouverture ou un crochet fermant une ou plusieurs fois.Match any character that is not an opening or a closing bracket one or more times. Il s'agit du premier groupe de capture.This is the first capturing group.
\] Mettre en correspondance un crochet fermant.Match a closing bracket.

La Regex.Split méthode est presque identique à String.Split, à ceci près qu’elle fractionne une chaîne basée sur un modèle d’expression régulière au lieu d’un jeu de caractères fixe.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. Par exemple, l’exemple suivant utilise la Regex.Split méthode pour fractionner une chaîne qui contient des sous-chaînes délimitées par différentes combinaisons de tirets et d’autres caractères.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

Le modèle \s-\s?[+*]?\s?-\s d’expression régulière est défini comme suit :The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

MotifPattern DescriptionDescription
\s- Correspond à un espace blanc suivi d’un trait d’Union.Match a white-space character followed by a hyphen.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
[+*]? Correspond à zéro ou à une occurrence du caractère + ou *.Match zero or one occurrence of either the + or * character.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
-\s Faire correspondre un trait d’Union suivi d’un espace blanc.Match a hyphen followed by a white-space character.

Méthodes de recherche et méthode SubstringSearch methods and the Substring method

Si vous n’êtes pas intéressé par toutes les sous-chaînes d’une chaîne, vous préférerez peut-être utiliser l’une des méthodes de comparaison de chaînes qui retourne l’index auquel la correspondance commence.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. Vous pouvez ensuite appeler la Substring méthode pour extraire la sous-chaîne de votre choix.You can then call the Substring method to extract the substring that you want. Les méthodes de comparaison de chaînes sont les suivantes :The string comparison methods include:

  • IndexOf, qui retourne l’index de base zéro de la première occurrence d’un caractère ou d’une chaîne dans une instance de chaîne.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, qui retourne l’index de base zéro dans l’instance de chaîne actuelle de la première occurrence d’un caractère dans un tableau de caractères.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, qui retourne l’index de base zéro de la dernière occurrence d’un caractère ou d’une chaîne dans une instance de chaîne.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, qui retourne un index de base zéro dans l’instance de chaîne actuelle de la dernière occurrence d’un caractère dans un tableau de caractères.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

L’exemple suivant utilise la IndexOf méthode pour rechercher les points dans une chaîne.The following example uses the IndexOf method to find the periods in a string. Il utilise ensuite la Substring méthode pour retourner des phrases complètes.It then uses the Substring method to return full sentences.

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

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

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

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

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.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()

Paramètres

separator
Char[]

Tableau de caractères qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteurs ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Nombre maximal de sous-chaînes à retourner.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries pour ignorer les éléments vides du tableau retourné ou None pour les inclure.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères dans separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exceptions

options ne fait pas partie des valeurs StringSplitOptions.options is not one of the StringSplitOptions values.

Exemples

L’exemple suivant utilise l' StringSplitOptions énumération pour inclure ou exclure des sous-chaînes générées par la Split méthode.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]>
'

Remarques

Les caractères délimiteurs ne sont pas inclus dans les éléments du tableau retourné.Delimiter characters are not included in the elements of the returned array.

Si cette instance ne contient pas l’un des caractères dans separator, ou si count le paramètre est 1, le tableau retourné se compose d’un seul élément qui contient cette instance.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. Si le separator paramètre est null ou ne contient aucun caractère, les espaces blancs sont considérés comme des délimiteurs.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Les espaces blancs sont définis par la norme Unicode et retournent true s’ils sont passés à la Char.IsWhiteSpace méthode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Toutefois, si le separator paramètre dans l’appel à cette surcharge de méthode nullest, la résolution de surcharge du compilateur échoue.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Pour identifier de façon non ambiguë la méthode appelée, votre code doit indiquer le type de la valeur null.To unambiguously identify the called method, your code must indicate the type of the null. L’exemple suivant montre plusieurs façons d’identifier sans ambiguïté cette surcharge.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)

Si le count paramètre est égal à zéro ou options si le RemoveEmptyEntries paramètre a la valeur et que la longueur de cette instance est égale à zéro, un tableau vide est retourné.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.

Chaque élément de separator définit un caractère délimiteur distinct.Each element of separator defines a separate delimiter character. Si le options paramètre est Noneet que deux séparateurs sont adjacents ou qu’un délimiteur est trouvé au début ou à la fin de cette instance, l' Emptyélément de tableau correspondant contient.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.

S’il y a plus count de sous-chaînes dans cette instance, les count premières sous-chaînes moins 1 sont retournées count dans les premiers éléments moins 1 de la valeur de retour, et les caractères restants dans cette instance sont retournés dans le dernier élément de la valeur de retour.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.

Si count est supérieur au nombre de sous-chaînes, les sous-chaînes disponibles sont retournées et aucune exception n’est levée.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Considérations sur les performancesPerformance Considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d' Compare utiliser la méthode ou, et éventuellement la méthode, pour rechercher une sous-chaîne dans une chaîne.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.

Si vous fractionnez une chaîne au niveau d’un caractère de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher un caractère de séparation dans la chaîne.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Si vous fractionnez une chaîne au niveau d’une chaîne de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher le premier caractère de la chaîne de séparation.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. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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

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

Paramètres

separator
Char Char Char Char

Retours

String[]

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into a maximum number of substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.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()

Paramètres

separator
String[]

Tableau de chaînes qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteur ou null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Nombre maximal de sous-chaînes à retourner.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries pour ignorer les éléments vides du tableau retourné ou None pour les inclure.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs chaînes dans separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exceptions

options ne fait pas partie des valeurs StringSplitOptions.options is not one of the StringSplitOptions values.

Exemples

L’exemple suivant utilise l' StringSplitOptions énumération pour inclure ou exclure des sous-chaînes générées par la Split méthode.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]>
'

Remarques

Détails de la valeur de retourReturn value details

Les chaînes de délimiteurs ne sont pas incluses dans les éléments du tableau retourné.Delimiter strings are not included in the elements of the returned array.

Si cette instance ne contient aucune des chaînes dans separator, ou si le count paramètre est 1, le tableau retourné se compose d’un seul élément qui contient cette instance.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. Si le separator paramètre est null ou ne contient aucun caractère, les espaces blancs sont considérés comme des délimiteurs.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Les espaces blancs sont définis par la norme Unicode et retournent true s’ils sont passés à la Char.IsWhiteSpace méthode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Toutefois, si le separator paramètre dans l’appel à cette surcharge de méthode nullest, la résolution de surcharge du compilateur échoue.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Pour identifier de façon non ambiguë la méthode appelée, votre code doit indiquer le type de null.To unambiguously identify the called method, your code must indicate the type of the null. L’exemple suivant montre plusieurs façons d’identifier sans ambiguïté cette surcharge.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)

Si le count paramètre est égal à zéro ou options si le RemoveEmptyEntries paramètre a la valeur et que la longueur de cette instance est égale à zéro, un tableau vide est retourné.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.

Chaque élément de separator définit un délimiteur distinct qui se compose d’un ou de plusieurs caractères.Each element of separator defines a separate delimiter that consists of one or more characters. Si le options paramètre est Noneet que deux séparateurs sont adjacents ou qu’un délimiteur est trouvé au début ou à la fin de cette instance, l' Emptyélément de tableau correspondant contient.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.

S’il y a plus count de sous-chaînes dans cette instance, les count premières sous-chaînes moins 1 sont retournées count dans les premiers éléments moins 1 de la valeur de retour, et les caractères restants dans cette instance sont retournés dans le dernier élément de la valeur de retour.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.

Si count est supérieur au nombre de sous-chaînes, les sous-chaînes disponibles sont retournées et aucune exception n’est levée.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Tableau de séparateursThe separator array

Si l’un des éléments de separator se compose de plusieurs caractères, la sous-chaîne entière est considérée comme un délimiteur.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Par exemple, si l’un des éléments dans separator est « 10 », tentative de fractionnement de la chaîne « This10is10a10string ».For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." retourne ce tableau à quatre éléments : {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Détails de la comparaisonComparison details

La Split méthode extrait les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs des chaînes separator du paramètre, puis retourne ces sous-chaînes en tant qu’éléments d’un tableau.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.

La Split méthode recherche les délimiteurs en effectuant des comparaisons à l’aide de règles de tri ordinal respectant la casse.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Pour plus d’informations sur les tris de mot, de chaîne et ordinal System.Globalization.CompareOptions , consultez l’énumération.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

La Split méthode ignore tout separator élément dont la valeur est null ou la chaîne vide ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Pour éviter des résultats ambigus lorsque separator les chaînes de ont des caractères Split en commun, la méthode se poursuit du début à la fin de la valeur de l’instance, et correspond separator au premier élément de qui est égal à un délimiteur dans instancié.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. L’ordre dans lequel les sous-chaînes sont rencontrées dans l’instance est prioritaire par rapport à l' separatorordre des éléments dans.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Par exemple, considérez une instance dont la valeur est « abcdef ».For example, consider an instance whose value is "abcdef". Si le premier élément de separator était « EF » et que le deuxième élément était « BCDE », le résultat de l’opération de fractionnement serait « a » et « 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". Cela est dû au fait que la sous-chaîne de l’instance, « BCDE », est rencontrée separator et correspond à un élément dans avant que la sous-chaîne « f » soit rencontrée.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Toutefois, si le premier élément de separator était « BCD » et que le deuxième élément était « BC », le résultat de l’opération de fractionnement serait « a » et « 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". Cela est dû au fait que « BCD » est le separator premier délimiteur de qui correspond à un délimiteur de l’instance.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Si l’ordre des séparateurs a été inversé, de sorte que le premier élément était « BC » et que le deuxième élément était « BCD », le résultat serait « a » et « 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".

Considérations sur les performancesPerformance considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d' Compare utiliser la méthode ou, et éventuellement la méthode, pour rechercher une sous-chaîne dans une chaîne.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.

Si vous fractionnez une chaîne au niveau d’un caractère de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher un caractère de séparation dans la chaîne.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Si vous fractionnez une chaîne au niveau d’une chaîne de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher le premier caractère de la chaîne de séparation.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. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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

Fractionne une chaîne en sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.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()

Paramètres

separator
String[]

Tableau de chaînes qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteur ou null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries pour ignorer les éléments vides du tableau retourné ou None pour les inclure.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs chaînes dans separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exceptions

options ne fait pas partie des valeurs StringSplitOptions.options is not one of the StringSplitOptions values.

Exemples

L’exemple suivant illustre la différence dans les tableaux retournés en appelant la méthode d' String.Split(String[], StringSplitOptions) une chaîne avec options son paramètre égal StringSplitOptions.None à StringSplitOptions.RemoveEmptyEntrieset.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'

L’exemple suivant définit un tableau de séparateurs qui incluent des caractères de ponctuation et des espaces blancs.The following example defines an array of separators that include punctuation and white-space characters. La transmission de ce tableau avec une valeur StringSplitOptions.RemoveEmptyEntries à la Split(String[], StringSplitOptions) méthode retourne un tableau qui se compose des mots individuels de la chaîne.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

Notez que la méthode est appelée avec l' options argument défini sur StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Cela empêche le tableau retourné d’inclure String.Empty des valeurs qui représentent des correspondances de sous-chaînes vides entre les signes de ponctuation et les espaces blancs.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Remarques

Lorsqu’une chaîne est délimitée par un ensemble de chaînes connu, vous pouvez utiliser la Split méthode pour la séparer en sous-chaînes.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Détails de la valeur de retourReturn value details

Les chaînes de délimiteurs ne sont pas incluses dans les éléments du tableau retourné.Delimiter strings are not included in the elements of the returned array. Par exemple, si le separator tableau inclut la chaîne « -- » et que la valeur de l’instance de chaîne actuelle est « AA--BB-CC », la méthode retourne un tableau qui contient trois éléments : « AA », « BB » et « 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".

Si cette instance ne contient aucune des chaînes dans separator, le tableau retourné se compose d’un seul élément qui contient cette instance.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Si le options paramètre est RemoveEmptyEntries et que la longueur de cette instance est égale à zéro, la méthode retourne un tableau vide.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Chaque élément de separator définit un délimiteur distinct qui se compose d’un ou de plusieurs caractères.Each element of separator defines a separate delimiter that consists of one or more characters. Si l' options argument est Noneet que deux séparateurs sont adjacents ou qu’un délimiteur est trouvé au début ou à la fin de cette instance, l' String.Emptyélément de tableau correspondant contient.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. Par exemple, si separator comprend deux éléments, « - » et «_», la valeur de l’instance de chaîne est «_-AA_- » et que la valeur de options l’argument Noneest, la méthode retourne un tableau de chaînes avec les cinq éléments suivants :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, qui représente la chaîne vide qui précède la sous-chaîne « - » à l’index 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, qui représente la chaîne vide entre la sous-chaîne « - » à l’index 0 et la sous-chaîne « _ » à l’index 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, qui représente la chaîne vide qui suit la sous-chaîne « _ » à l’index 4.String.Empty, which represents the empty string that follows the "_" substring at index 4.

  5. String.Empty, qui représente la chaîne vide qui suit la sous-chaîne « - » à l’index 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Tableau de séparateursThe separator array

Si l’un des éléments de separator se compose de plusieurs caractères, la sous-chaîne entière est considérée comme un délimiteur.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Par exemple, si l’un des éléments dans separator est « 10 », tentative de fractionnement de la chaîne « This10is10a10string ».For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." retourne le tableau de quatre éléments suivant : {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Si le separator paramètre est null ou ne contient aucun caractère, les espaces blancs sont considérés comme des délimiteurs.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Les espaces blancs sont définis par la norme Unicode et retournent true s’ils sont passés à la Char.IsWhiteSpace méthode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Si le separator paramètre dans l’appel à cette surcharge de méthode nullest, la résolution de surcharge du compilateur échoue.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Pour identifier de façon non ambiguë la méthode appelée, votre code doit indiquer le type de null.To unambiguously identify the called method, your code must indicate the type of the null. L’exemple suivant montre plusieurs façons d’identifier sans ambiguïté cette surcharge.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)

Détails de la comparaisonComparison details

La Split méthode extrait les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs des chaînes separator du paramètre, puis retourne ces sous-chaînes en tant qu’éléments d’un tableau.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.

La Split méthode recherche les délimiteurs en effectuant des comparaisons à l’aide de règles de tri ordinal respectant la casse.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Pour plus d’informations sur les tris de mot, de chaîne et ordinal System.Globalization.CompareOptions , consultez l’énumération.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

La Split méthode ignore tout separator élément dont la valeur est null ou la chaîne vide ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Pour éviter des résultats ambigus lorsque separator les chaînes de ont des caractères Split en commun, l’opération se poursuit du début à la fin de la valeur de l’instance, et correspond separator au premier élément de qui est égal à un délimiteur dans le instancié.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. L’ordre dans lequel les sous-chaînes sont rencontrées dans l’instance est prioritaire par rapport à l' separatorordre des éléments dans.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Par exemple, considérez une instance dont la valeur est « abcdef ».For example, consider an instance whose value is "abcdef". Si le premier élément de separator était « EF » et que le deuxième élément était « BCDE », le résultat de l’opération de fractionnement serait un tableau de chaînes qui contient deux éléments, « a » et « 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". Cela est dû au fait que la sous-chaîne de l’instance, « BCDE », est rencontrée separator et correspond à un élément dans avant que la sous-chaîne « f » soit rencontrée.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Toutefois, si le premier élément de separator était « BCD » et que le deuxième élément était « BC », le résultat de l’opération de fractionnement serait un tableau de chaînes qui contient deux éléments, « a » et « 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". Cela est dû au fait que « BCD » est le separator premier délimiteur de qui correspond à un délimiteur de l’instance.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Si l’ordre des séparateurs a été inversé, de sorte que le premier élément était « BC » et que le deuxième élément était « BCD », le résultat serait un tableau de chaînes qui contient deux éléments, « a » et « 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".

Considérations sur les performancesPerformance considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d' Compare utiliser la méthode ou, et éventuellement la méthode, pour rechercher une sous-chaîne dans une chaîne.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.

Si vous fractionnez une chaîne au niveau d’un caractère de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher un caractère de séparation dans la chaîne.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Si vous fractionnez une chaîne au niveau d’une chaîne de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher le premier caractère de la chaîne de séparation.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. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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

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

Paramètres

Retours

String[]

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

Fractionne une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings based on the characters in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.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()

Paramètres

separator
Char[]

Tableau de caractères qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteurs ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries pour ignorer les éléments vides du tableau retourné ou None pour les inclure.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères dans separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exceptions

options ne fait pas partie des valeurs StringSplitOptions.options is not one of the StringSplitOptions values.

Exemples

L’exemple suivant utilise l' StringSplitOptions énumération pour inclure ou exclure des sous-chaînes générées par la Split méthode.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]>
'

Remarques

Détails de la valeur de retourReturn value details

Les caractères de délimitation (les separator caractères dans le tableau) ne sont pas inclus dans les éléments du tableau retourné.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Par exemple, si le separator tableau inclut le caractère « - » et que la valeur de l’instance de chaîne actuelle est « AA-BB-CC », la méthode retourne un tableau qui contient trois éléments : « AA », « BB » et « 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".

Si cette instance ne contient pas l’un des caractères dans separator, le tableau retourné se compose d’un seul élément qui contient cette instance.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Si le options paramètre est RemoveEmptyEntries et que la longueur de cette instance est égale à zéro, la méthode retourne un tableau vide.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Chaque élément de separator définit un délimiteur distinct qui se compose d’un seul caractère.Each element of separator defines a separate delimiter that consists of a single character. Si l' options argument est Noneet que deux séparateurs sont adjacents ou qu’un délimiteur est trouvé au début ou à la fin de cette instance, l' String.Emptyélément de tableau correspondant contient.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. Par exemple, si separator comprend deux éléments, « - » et «_», la valeur de l’instance de chaîne est «_-AA_- » et que la valeur de options l’argument Noneest, la méthode retourne un tableau de chaînes avec les cinq éléments suivants :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, qui représente la chaîne vide qui précède le caractère « - » à l’index 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, qui représente la chaîne vide entre le caractère « - » à l’index 0 et le caractère « _ » à l’index 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, qui représente la chaîne vide qui suit le caractère « _ » à l’index 4.String.Empty, which represents the empty string that follows the "_" character at index 4.

  5. String.Empty, qui représente la chaîne vide qui suit le caractère « - » à l’index 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

Tableau de séparateursThe separator array

Si le separator paramètre est null ou ne contient aucun caractère, les espaces blancs sont considérés comme des délimiteurs.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Les espaces blancs sont définis par la norme Unicode et retournent true s’ils sont passés à la Char.IsWhiteSpace méthode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Si le separator paramètre dans l’appel à cette surcharge de méthode nullest, la résolution de surcharge du compilateur échoue.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Pour identifier de façon non ambiguë la méthode appelée, votre code doit indiquer le type de null.To unambiguously identify the called method, your code must indicate the type of the null. L’exemple suivant montre plusieurs façons d’identifier sans ambiguïté cette surcharge.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)

Détails de la comparaisonComparison details

La Split méthode extrait les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères separator du paramètre, puis retourne ces sous-chaînes en tant qu’éléments d’un tableau.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.

La Split méthode recherche les délimiteurs en effectuant des comparaisons à l’aide de règles de tri ordinal respectant la casse.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Pour plus d’informations sur les tris de mot, de chaîne et ordinal System.Globalization.CompareOptions , consultez l’énumération.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considérations sur les performancesPerformance Considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d' Compare utiliser la méthode ou, et éventuellement la méthode, pour rechercher une sous-chaîne dans une chaîne.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.

Si vous fractionnez une chaîne au niveau d’un caractère de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher un caractère de séparation dans la chaîne.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Si vous fractionnez une chaîne au niveau d’une chaîne de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher le premier caractère de la chaîne de séparation.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. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into a maximum number of substrings based on the characters in an array. Vous pouvez aussi spécifier le nombre maximal de sous-chaînes à retourner.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()

Paramètres

separator
Char[]

Tableau de caractères qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteurs ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Nombre maximal de sous-chaînes à retourner.The maximum number of substrings to return.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette instance qui sont délimitées par un ou plusieurs caractères dans separator.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exceptions

Exemples

L’exemple suivant montre comment count affecte le nombre de chaînes retournées par. SplitThe following example demonstrates how count affects the number of strings returned by Split.

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

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

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

Remarques

Les caractères délimiteurs ne sont pas inclus dans les éléments du tableau retourné.Delimiter characters are not included in the elements of the returned array.

Si cette instance ne contient pas l’un des caractères dans separator, le tableau retourné se compose d’un seul élément qui contient cette instance.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Si count est égal à zéro, un tableau vide est retourné.If count is zero, an empty array is returned.

Si le separator paramètre est null ou ne contient aucun caractère, les espaces blancs sont considérés comme des délimiteurs.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Les espaces blancs sont définis par la norme Unicode et retournent true s’ils sont passés à la Char.IsWhiteSpace méthode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Chaque élément de separator définit un caractère délimiteur distinct.Each element of separator defines a separate delimiter character. Si deux séparateurs sont adjacents, ou si un délimiteur est trouvé au début ou à la fin de cette instance, l' Emptyélément de tableau correspondant contient.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

S’il y a plus count de sous-chaînes dans cette instance, les count premières sous-chaînes moins 1 sont retournées count dans les premiers éléments moins 1 de la valeur de retour, et les caractères restants dans cette instance sont retournés dans le dernier élément de la valeur de retour.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.

Si count est supérieur au nombre de sous-chaînes, les sous-chaînes disponibles sont retournées et aucune exception n’est levée.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Le tableau suivant fournit des exemples.The following table provides examples.

Valeur de chaîneString value SéparateurSeparator NombreCount Tableau retournéReturned 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" nouveau char [] {'. '}new Char[] {'.'} (C#)(C#)

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

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

« Darb » & vbLf & « Smarba » (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
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"}

Considérations sur les performancesPerformance Considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d' Compare utiliser la méthode ou, et éventuellement la méthode, pour rechercher une sous-chaîne dans une chaîne.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.

Si vous fractionnez une chaîne au niveau d’un caractère de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher un caractère de séparation dans la chaîne.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Si vous fractionnez une chaîne au niveau d’une chaîne de séparation, IndexOf utilisez IndexOfAny la méthode ou pour rechercher le premier caractère de la chaîne de séparation.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. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Voir aussi

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

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

Paramètres

separator
Char Char Char Char

Retours

String[]

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

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

Paramètres

Retours

String[]

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

Divise une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings that are based on the characters in an array.

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

Paramètres

separator
Char[]

Tableau de caractères qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteurs ou null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette instance qui sont délimitées par un ou plusieurs caractères dans separator.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Pour plus d'informations, consultez la section Remarques.For more information, see the Remarks section.

Exemples

L’exemple suivant montre comment extraire des mots individuels d’un bloc de texte en traitant les espaces blancs et les signes de ponctuation comme délimiteurs.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. Le tableau de caractères passé au separator paramètre de la String.Split(Char[]) méthode se compose d’un espace et d’un caractère de tabulation, ainsi que de certains symboles de ponctuation courants.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

Remarques

Lorsqu’une chaîne est délimitée par un jeu de caractères connu, vous pouvez utiliser la Split(Char[]) méthode pour la séparer en sous-chaînes.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Détails de la valeur de retourReturn value details

Les caractères délimiteurs ne sont pas inclus dans les éléments du tableau retourné.Delimiter characters are not included in the elements of the returned array. Par exemple, si le tableau de séparateurs inclut le caractère « - » et que la valeur de l’instance de chaîne actuelle est « AA-BB-CC », la méthode retourne un tableau qui contient trois éléments : « AA », « BB » et « 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".

Si cette instance ne contient pas l’un des caractères dans separator, le tableau retourné se compose d’un seul élément qui contient cette instance.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Chaque élément de separator définit un caractère délimiteur distinct.Each element of separator defines a separate delimiter character. Si deux séparateurs sont adjacents, ou si un délimiteur est trouvé au début ou à la fin de cette instance, l’élément correspondant dans Emptyle tableau retourné contient.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. Voici quelques exemples :Here are some examples:

Valeur de chaîneString value SéparateurSeparator Tableau retournéReturned 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" nouveau char [] {'. '}new Char[] {'.'} (C#)(C#)

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

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

« Darb » & vbLf & « Smarba » (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
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"}

Tableau de séparateursThe separator array

Chaque élément de Separator définit un délimiteur distinct qui se compose d’un seul caractère.Each element of separator defines a separate delimiter that consists of a single character. Si l' separator argument est null ou ne contient aucun caractère, la méthode traite les espaces blancs comme des délimiteurs.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Les espaces blancs sont définis par la norme Unicode ; ils retournent true s’ils sont passés Char.IsWhiteSpace à la méthode.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String. Split (Char []) et résolution de surcharge du compilateurString.Split(Char[]) and compiler overload resolution

Bien que le paramètre unique pour cette surcharge String.Split de soit un tableau de caractères, vous pouvez l’appeler avec un caractère unique, comme le montre l’exemple suivant.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.

Étant donné separator que le paramètre est décoré ParamArrayAttribute avec l’attribut, les compilateurs interprètent un caractère unique comme un tableau de caractères à un seul élément.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Ce n’est pas le cas pour String.Split les autres surcharges qui separator incluent un paramètre ; vous devez passer explicitement ces surcharges separator un tableau de caractères comme argument.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Détails de la comparaisonComparison details

La Split(Char[]) méthode extrait les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères separator du tableau, puis retourne ces sous-chaînes en tant qu’éléments d’un tableau.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.

La Split(Char[]) méthode recherche les délimiteurs en effectuant des comparaisons à l’aide de règles de tri ordinal respectant la casse.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Pour plus d’informations sur les tris de mot, de chaîne et ordinal System.Globalization.CompareOptions , consultez l’énumération.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considérations sur les performancesPerformance Considerations

Les Split méthodes allouent de la mémoire pour l’objet de String tableau retourné et un objet pour chaque élément de tableau.The Split methods allocate memory for the returned array object and a String object for each array element. Si votre application requiert des performances optimales ou si la gestion de l’allocation de mémoire est essentielle dans IndexOf votre IndexOfAny application, envisagez d’utiliser la méthode ou.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Vous avez également la possibilité d’utiliser la Compare méthode pour rechercher une sous-chaîne dans une chaîne.You also have the option of using the Compare method to locate a substring within a string.

Pour fractionner une chaîne au niveau d’un caractère de IndexOf séparation IndexOfAny , utilisez la méthode ou pour rechercher un caractère de séparation dans la chaîne.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Pour fractionner une chaîne au niveau d’une chaîne de IndexOf séparation IndexOfAny , utilisez la méthode ou pour rechercher le premier caractère de la chaîne de séparation.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Utilisez ensuite la Compare méthode pour déterminer si les caractères qui suivent ce premier caractère sont identiques aux caractères restants de la chaîne de séparation.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes Split dans plusieurs appels de méthode, envisagez de créer un tableau unique et de le référencer dans chaque appel de méthode.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. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.This significantly reduces the additional overhead of each method call.

Notes pour les appelants

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, si la Split(Char[]) méthode reçoit un separator qui a null la valeur ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la Trim(Char[]) chaîne par rapport à la méthode. Découpez la chaîne.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. À partir du .NET Framework 4, les deux méthodes utilisent un ensemble identique d’espaces blancs Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Voir aussi

S’applique à