String.Split Méthode

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)

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)

Divise une chaîne en un nombre maximal de sous-chaînes d’après le séparateur de caractères fourni.Splits a string into a maximum number substrings based on the provided character separator.

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)

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)

Divise une chaîne en un nombre maximal de sous-chaînes d’après le séparateur de chaînes fourni.Splits a string into a maximum number of substrings based on the provided string separator.

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)

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)

Divise une chaîne en sous-chaînes d’après le séparateur de caractères fourni.Splits a string into substrings based on the provided character separator.

Split(String, StringSplitOptions)

Divise une chaîne en sous-chaînes d’après le séparateur de chaînes fourni.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

Divise une chaîne en sous-chaînes d’après les caractères du tableau de séparateurs.Splits a string into substrings that are based on the characters in the separator array.

Remarques

Split est utilisé pour décomposer 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 (méthode Split(Char[])), 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 la méthode Split vous permettent de limiter le nombre de sous-chaînes retournées par la méthode (méthode Split(Char[], Int32)), pour déterminer si les chaînes vides sont incluses dans les sous-chaînes retournées (méthodes Split(Char[], StringSplitOptions) et Split(String[], StringSplitOptions), ou pour effectuer les deux méthodes (Split(Char[], Int32, StringSplitOptions) et Split(String[], Int32, StringSplitOptions)).Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Alternatives à String. SplitAlternatives to String.Split

La méthode Split 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’expression régulière (\d+)\s+([-+*/])\s+(\d+) 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’instance String.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 méthode Split ne peut pas être utilisée pour fractionner la chaîne suivante, car le nombre de C#\n (in) ou vbCrLf (en Visual Basic) caractères est variable et ne sert 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 méthode Regex.Split 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 méthode Regex.Split 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 d’expression régulière \s-\s?[+*]?\s?-\s 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 méthode Substring 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 méthode IndexOf 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 méthode Substring 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)

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);
public string[] Split (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

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

options
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.

Attributs

Exceptions

count est un nombre négatif.count is negative.

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

Exemples

L’exemple suivant utilise l’énumération StringSplitOptions pour inclure ou exclure des sous-chaînes générées par la méthode Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

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 aucun des caractères de separator, ou si le paramètre count 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 paramètre separator 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 méthode Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Toutefois, si le paramètre separator dans l’appel à cette surcharge de méthode est null, la résolution de surcharge de 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 paramètre count est égal à zéro, ou si le paramètre options est RemoveEmptyEntries 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 paramètre options est None, et 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 de tableau correspondant contient Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

S’il y a plus de count sous-chaînes dans cette instance, la première count moins 1 sous-chaînes est retournée dans le premier count moins 1 élément de la valeur de retour, et les autres caractères de 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 méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, 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, utilisez la méthode IndexOf ou IndexOfAny 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, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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)

Divise une chaîne en un nombre maximal de sous-chaînes d’après le séparateur de caractères fourni.Splits a string into a maximum number substrings based on the provided character separator.

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

Paramètres

separator
Char

Caractère qui délimite les sous-chaînes de cette instance.A character that delimits the substrings in this instance.

count
Int32

Nombre maximal d’éléments attendus dans le tableau.The maximum number of elements expected in the array.

options
StringSplitOptions

Une des valeurs d’énumération qui détermine si l’opération de division doit omettre les sous-chaînes vides dans la valeur retournée.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Retours

String[]

Tableau dont les éléments contiennent au maximum count sous-chaînes de cette instance, qui sont délimitées par separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Remarques

Si la chaîne a déjà été fractionnée count-1 fois, mais que la fin de la chaîne n’a pas été atteinte, la dernière chaîne dans le tableau retourné contient la sous-chaîne de fin restante de cette instance, sans toucher.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(String[], Int32, StringSplitOptions)

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);
public string[] Split (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

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

options
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.

Attributs

Exceptions

count est un nombre négatif.count is negative.

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

Exemples

L’exemple suivant utilise l’énumération StringSplitOptions pour inclure ou exclure des sous-chaînes générées par la méthode Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

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 paramètre count 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 paramètre separator 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 méthode Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Toutefois, si le paramètre separator dans l’appel à cette surcharge de méthode est null, la résolution de surcharge de 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 l' 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 paramètre count est égal à zéro, ou si le paramètre options est RemoveEmptyEntries 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 paramètre options est None, et 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 de tableau correspondant contient Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

S’il y a plus de count sous-chaînes dans cette instance, la première count moins 1 sous-chaînes est retournée dans le premier count moins 1 élément de la valeur de retour, et les autres caractères de 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 de 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 méthode Split extrait les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs chaînes dans le paramètre separator, 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 méthode Split 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, consultez l’énumération System.Globalization.CompareOptions.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

La méthode Split ignore tout élément de separator 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 les chaînes de separator ont des caractères en commun, la méthode Split se poursuit du début à la fin de la valeur de l’instance, et correspond au premier élément de separator qui est égal à un délimiteur de l’instance.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’ordre des éléments dans separator.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 et correspond à un élément dans separator 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 premier délimiteur separator 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 méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, 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, utilisez la méthode IndexOf ou IndexOfAny 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, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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)

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);
public string[] Split (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

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.

Attributs

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 entre les tableaux retournés en appelant la méthode String.Split(String[], StringSplitOptions) d’une chaîne avec son paramètre options égal à StringSplitOptions.None et StringSplitOptions.RemoveEmptyEntries.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

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

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

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

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

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. Le passage de ce tableau avec la valeur StringSplitOptions.RemoveEmptyEntries à la méthode Split(String[], StringSplitOptions) 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’argument options 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 des valeurs de String.Empty 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 méthode Split 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 tableau de separator 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 paramètre options 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’argument options est None, et 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 de tableau correspondant contient String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Par exemple, si separator comprend deux éléments, « - » et «_», la valeur de l’instance de chaîne est « -_AA-_», et la valeur de l’argument options est None, 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 de 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 paramètre separator 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 méthode Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Si le paramètre separator dans l’appel à cette surcharge de méthode est null, la résolution de surcharge de 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 l' 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 méthode Split extrait les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs chaînes dans le paramètre separator, 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 méthode Split 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, consultez l’énumération System.Globalization.CompareOptions.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

La méthode Split ignore tout élément de separator 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 les chaînes de separator ont des caractères en commun, l’opération Split se poursuit du début à la fin de la valeur de l’instance, et correspond au premier élément de separator qui est égal à un délimiteur de l’instance.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’ordre des éléments dans separator.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 et correspond à un élément dans separator 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 premier délimiteur separator 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 méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, 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, utilisez la méthode IndexOf ou IndexOfAny 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, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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)

Divise une chaîne en un nombre maximal de sous-chaînes d’après le séparateur de chaînes fourni.Splits a string into a maximum number of substrings based on the provided string separator.

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

Paramètres

separator
String

Chaîne qui délimite les sous-chaînes de cette instance.A string that delimits the substrings in this instance.

count
Int32

Nombre maximal d’éléments attendus dans le tableau.The maximum number of elements expected in the array.

options
StringSplitOptions

Une des valeurs d’énumération qui détermine si l’opération de division doit omettre les sous-chaînes vides dans la valeur retournée.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Retours

String[]

Tableau dont les éléments contiennent au maximum count sous-chaînes de cette instance, qui sont délimitées par separator.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Remarques

Si la chaîne a déjà été fractionnée count-1 fois, mais que la fin de la chaîne n’a pas été atteinte, la dernière chaîne dans le tableau retourné contient la sous-chaîne de fin restante de cette instance, sans toucher.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(Char[], StringSplitOptions)

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);
public string[] Split (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

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.

Attributs

Exceptions

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

Exemples

L’exemple suivant utilise l’énumération StringSplitOptions pour inclure ou exclure des sous-chaînes générées par la méthode Split.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Remarques

Détails de la valeur de retourReturn value details

Les caractères de délimitation (les caractères dans le tableau separator) 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 tableau de separator 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 aucun des caractères de 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 paramètre options 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’argument options est None, et 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 de tableau correspondant contient String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Par exemple, si separator comprend deux éléments, « - » et «_», la valeur de l’instance de chaîne est « -_AA-_», et la valeur de l’argument options est None, 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 paramètre separator 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 méthode Char.IsWhiteSpace.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Si le paramètre separator dans l’appel à cette surcharge de méthode est null, la résolution de surcharge de 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 l' 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 méthode Split extrait les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères du paramètre separator, 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 méthode Split 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, consultez l’énumération System.Globalization.CompareOptions.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considérations sur les performancesPerformance Considerations

Les méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, 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, utilisez la méthode IndexOf ou IndexOfAny 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, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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)

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

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

count est un nombre négatif.count is negative.

Exemples

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

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

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

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

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 aucun des caractères de 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 paramètre separator 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 méthode Char.IsWhiteSpace.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’élément de tableau correspondant contient Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

S’il y a plus de count sous-chaînes dans cette instance, la première count moins 1 sous-chaînes est retournée dans le premier count moins 1 élément de la valeur de retour, et les autres caractères de 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 CountCount 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 méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, 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, utilisez la méthode IndexOf ou IndexOfAny 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, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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)

Divise une chaîne en sous-chaînes d’après le séparateur de caractères fourni.Splits a string into substrings based on the provided character separator.

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

Paramètres

separator
Char

Caractère qui délimite les sous-chaînes de cette chaîne.A character that delimits the substrings in this string.

options
StringSplitOptions

Une des valeurs d’énumération qui détermine si l’opération de division doit omettre les sous-chaînes vides dans la valeur retournée.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette instance, qui sont délimitées par separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(String, StringSplitOptions)

Divise une chaîne en sous-chaînes d’après le séparateur de chaînes fourni.Splits a string into substrings that are based on the provided string separator.

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

Paramètres

separator
String

Chaîne qui délimite les sous-chaînes de cette chaîne.A string that delimits the substrings in this string.

options
StringSplitOptions

Une des valeurs d’énumération qui détermine si l’opération de division doit omettre les sous-chaînes vides dans la valeur retournée.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Retours

String[]

Tableau dont les éléments contiennent les sous-chaînes de cette instance, qui sont délimitées par separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(Char[])

Divise une chaîne en sous-chaînes d’après les caractères du tableau de séparateurs.Splits a string into substrings that are based on the characters in the separator array.

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

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 paramètre separator de la méthode String.Split(Char[]) se compose d’un espace et d’un caractère de tabulation, ainsi que de 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 méthode Split(Char[]) 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 aucun des caractères de 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 le tableau retourné contient Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. 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’argument separator est null ou ne contient pas de caractères, 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 à la méthode Char.IsWhiteSpace.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 de String.Split soit un tableau de caractères, vous pouvez l’appeler avec un seul caractère, 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é que le paramètre separator est décoré avec l’attribut ParamArrayAttribute, les compilateurs interprètent un seul caractère 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 les autres surcharges de String.Split qui incluent un paramètre separator ; vous devez passer explicitement ces surcharges un tableau de caractères en tant qu’argument separator.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Détails de la comparaisonComparison details

La méthode Split(Char[]) extrait les sous-chaînes de cette chaîne qui sont délimitées par un ou plusieurs caractères dans le tableau separator, 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 méthode Split(Char[]) 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, consultez l’énumération System.Globalization.CompareOptions.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considérations sur les performancesPerformance Considerations

Les méthodes Split allouent de la mémoire pour l’objet de tableau retourné et un objet String 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 votre application, envisagez d’utiliser la méthode IndexOf ou IndexOfAny.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 méthode Compare 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 séparation, utilisez la méthode IndexOf ou IndexOfAny 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 séparation, utilisez la méthode IndexOf ou IndexOfAny 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 méthode Compare pour déterminer si les caractères situés après 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 dans plusieurs appels de méthode Split, 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 le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, si la méthode Split(Char[]) reçoit un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que la méthode Trim(Char[]) fait pour supprimer 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 à