Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

String.Split, méthode (Char[], StringSplitOptions)

Retourne un tableau de chaînes qui contient les sous-chaînes de cette chaîne, délimitées par les éléments d'un tableau de caractères Unicode spécifié. Un paramètre spécifie s'il faut retourner les éléments de tableau vides.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)
[ComVisibleAttribute(false)]
public string[] Split(
	char[] separator,
	StringSplitOptions options
)

Paramètres

separator
Type : System.Char[]
Tableau de caractères Unicode qui délimitent les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteur, ou null.
options
Type : System.StringSplitOptions
RemoveEmptyEntries pour ignorer les éléments de tableau vides du tableau retourné ou None pour inclure les éléments de tableau vides du tableau retourné.

Valeur de retour

Type : System.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. Pour plus d'informations, consultez la section Notes.
ExceptionCondition
ArgumentException

options ne fait pas partie des valeurs StringSplitOptions.

Les caractères délimiteurs ne sont pas inclus dans les éléments du tableau retourné.

Si cette instance ne contient aucun des caractères de separator, le tableau retourné se compose d'un seul élément contenant cette instance. Si le paramètre separator est null ou ne contient pas de caractères, les délimiteurs sont supposés être des espaces blancs. Les caractères d'espace de blanc sont définis par la norme Unicode et retournent la valeur true s'ils sont passés à la méthode Char.IsWhiteSpace. Toutefois, si le paramètre separator dans l'appel de cette surcharge de méthode est null, la résolution de la surcharge du compilateur échoue. Pour identifier la méthode appelée clairement, votre code doit indiquer le type null. L'exemple suivant affiche plusieurs méthodes pour identifier cette surcharge clairement.


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


Chaque élément de separator définit un caractère délimiteur séparé. Si le paramètre options est RemoveEmptyEntries et que la longueur de cette instance est égale à zéro, un tableau vide est retourné.

Si le paramètre options est None et que deux délimiteurs sont adjacents ou qu'un délimiteur est trouvé au début ou à la fin de cette instance, l'élément de tableau correspondant contient Empty.

Considérations sur les performances

Les méthodes Split allouent de la mémoire pour l'objet tableau retourné et un objet String pour chaque élément du tableau. Si votre application requiert des performances optimales ou si la gestion de l'allocation de mémoire est critique dans votre application, envisagez d'utiliser la méthode IndexOf ou IndexOfAny, et éventuellement la méthode Compare, pour localiser une sous-chaîne dans une chaîne.

Si vous fractionnez une chaîne au caractère de séparation, utilisez la méthode IndexOf ou IndexOfAny pour rechercher un caractère de séparation dans la chaîne. 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. Puis utilisez la méthode Compare pour déterminer si les caractères suivant ce premier caractère sont égaux aux caractères restants de la chaîne de séparation.

De plus, si le même jeu de caractères est utilisé pour fractionner des chaînes en plusieurs appels de méthode Split, envisagez la création d'un tableau unique et son référencement dans chaque appel de méthode. Cela réduit considérablement la surcharge supplémentaire de chaque appel de méthode.

Remarques à l'attention des appelants

Dans .NET Framework 3.5 et les versions antérieures, si un separator est passé à la méthode Split qui est null ou ne contient pas de caractères, la méthode utilise un jeu légèrement différent de caractères pour fractionner la chaîne que la méthode Trim fait pour découper la chaîne. Dans le .NET Framework 4, les deux méthodes utilisent un jeu identique d'espaces blancs Unicode.

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.


// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
using System;

class Sample 
{
    public static void Main() 
    {
    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.
    public static 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]>

*/


.NET Framework

Pris en charge dans : 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Cela vous a-t-il été utile ?
(1500 caractères restants)

Ajouts de la communauté

© 2013 Microsoft. Tous droits réservés.