Regex.Split Metodo

Definizione

Suddivide una stringa di input in una matrice di sottostringhe nelle posizioni definite dalla corrispondenza di un'espressione regolare.Splits an input string into an array of substrings at the positions defined by a regular expression match.

Overload

Split(String, String, RegexOptions, TimeSpan)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String, String, RegexOptions)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Le opzioni specificate modificano l'operazione di corrispondenza.Specified options modify the matching operation.

Split(String, Int32, Int32)

Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.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 ricerca del criterio di espressione regolare inizia da una posizione del carattere specificata nella stringa di input.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, Int32)

Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.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)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato nel costruttore Regex.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)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions, TimeSpan)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.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()

Parametri

input
String

Stringa da dividere.The string to split.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Restituisce

String[]

Matrice di stringhe.A string array.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

options non è una combinazione bit per bit valida di valori di RegexOptions.options is not a valid bitwise combination of RegexOptions values.

-oppure--or- matchTimeout è negativo, zero o maggiore di circa 24 giorni.matchTimeout is negative, zero, or greater than approximately 24 days.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split(Char[]) metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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 stringa viene divisa il maggior numero di volte possibile.The string is split as many times as possible. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la input stringa originale.If no delimiter is found, the return value contains one element whose value is the original input string.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate utilizzate nelle chiamate ai Split metodi statici vengono automaticamente memorizzate nella cache.Compiled regular expressions used in calls to static Split methods are automatically cached. Per gestire la durata delle espressioni regolari compilate, usare i Split metodi di istanza.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se più corrispondenze sono adiacenti le une alle altre, viene inserita una stringa vuota nella matrice.If multiple matches are adjacent to one another, an empty string is inserted into the array. Se ad esempio si divide una stringa su un solo segno meno, la matrice restituita includerà una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.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.

Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita.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. Nell'esempio seguente viene usato il criterio di espressione regolare [a-z]+ per suddividere una stringa di input in qualsiasi carattere alfabetico maiuscolo o minuscolo.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Poiché la stringa inizia e termina con i caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''

Se in un'espressione vengono utilizzate le parentesi di acquisizione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Se, ad esempio, si divide la stringa "plum-pear" su un trattino racchiuso tra parentesi di acquisizione, la matrice restituita includerà un elemento stringa che contiene il trattino.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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, se non viene trovata una corrispondenza nel primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita.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. A partire da .NET Framework 2,0, viene aggiunto anche tutto il testo acquisito alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Il codice seguente, ad esempio, usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data.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. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Se il codice di esempio viene compilato ed eseguito con il .NET Framework 1,0 o 1,1, esclude la barra; Se viene compilata ed eseguita con la .NET Framework 2,0 o versioni successive, le include.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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.

Il matchTimeout parametro specifica per quanto tempo un metodo di criteri di ricerca deve provare a trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce la visualizzazione di espressioni regolari basate su un backtracking eccessivo per interrompere la risposta quando elaborano un input che contiene le corrispondenze vicine.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. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e il backtracking.For more information, see Best Practices for Regular Expressions and Backtracking. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo genera un' RegexMatchTimeoutException eccezione.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene eseguito il metodo.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Note per i chiamanti

Si consiglia di impostare il matchTimeout parametro su un valore appropriato, ad esempio due secondi.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se si disabilitano i timeout specificando InfiniteMatchTimeout , il motore delle espressioni regolari offre prestazioni leggermente migliori.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:However, you should disable time-outs only under the following conditions: -Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile oppure è costituito da testo statico.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Questo esclude il testo che è stato inserito dinamicamente dagli utenti.This excludes text that has been dynamically input by users.

-Quando il modello di espressione regolare è stato testato accuratamente per assicurarsi che gestisca in modo efficiente le corrispondenze, non corrispondenze e quasi corrispondenze.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Vedi anche

Si applica a

Split(String, String, RegexOptions)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Le opzioni specificate modificano l'operazione di corrispondenza.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()

Parametri

input
String

Stringa da dividere.The string to split.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.A bitwise combination of the enumeration values that provide options for matching.

Restituisce

String[]

Matrice di stringhe.An array of strings.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

options non è una combinazione bit per bit valida di valori di RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split(Char[]) metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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 stringa viene divisa il maggior numero di volte possibile.The string is split as many times as possible. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la input stringa originale.If no delimiter is found, the return value contains one element whose value is the original input string.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate utilizzate nelle chiamate ai Split metodi statici vengono automaticamente memorizzate nella cache.Compiled regular expressions used in calls to static Split methods are automatically cached. Per gestire la durata delle espressioni regolari compilate, usare i Split metodi di istanza.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se più corrispondenze sono adiacenti le une alle altre, viene inserita una stringa vuota nella matrice.If multiple matches are adjacent to one another, an empty string is inserted into the array. Se ad esempio si divide una stringa su un solo segno meno, la matrice restituita includerà una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.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.

Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita.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. Nell'esempio seguente viene usato il criterio di espressione regolare [a-z]+ per suddividere una stringa di input in qualsiasi carattere alfabetico maiuscolo o minuscolo.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Poiché la stringa inizia e termina con i caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''

Se in un'espressione vengono utilizzate le parentesi di acquisizione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Se, ad esempio, si divide la stringa "plum-pear" su un trattino racchiuso tra parentesi di acquisizione, la matrice restituita includerà un elemento stringa che contiene il trattino.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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, se non viene trovata una corrispondenza nel primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita.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. A partire da .NET Framework 2,0, viene aggiunto anche tutto il testo acquisito alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Il codice seguente, ad esempio, usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data.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. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Se il codice di esempio viene compilato ed eseguito con il .NET Framework 1,0 o 1,1, esclude la barra; Se viene compilata ed eseguita con la .NET Framework 2,0 o versioni successive, le include.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione Split supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo.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. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout , non viene generata alcuna eccezione.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.

Note per i chiamanti

Si verifica il timeout di questo metodo dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato il metodo.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. Se non è stato definito un valore di timeout per il dominio dell'applicazione, InfiniteMatchTimeout viene usato il valore, che impedisce il timeout del metodo.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. Il metodo statico consigliato per suddividere il testo in base a un criterio di ricerca è Split(String, String, RegexOptions, TimeSpan) , che consente di impostare l'intervallo di timeout.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.

Vedi anche

Si applica a

Split(String, Int32, Int32)

Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.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 ricerca del criterio di espressione regolare inizia da una posizione del carattere specificata nella stringa di input.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()

Parametri

input
String

Stringa da suddividere.The string to be split.

count
Int32

Numero massimo di volte in cui la suddivisione può aver luogo.The maximum number of times the split can occur.

startat
Int32

Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.The character position in the input string where the search will begin.

Restituisce

String[]

Matrice di stringhe.An array of strings.

Eccezioni

input è null.input is null.

startat è minore di zero o maggiore della lunghezza di input.startat is less than zero or greater than the length of input.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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. Il count parametro specifica il numero massimo di sottostringhe in cui la input stringa è divisa; l'ultima stringa contiene il resto della stringa non suddiviso.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 valore pari a zero fornisce il comportamento predefinito di suddivisione del numero di volte possibile.A count value of zero provides the default behavior of splitting as many times as possible. Il startat parametro definisce il punto in corrispondenza del quale inizia la ricerca del primo delimitatore, che può essere usato per ignorare gli spazi vuoti iniziali.The startat parameter defines the point at which the search for the first delimiter begins (this can be used for skipping leading white space).

Se non viene trovata alcuna corrispondenza dalla count posizione + 1 nella stringa, il metodo restituisce una matrice a un elemento che contiene la input stringa.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. Se vengono rilevate una o più corrispondenze, il primo elemento della matrice restituita contiene la prima parte della stringa dal primo carattere fino a un carattere precedente alla corrispondenza.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.

Se più corrispondenze sono adiacenti l'una all'altra e il numero di corrispondenze trovate è almeno due minore di count , viene inserita una stringa vuota nella matrice.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. Analogamente, se viene trovata una corrispondenza in startat , ovvero il primo carattere della stringa, il primo elemento della matrice restituita è una stringa vuota.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. Ovvero, le stringhe vuote derivate da corrispondenze adiacenti vengono conteggiate per determinare se il numero di sottostringhe corrispondenti è uguale a count .That is, empty strings that result from adjacent matches are counted in determining whether the number of matched substrings equals count. Nell'esempio seguente viene usata l'espressione regolare \d+ per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa e quindi dividere la stringa per un massimo di tre volte a partire da quella posizione.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. Poiché il criterio di espressione regolare corrisponde all'inizio della stringa di input, la matrice di stringhe restituita è costituita da una stringa vuota, una stringa alfabetica di cinque caratteri e il resto della stringa.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'

Se in un'espressione regolare vengono utilizzate le parentesi di acquisizione, qualsiasi testo acquisito viene incluso nella matrice di stringhe divise.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Tuttavia, gli elementi di matrice che contengono testo acquisito non vengono conteggiati per determinare se è stato raggiunto il numero di corrispondenze count .However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Ad esempio, la suddivisione della stringa "" Apple-albicocca-prugna-pera-melograno-ananas-Peach "in un massimo di quattro sottostringhe a partire dal carattere 15 nella stringa restituisce una matrice a sette elementi, come illustrato nel codice seguente.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.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'
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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, se non viene trovata una corrispondenza nel primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita.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. A partire da .NET Framework 2,0, viene aggiunto anche tutto il testo acquisito alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Il codice seguente, ad esempio, usa due set di parentesi di acquisizione per estrarre le singole parole in una stringa.For example, the following code uses two sets of capturing parentheses to extract the individual words in a string. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra verticale.The first set of capturing parentheses captures the hyphen, and the second set captures the vertical bar. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1,0 o 1,1, esclude i caratteri della barra verticale; Se viene compilata ed eseguita con la .NET Framework 2,0 o versioni successive, le include.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi contenuti nella stringa di input, iniziando dal carattere "a".The following example splits the string "characters" into as many elements as the input string contains, starting with the character "a". Poiché la stringa null corrisponde alla fine della stringa di input, alla fine della matrice restituita viene inserita una stringa null.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}

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione Split supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore.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. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui Regex viene creato l'oggetto.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. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout , non viene generata alcuna eccezioneIf 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

Vedi anche

Si applica a

Split(String, Int32)

Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.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()

Parametri

input
String

Stringa da suddividere.The string to be split.

count
Int32

Numero massimo di volte in cui la suddivisione può aver luogo.The maximum number of times the split can occur.

Restituisce

String[]

Matrice di stringhe.An array of strings.

Eccezioni

input è null.input is null.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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. Il count parametro specifica il numero massimo di sottostringhe in cui la input stringa può essere divisa; l'ultima stringa contiene il resto della stringa non suddiviso.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 valore pari a zero fornisce il comportamento predefinito di suddivisione del numero di volte possibile.A count value of zero provides the default behavior of splitting as many times as possible.

Se più corrispondenze sono adiacenti l'una all'altra o se viene trovata una corrispondenza all'inizio o alla fine di input e il numero di corrispondenze trovato è almeno due minore di count , viene inserita una stringa vuota nella matrice.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. Ovvero, le stringhe vuote risultanti da corrispondenze adiacenti o da corrispondenze all'inizio o alla fine della stringa di input vengono conteggiate per determinare se il numero di sottostringhe corrispondenti è uguale a 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. Nell'esempio seguente viene usata l'espressione regolare /d+ per suddividere una stringa di input che include una o più cifre decimali in un massimo di tre sottostringhe.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. Poiché l'inizio della stringa di input corrisponde al criterio di espressione regolare, il primo elemento della matrice contiene String.Empty , il secondo contiene il primo set di caratteri alfabetici nella stringa di input e il terzo contiene il resto della stringa che segue la terza corrispondenza.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'

Se in un'espressione regolare vengono utilizzate le parentesi di acquisizione, qualsiasi testo acquisito viene incluso nella matrice di stringhe divise.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Tuttavia, gli elementi di matrice che contengono testo acquisito non vengono conteggiati per determinare se è stato raggiunto il numero di corrispondenze count .However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Ad esempio, suddividendo la stringa "Apple-albicocca-Plum-pera-banana" in un massimo di quattro sottostringhe si ottiene una matrice di sette elementi, come illustrato nel codice seguente.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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, nella matrice restituita viene incluso solo il testo acquisito dal primo set di parentesi di acquisizione.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. A partire da .NET Framework 2,0, tutto il testo acquisito viene aggiunto alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is added to the returned array. Tuttavia, gli elementi nella matrice restituita che contengono testo acquisito non vengono conteggiati per determinare se il numero di sottostringhe corrispondenti è uguale a count .However, elements in the returned array that contain captured text are not counted in determining whether the number of matched substrings equals count. Nel codice seguente, ad esempio, un'espressione regolare usa due set di parentesi di acquisizione per estrarre gli elementi di una data da una stringa di data.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. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. La chiamata al Split(String, Int32) metodo specifica quindi un massimo di due elementi nella matrice restituita.The call to the Split(String, Int32) method then specifies a maximum of two elements in the returned array. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1,0 o 1,1, il metodo restituisce una matrice di stringhe a due elementi.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. Se viene compilato ed eseguito in .NET Framework 2,0 o versioni successive, il metodo restituisce una matrice di stringhe a tre elementi.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split(String, Int32) suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi presenti nella stringa di input.The following example splits the string "characters" into as many elements as there are in the input string. Poiché la stringa null corrisponde all'inizio della stringa di input, viene inserita una stringa null all'inizio della matrice restituita.Because the null string matches the beginning of the input string, a null string is inserted at the beginning of the returned array. Questo fa sì che il decimo elemento sia costituito dai due caratteri alla fine della stringa di input.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}

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione Split supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore.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. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui Regex viene creato l'oggetto.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. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout , non viene generata alcuna eccezioneIf 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

Vedi anche

Si applica a

Split(String)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato nel costruttore Regex.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()

Parametri

input
String

Stringa da dividere.The string to split.

Restituisce

String[]

Matrice di stringhe.An array of strings.

Eccezioni

input è null.input is null.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split(Char[]) metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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 stringa viene divisa il maggior numero di volte possibile.The string is split as many times as possible. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa di input originale.If no delimiter is found, the return value contains one element whose value is the original input string.

Se più corrispondenze sono adiacenti le une alle altre, viene inserita una stringa vuota nella matrice.If multiple matches are adjacent to one another, an empty string is inserted into the array. Se ad esempio si divide una stringa in un singolo trattino, la matrice restituita includerà una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.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'

Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita.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. Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per suddividere una stringa di input in caratteri numerici.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''

Se in un'espressione vengono utilizzate le parentesi di acquisizione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Se, ad esempio, si divide la stringa "plum-pear" su un trattino racchiuso tra parentesi di acquisizione, la matrice restituita includerà un elemento stringa che contiene il trattino.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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, se non viene trovata una corrispondenza nel primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita.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. A partire da .NET Framework 2,0, viene aggiunto anche tutto il testo acquisito alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Il codice seguente, ad esempio, usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data.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. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Se il codice di esempio viene compilato ed eseguito con il .NET Framework 1,0 o 1,1, esclude la barra; Se viene compilata ed eseguita con la .NET Framework 2,0 o versioni successive, le include.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split(String) suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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. Ad esempio: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, }

Si noti che la matrice restituita include anche una stringa vuota all'inizio e alla fine della matrice.Note that the returned array also includes an empty string at the beginning and end of the array.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione Split supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore.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. Se non si imposta un intervallo di timeout quando si chiama il costruttore, viene generata un'eccezione se l'operazione supera un valore di timeout stabilito per il dominio dell'applicazione in cui Regex viene creato l'oggetto.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. Se non viene definito alcun timeout nella chiamata del Regex costruttore o nelle proprietà del dominio dell'applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout , non viene generata alcuna eccezioneIf 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

Vedi anche

Si applica a

Split(String, String)

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare.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()

Parametri

input
String

Stringa da dividere.The string to split.

pattern
String

Criterio di espressione regolare di cui trovare la corrispondenza.The regular expression pattern to match.

Restituisce

String[]

Matrice di stringhe.An array of strings.

Eccezioni

Si è verificato un errore di analisi dell'espressione regolare.A regular expression parsing error occurred.

input o pattern è null.input or pattern is null.

Si è verificato un timeout.A time-out occurred. Per altre informazioni sui timeout, vedere la sezione Osservazioni.For more information about time-outs, see the Remarks section.

Commenti

I Regex.Split metodi sono simili al String.Split metodo, con la differenza che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri.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. La input stringa viene divisa il maggior numero di volte possibile.The input string is split as many times as possible. Se pattern non viene trovato nella input stringa, il valore restituito contiene un elemento il cui valore è la input stringa originale.If pattern is not found in the input string, the return value contains one element whose value is the original input string.

Il pattern parametro è costituito da elementi del linguaggio di espressioni regolari che descrivono simbolicamente la stringa di cui trovare la corrispondenza.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Per ulteriori informazioni sulle espressioni regolari, vedere .NET Framework espressioni regolari e linguaggio di espressioni regolari -riferimento rapido.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate utilizzate nelle chiamate ai Split metodi statici vengono automaticamente memorizzate nella cache.Compiled regular expressions used in calls to static Split methods are automatically cached. Per gestire la durata delle espressioni regolari compilate, usare i Split metodi di istanza.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Se più corrispondenze sono adiacenti le une alle altre, viene inserita una stringa vuota nella matrice.If multiple matches are adjacent to one another, an empty string is inserted into the array. Se ad esempio si divide una stringa in un singolo trattino, la matrice restituita includerà una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.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'

Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita.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. Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per suddividere una stringa di input in caratteri numerici.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''

Se in un'espressione vengono utilizzate le parentesi di acquisizione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Se, ad esempio, si divide la stringa "plum-pear" su un trattino racchiuso tra parentesi di acquisizione, la matrice restituita includerà un elemento stringa che contiene il trattino.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'

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione della .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. In .NET Framework 1,0 e 1,1, se non viene trovata una corrispondenza nel primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita.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. A partire da .NET Framework 2,0, viene aggiunto anche tutto il testo acquisito alla matrice restituita.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Il codice seguente, ad esempio, usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data.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. Il primo set di parentesi di acquisizione acquisisce il segno meno e il secondo set acquisisce la barra.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Se il codice di esempio viene compilato ed eseguito con il .NET Framework 1,0 o 1,1, esclude la barra; Se viene compilata ed eseguita con la .NET Framework 2,0 o versioni successive, le include.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.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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo poiché è possibile trovare il delimitatore di stringa vuoto in ogni posizione.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. Ad esempio: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', ''}

Si noti che la matrice restituita include anche una stringa vuota all'inizio e alla fine della matrice.Note that the returned array also includes an empty string at the beginning and end of the array.

L' RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione Split supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo.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. Se non viene definito alcun timeout nelle proprietà del dominio dell'applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout , non viene generata alcuna eccezione.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.

Note per i chiamanti

Si verifica il timeout di questo metodo dopo un intervallo uguale al valore di timeout predefinito del dominio dell'applicazione in cui viene chiamato il metodo.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. Se non è stato definito un valore di timeout per il dominio dell'applicazione, InfiniteMatchTimeout viene usato il valore, che impedisce il timeout del metodo.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. Il metodo statico consigliato per suddividere il testo in base a un criterio di ricerca è Split(String, String, RegexOptions, TimeSpan) , che consente di impostare l'intervallo di timeout.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.

Vedi anche

Si applica a