Regex.Split Regex.Split Regex.Split Regex.Split Method

Définition

Fractionne une chaîne d'entrée en tableau de sous-chaînes aux positions définies par une correspondance d'expression régulière.Splits an input string into an array of substrings at the positions defined by a regular expression match.

Surcharges

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les options spécifiées modifient l'opération correspondante.Specified options modify the matching operation.

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

Fractionne une entrée chaîne un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le Regex constructeur.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La recherche du modèle d’expression régulière débute à une position de caractère spécifiée dans la chaîne d’entrée.The search for the regular expression pattern starts at a specified character position in the input string.

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

Fractionne une entrée chaîne un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le Regex constructeur.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String) Split(String) Split(String) Split(String)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié dans le Regex constructeur.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

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

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to split.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retours

String[]

Tableau de chaînes.A string array.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern a la valeur null.input or pattern is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.options is not a valid bitwise combination of RegexOptions values.

ou-or- matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.matchTimeout is negative, zero, or greater than approximately 24 days.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split(Char[]) (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La chaîne est fractionnée autant de fois que possible.The string is split as many times as possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la version d’origine input chaîne.If no delimiter is found, the return value contains one element whose value is the original input string.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Important

Les expressions régulières utilisées dans les appels statiques compilées Split méthodes sont mis en cache automatiquement.Compiled regular expressions used in calls to static Split methods are automatically cached. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez l’instance Split méthodes.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si plusieurs correspondances sont adjacentes, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another, an empty string is inserted into the array. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union, le tableau retourné inclure une chaîne vide à la position où sont trouvent les deux traits d’union.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. L’exemple suivant utilise le modèle d’expression régulière [a-z]+ pour fractionner une chaîne d’entrée sur n’importe quel caractère alphabétique majuscule ou minuscule.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Étant donné que la chaîne commence et se termine avec la mise en correspondance des caractères alphabétiques, la valeur de l’élément de premier et dernier du tableau retourné est String.Empty.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si les parenthèses de capture sont utilisées dans un Regex.Split expression, tout texte capturée est inclus dans le tableau de chaînes qui en résulte.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé dans les parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans le .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses, de texte capturé à partir des autres parenthèses de capture n’est pas inclus dans le tableau retourné.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date, y compris les séparateurs de date, d’une chaîne de date.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre oblique.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, il exclut les barres obliques ; s’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, il les inclut.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si l’expression régulière peut correspondre à une chaîne vide, Split fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

Le matchTimeout paramètre spécifie la manière dont la durée pendant laquelle un modèle de correspondance méthode doit essayer de trouver une correspondance avant son expiration. Définition d’un intervalle de délai d’attente empêche des expressions régulières qui s’appuient sur une rétroaction excessive d’apparaître à cesser de répondre lorsqu’elles traitent une entrée qui contient près de correspondances.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Pour plus d’informations, consultez meilleures pratiques pour les Expressions régulières et rétroaction.For more information, see Best Practices for Regular Expressions and Backtracking. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève un RegexMatchTimeoutException exception.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut défini pour le domaine d’application dans laquelle la méthode s’exécute.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notes pour les appelants

Nous vous recommandons de définir le matchTimeout paramètre à une valeur appropriée, comme les deux secondes.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si vous désactivez des délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes :However, you should disable time-outs only under the following conditions: -Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Cela exclut le texte qui a été dynamiquement par les utilisateurs.This excludes text that has been dynamically input by users.

-Lorsque le modèle d’expression régulière a été testé pour s’assurer qu’elle gère efficacement corresponde au, non-correspondances et proche.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Lorsque le modèle d’expression régulière ne contient aucun élément de langage qui est connus pour provoquer une rétroaction excessive lors du traitement d’une correspondance proche.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Voir aussi

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Les options spécifiées modifient l'opération correspondante.Specified options modify the matching operation.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to split.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.A bitwise combination of the enumeration values that provide options for matching.

Retours

String[]

Tableau de chaînes.An array of strings.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern a la valeur null.input or pattern is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split(Char[]) (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La chaîne est fractionnée autant de fois que possible.The string is split as many times as possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la version d’origine input chaîne.If no delimiter is found, the return value contains one element whose value is the original input string.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Important

Les expressions régulières utilisées dans les appels statiques compilées Split méthodes sont mis en cache automatiquement.Compiled regular expressions used in calls to static Split methods are automatically cached. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez l’instance Split méthodes.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si plusieurs correspondances sont adjacentes, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another, an empty string is inserted into the array. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union, le tableau retourné inclure une chaîne vide à la position où sont trouvent les deux traits d’union.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. L’exemple suivant utilise le modèle d’expression régulière [a-z]+ pour fractionner une chaîne d’entrée sur n’importe quel caractère alphabétique majuscule ou minuscule.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Étant donné que la chaîne commence et se termine avec la mise en correspondance des caractères alphabétiques, la valeur de l’élément de premier et dernier du tableau retourné est String.Empty.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si les parenthèses de capture sont utilisées dans un Regex.Split expression, tout texte capturée est inclus dans le tableau de chaînes qui en résulte.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé dans les parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans le .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses, de texte capturé à partir des autres parenthèses de capture n’est pas inclus dans le tableau retourné.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date, y compris les séparateurs de date, d’une chaîne de date.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre oblique.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, il exclut les barres obliques ; s’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, il les inclut.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si l’expression régulière peut correspondre à une chaîne vide, Split fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes pour les appelants

Cette méthode expire après un intervalle est égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel la méthode est appelée.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche la méthode de délai d’expiration, est utilisé.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. La méthode statique recommandée pour fractionner le texte sur une correspondance de modèle est Split(String, String, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Voir aussi

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

Fractionne une entrée chaîne un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le Regex constructeur.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. La recherche du modèle d’expression régulière débute à une position de caractère spécifiée dans la chaîne d’entrée.The search for the regular expression pattern starts at a specified character position in the input string.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);
public string[] Split (string input, int count, int startat);
member this.Split : string * int * int -> string[]
Public Function Split (input As String, count As Integer, startat As Integer) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to be split.

count
Int32 Int32 Int32 Int32

Le nombre maximal de fois où que le fractionnement peut se produire.The maximum number of times the split can occur.

startat
Int32 Int32 Int32 Int32

Position du caractère dans la chaîne d’entrée où la recherche doit commencer.The character position in the input string where the search will begin.

Retours

String[]

Tableau de chaînes.An array of strings.

Exceptions

startat est inférieur à zéro ou supérieur à la longueur de input.startat is less than zero or greater than the length of input.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Le count paramètre spécifie le nombre maximal de sous-chaînes dans lesquelles la input chaîne est fractionnée ; la dernière chaîne contient la fractionnée de la chaîne.The count parameter specifies the maximum number of substrings into which the input string is split; the last string contains the unsplit remainder of the string. Un count valeur zéro fournit le comportement par défaut de fractionnement autant de fois que possible.A count value of zero provides the default behavior of splitting as many times as possible. Le startat paramètre définit le point à partir duquel commence la recherche pour le premier délimiteur (Cela peut être utilisé pour ignorer l’espace blanc de début).The startat parameter defines the point at which the search for the first delimiter begins (this can be used for skipping leading white space).

Si aucune correspondance n’est trouvée à partir de la count+ 1 positionner dans la chaîne, la méthode retourne un tableau d’un élément qui contient le input chaîne.If no matches are found from the count+1 position in the string, the method returns a one-element array that contains the input string. Si un ou plusieurs correspondances sont trouvées, le premier élément du tableau retourné contient la première partie de la chaîne au premier caractère jusqu'à un caractère avant la correspondance.If one or more matches are found, the first element of the returned array contains the first portion of the string from the first character up to one character before the match.

Si plusieurs correspondances sont adjacentes et le nombre de correspondances trouvées est au moins deux inférieur à count, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another and the number of matches found is at least two less than count, an empty string is inserted into the array. De même, si une correspondance est trouvée à startat, qui est le premier caractère dans la chaîne, le premier élément du tableau retourné est une chaîne vide.Similarly, if a match is found at startat, which is the first character in the string, the first element of the returned array is an empty string. Autrement dit, les chaînes vides qui résultent des correspondances adjacentes sont comptés pour déterminer si le nombre de mises en correspondance de sous-chaînes equals count.That is, empty strings that result from adjacent matches are counted in determining whether the number of matched substrings equals count. Dans l’exemple suivant, l’expression régulière \d+ est utilisé pour rechercher la position de départ de la première sous-chaîne de caractères numériques dans une chaîne, puis fractionne la chaîne pour un maximum de trois fois à partir de cette position.In the following example, the regular expression \d+ is used to find the starting position of the first substring of numeric characters in a string, and then to split the string a maximum of three times starting at that position. Étant donné que le modèle d’expression régulière correspond au début de la chaîne d’entrée, le tableau de chaînes retourné se compose d’une chaîne vide, une chaîne de caractères alphabétiques cinq caractères et le reste de la chaîne,Because the regular expression pattern matches the beginning of the input string, the returned string array consists of an empty string, a five-character alphabetic string, and the remainder of the string,

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si les parenthèses de capture sont utilisées dans une expression régulière, n’importe quel texte capturé est inclus dans le tableau de chaînes fractionnées.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Toutefois, tous les éléments de tableau qui contiennent le texte capturé ne sont pas comptés pour déterminer si le nombre de correspondances a atteint count.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Par exemple, si la chaîne « « apple-apricot-plum-pear-pomegranate-pineapple-peach » est fractionnée en un maximum de quatre sous-chaînes en commençant à caractère 15 dans les résultats de la chaîne dans un tableau de sept éléments, comme le montre le code suivant.For example, splitting the string '"apple-apricot-plum-pear-pomegranate-pineapple-peach" into a maximum of four substrings beginning at character 15 in the string results in a seven-element array, as the following code shows.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses, de texte capturé à partir des autres parenthèses de capture n’est pas inclus dans le tableau retourné.In .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les mots individuels dans une chaîne.For example, the following code uses two sets of capturing parentheses to extract the individual words in a string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre verticale.The first set of capturing parentheses captures the hyphen, and the second set captures the vertical bar. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, il exclut la verticale de la barre des caractères ; s’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, il les inclut.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the vertical bar characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Si l’expression régulière peut correspondre à une chaîne vide, Split fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. L’exemple suivant fractionne les caractères « chaîne » en autant d’éléments que contient de la chaîne d’entrée, en commençant par le caractère « a ».The following example splits the string "characters" into as many elements as the input string contains, starting with the character "a". Étant donné que la chaîne null correspond à la fin de la chaîne d’entrée, une chaîne null est insérée à la fin du tableau retourné.Because the null string matches the end of the input string, a null string is inserted at the end of the returned array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Voir aussi

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

Fractionne une entrée chaîne un nombre de fois maximal spécifié en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le Regex constructeur.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count);
public string[] Split (string input, int count);
member this.Split : string * int -> string[]
Public Function Split (input As String, count As Integer) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to be split.

count
Int32 Int32 Int32 Int32

Le nombre maximal de fois où que le fractionnement peut se produire.The maximum number of times the split can occur.

Retours

String[]

Tableau de chaînes.An array of strings.

Exceptions

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Le count paramètre spécifie le nombre maximal de sous-chaînes dans lesquelles la input chaîne peut être fractionnée ; la dernière chaîne contient la fractionnée de la chaîne.The count parameter specifies the maximum number of substrings into which the input string can be split; the last string contains the unsplit remainder of the string. Un count valeur zéro fournit le comportement par défaut de fractionnement autant de fois que possible.A count value of zero provides the default behavior of splitting as many times as possible.

Si plusieurs correspondances sont adjacentes ou si une correspondance est trouvée au début ou à la fin de input, et le nombre de correspondances trouvées est au moins deux inférieur à count, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another or if a match is found at the beginning or end of input, and the number of matches found is at least two less than count, an empty string is inserted into the array. Autrement dit, les chaînes vides qui résultent de correspondances adjacentes ou de correspondances au début ou à la fin de la chaîne d’entrée sont comptés pour déterminer si le nombre de mises en correspondance de sous-chaînes equals count.That is, empty strings that result from adjacent matches or from matches at the beginning or end of the input string are counted in determining whether the number of matched substrings equals count. Dans l’exemple suivant, l’expression régulière /d+ est utilisé pour fractionner une chaîne d’entrée qui inclut un ou plusieurs chiffres décimaux en un maximum de trois des sous-chaînes.In the following example, the regular expression /d+ is used to split an input string that includes one or more decimal digits into a maximum of three substrings. Étant donné que le début de la chaîne d’entrée correspond au modèle d’expression régulière, le premier élément du tableau contient String.Empty, le deuxième contient le premier jeu de caractères alphabétiques dans la chaîne d’entrée et le troisième contient le reste de la chaîne qui suit la correspondance de tiers.Because the beginning of the input string matches the regular expression pattern, the first array element contains String.Empty, the second contains the first set of alphabetic characters in the input string, and the third contains the remainder of the string that follows the third match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si les parenthèses de capture sont utilisées dans une expression régulière, n’importe quel texte capturé est inclus dans le tableau de chaînes fractionnées.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Toutefois, tous les éléments de tableau qui contiennent le texte capturé ne sont pas comptés pour déterminer si le nombre de correspondances a atteint count.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Par exemple, si la chaîne « apple-apricot-plum-pear-banana » en un maximum de quatre résultats sous-chaînes dans un tableau de sept éléments, comme le code suivant montre.For example, splitting the string "apple-apricot-plum-pear-banana" into a maximum of four substrings results in a seven-element array, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans le .NET Framework 1.0 et 1.1, seul le texte capturé à partir du premier jeu de parenthèses de capture est inclus dans le tableau retourné.In the .NET Framework 1.0 and 1.1, only captured text from the first set of capturing parentheses is included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is added to the returned array. Toutefois, les éléments dans le tableau retourné qui contiennent le texte capturé ne sont pas comptés pour déterminer si le nombre de mises en correspondance de sous-chaînes equals count.However, elements in the returned array that contain captured text are not counted in determining whether the number of matched substrings equals count. Par exemple, dans le code suivant, une expression régulière utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date à partir d’une chaîne de date.For example, in the following code, a regular expression uses two sets of capturing parentheses to extract the elements of a date from a date string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre oblique.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. L’appel à la Split(String, Int32) méthode spécifie ensuite un maximum de deux éléments dans le tableau retourné.The call to the Split(String, Int32) method then specifies a maximum of two elements in the returned array. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, la méthode retourne un tableau de chaînes de deux éléments.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, the method returns a two-element string array. S’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, la méthode retourne un tableau de chaînes de trois éléments.If it is compiled and run under the .NET Framework 2.0 or later versions, the method returns a three-element string array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007' 
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007' 

Si l’expression régulière peut correspondre à une chaîne vide, Split(String, Int32) fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split(String, Int32) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. L’exemple suivant fractionne la chaîne « characters » en comme de nombreux éléments qu’il y dans la chaîne d’entrée.The following example splits the string "characters" into as many elements as there are in the input string. Étant donné que la chaîne null correspond au début de la chaîne d’entrée, une chaîne null est insérée au début du tableau retourné.Because the null string matches the beginning of the input string, a null string is inserted at the beginning of the returned array. Cela entraîne le dixième élément se compose de deux caractères à la fin de la chaîne d’entrée.This causes the tenth element to consist of the two characters at the end of the input string.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Voir aussi

Split(String) Split(String) Split(String) Split(String)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié dans le Regex constructeur.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);
public string[] Split (string input);
member this.Split : string -> string[]
Public Function Split (input As String) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to split.

Retours

String[]

Tableau de chaînes.An array of strings.

Exceptions

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split(Char[]) (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. La chaîne est fractionnée autant de fois que possible.The string is split as many times as possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la chaîne d’entrée d’origine.If no delimiter is found, the return value contains one element whose value is the original input string.

Si plusieurs correspondances sont adjacentes, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another, an empty string is inserted into the array. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union, le tableau retourné inclure une chaîne vide à la position où sont trouvent les deux traits d’union, comme le montre le code suivant.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. L’exemple suivant utilise le modèle d’expression régulière \d+ pour fractionner une chaîne d’entrée sur des caractères numériques.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Étant donné que la chaîne commence et se termine avec la mise en correspondance des caractères numériques, la valeur de l’élément de premier et dernier du tableau retourné est String.Empty.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si les parenthèses de capture sont utilisées dans un Regex.Split expression, tout texte capturée est inclus dans le tableau de chaînes qui en résulte.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé dans les parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans le .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses, de texte capturé à partir des autres parenthèses de capture n’est pas inclus dans le tableau retourné.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date, y compris les séparateurs de date, d’une chaîne de date.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre oblique.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, il exclut les barres obliques ; s’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, il les inclut.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si l’expression régulière peut correspondre à une chaîne vide, Split(String) fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split(String) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Exemple :For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }
Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

Notez que le tableau retourné inclut également une chaîne vide au début et à la fin du tableau.Note that the returned array also includes an empty string at the beginning and end of the array.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Voir aussi

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

Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);
public static string[] Split (string input, string pattern);
static member Split : string * string -> string[]
Public Shared Function Split (input As String, pattern As String) As String()

Paramètres

input
String String String String

Chaîne à fractionner.The string to split.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

Retours

String[]

Tableau de chaînes.An array of strings.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern a la valeur null.input or pattern is null.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

Le Regex.Split méthodes sont similaires à la String.Split (méthode), à ceci près que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Le input chaîne est fractionnée autant de fois que possible.The input string is split as many times as possible. Si pattern est introuvable dans le input chaîne, la valeur de retour contient un élément dont la valeur est la version d’origine input chaîne.If pattern is not found in the input string, the return value contains one element whose value is the original input string.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Important

Les expressions régulières utilisées dans les appels statiques compilées Split méthodes sont mis en cache automatiquement.Compiled regular expressions used in calls to static Split methods are automatically cached. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez l’instance Split méthodes.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Si plusieurs correspondances sont adjacentes, une chaîne vide est insérée dans le tableau.If multiple matches are adjacent to one another, an empty string is inserted into the array. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union, le tableau retourné inclure une chaîne vide à la position où sont trouvent les deux traits d’union, comme le montre le code suivant.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. L’exemple suivant utilise le modèle d’expression régulière \d+ pour fractionner une chaîne d’entrée sur des caractères numériques.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Étant donné que la chaîne commence et se termine avec la mise en correspondance des caractères numériques, la valeur de l’élément de premier et dernier du tableau retourné est String.Empty.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si les parenthèses de capture sont utilisées dans un Regex.Split expression, tout texte capturée est inclus dans le tableau de chaînes qui en résulte.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé dans les parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs jeux de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Dans le .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses, de texte capturé à partir des autres parenthèses de capture n’est pas inclus dans le tableau retourné.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date, y compris les séparateurs de date, d’une chaîne de date.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Le premier jeu de parenthèses de capture capture le trait d’union, et la deuxième capture la barre oblique.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Si l’exemple de code est compilé et exécuté sous le .NET Framework 1.0 ou 1.1, il exclut les barres obliques ; s’il est compilé et exécuté sous le .NET Framework 2.0 ou versions ultérieures, il les inclut.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Si l’expression régulière peut correspondre à une chaîne vide, Split fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Exemple :For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Notez que le tableau retourné inclut également une chaîne vide au début et à la fin du tableau.Note that the returned array also includes an empty string at the beginning and end of the array.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes pour les appelants

Cette méthode expire après un intervalle est égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel la méthode est appelée.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche la méthode de délai d’expiration, est utilisé.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. La méthode statique recommandée pour fractionner le texte sur une correspondance de modèle est Split(String, String, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Voir aussi

S’applique à