Condividi tramite

Regex.Split Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Assembly:
netstandard.dll

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da una corrispondenza di espressione regolare.

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. Parametri aggiuntivi specificano opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.
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. Le opzioni specificate modificano l'operazione corrispondente.
Split(String, Int32, Int32)

Suddivide una stringa di input un numero massimo di volte specificato in una matrice di sottostringhe, in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. La ricerca del criterio di espressione regolare inizia in corrispondenza di una posizione di caratteri specificata nella stringa di input.
Split(String, String)

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

Suddivide una stringa di input un numero massimo di volte specificato in una matrice di sottostringhe, in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.

Split(String, String, RegexOptions, TimeSpan)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. Parametri aggiuntivi specificano opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.

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.

pattern
String

Modello di espressione regolare da trovare in corrispondenza.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono opzioni per la corrispondenza.

matchTimeout
TimeSpan

Intervallo di timeout o InfiniteMatchTimeout per indicare che il metodo non deve scadere.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è una combinazione bit per bit valida di valori di RegexOptions.

-o-

matchTimeout è negativo, zero o maggiore di circa 24 giorni.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split(Char[]), ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene divisa il maggior numero possibile di volte. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa originale input.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate usate nelle chiamate ai metodi Split statici vengono memorizzate automaticamente nella cache. Per gestire manualmente la durata delle espressioni regolari compilate, usare i metodi di Split dell'istanza.

Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la divisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.

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. 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. Poiché la stringa inizia e termina con caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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 le parentesi di acquisizione vengono usate in un'espressione Regex.Split, qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato tra parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.

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 alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione.

Il parametro matchTimeout consente di specificare per quanto tempo un metodo di ricerca dei criteri di ricerca deve provare a trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce che le espressioni regolari che si basano su un backtracking eccessivo vengano visualizzate per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e backtracking. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo genera un'eccezione RegexMatchTimeoutException. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio applicazione in cui viene eseguito il metodo.

Note per i chiamanti

È consigliabile impostare il parametro matchTimeout su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore delle espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:

  • Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile o è costituito da testo statico. Questo esclude il testo che è stato immesso dinamicamente dagli utenti.

  • Quando il criterio di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.

  • Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.

Vedi anche

Si applica a

Split(String, String, RegexOptions)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. Le opzioni specificate modificano l'operazione corrispondente.

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.

pattern
String

Modello di espressione regolare da trovare in corrispondenza.

options
RegexOptions

Combinazione bit per bit dei valori di enumerazione che forniscono opzioni per la corrispondenza.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

ArgumentOutOfRangeException

options non è una combinazione bit per bit valida di valori di RegexOptions.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split(Char[]), ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene divisa il maggior numero possibile di volte. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa originale input.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate usate nelle chiamate ai metodi Split statici vengono memorizzate automaticamente nella cache. Per gestire manualmente la durata delle espressioni regolari compilate, usare i metodi di Split dell'istanza.

Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la divisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.

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. 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. Poiché la stringa inizia e termina con caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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 le parentesi di acquisizione vengono usate in un'espressione Regex.Split, qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato tra parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.

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 alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione.

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

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato il metodo . Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la suddivisione del testo in una corrispondenza del criterio è Split(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

Si applica a

Split(String, Int32, Int32)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

Suddivide una stringa di input un numero massimo di volte specificato in una matrice di sottostringhe, in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. La ricerca del criterio di espressione regolare inizia in corrispondenza di una posizione di caratteri specificata nella stringa di input.

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

count
Int32

Numero massimo di volte in cui può verificarsi la divisione.

startat
Int32

Posizione del carattere nella stringa di input in cui inizierà la ricerca.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentNullException

input è null.

ArgumentOutOfRangeException

startat è minore di zero o maggiore della lunghezza di input.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split, ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il parametro count specifica il numero massimo di sottostringhe in cui viene divisa la stringa input; l'ultima stringa contiene il resto senzasplit della stringa. Un valore count pari a zero fornisce il comportamento predefinito della suddivisione il maggior numero possibile di volte. Il parametro startat definisce il punto in cui inizia la ricerca del primo delimitatore (può essere usato per ignorare lo spazio vuoto iniziale).

Per altre informazioni su startat, vedere la sezione Osservazioni di Match(String, Int32).

Se non vengono trovate corrispondenze dalla posizione count+1 nella stringa, il metodo restituisce una matrice di un elemento contenente la stringa input. Se vengono trovate una o più corrispondenze, il primo elemento della matrice restituita contiene la prima parte della stringa dal primo carattere a un carattere prima della corrispondenza.

Se più corrispondenze sono adiacenti l'una all'altra e il numero di corrispondenze trovate è almeno due minori di count, viene inserita una stringa vuota nella matrice. Analogamente, se viene trovata una corrispondenza in startat, ovvero il primo carattere nella stringa, il primo elemento della matrice restituita è una stringa vuota. Ovvero, vengono conteggiate stringhe vuote risultanti da corrispondenze adiacenti per determinare se il numero di sottostringhe corrispondenti è uguale a count. Nell'esempio seguente, l'espressione regolare \d+ viene usata per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa e quindi suddividere la stringa un massimo di tre volte a partire da tale posizione. 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,

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 le parentesi di acquisizione vengono usate in un'espressione regolare, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, tutti gli elementi della matrice che contengono testo acquisito non vengono conteggiati per determinare se il numero di corrispondenze è stato raggiunto count. Ad esempio, suddividendo la stringa '"apple-albicocca-plum-pomegranate-ananas-pesca" in un massimo di quattro sottostringhe a partire dal carattere 15 nella stringa viene restituita una matrice di sette elementi, come illustrato nel codice seguente.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre le singole parole in una stringa. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra verticale. 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 compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.

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 alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi contenuti nella stringa di input, a partire dal carattere "a". Poiché la stringa Null corrisponde alla fine della stringa di input, viene inserita una stringa Null alla fine della matrice restituita.

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

Vedi anche

Si applica a

Split(String, String)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare.

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.

pattern
String

Modello di espressione regolare da trovare in corrispondenza.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentException

Si è verificato un errore di analisi delle espressioni regolari.

ArgumentNullException

input o pattern è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split, ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa input viene suddivisa il maggior numero possibile di volte. Se pattern non viene trovato nella stringa input, il valore restituito contiene un elemento il cui valore è la stringa input originale.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

Importante

Le espressioni regolari compilate usate nelle chiamate ai metodi Split statici vengono memorizzate automaticamente nella cache. Per gestire manualmente la durata delle espressioni regolari compilate, usare i metodi di Split dell'istanza.

Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.

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. Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per suddividere una stringa di input in caratteri numerici. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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 le parentesi di acquisizione vengono usate in un'espressione Regex.Split, qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato tra parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.

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 alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Per esempio:

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.

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

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato il metodo . Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la suddivisione del testo in una corrispondenza del criterio è Split(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.

Vedi anche

Si applica a

Split(String)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

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.

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.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentNullException

input è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split(Char[]), ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene divisa il maggior numero possibile di volte. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa di input originale.

Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.

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. Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per suddividere una stringa di input in caratteri numerici. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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 le parentesi di acquisizione vengono usate in un'espressione Regex.Split, qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato tra parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.

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 alla stringa vuota, Split(String) suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Per esempio:

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.

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

Vedi anche

Si applica a

Split(String, Int32)

Origine:
Regex.Split.cs
Origine:
Regex.Split.cs
Origine:
Regex.Split.cs

Suddivide una stringa di input un numero massimo di volte specificato in una matrice di sottostringhe, in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex.

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

count
Int32

Numero massimo di volte in cui può verificarsi la divisione.

Restituisce

String[]

Matrice di stringhe.

Eccezioni

ArgumentNullException

input è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Commenti

I metodi Regex.Split sono simili al metodo String.Split, ad eccezione del fatto che Regex.Split suddivide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il parametro count specifica il numero massimo di sottostringhe in cui è possibile dividere la stringa input; l'ultima stringa contiene il resto senzasplit della stringa. Un valore count pari a zero fornisce il comportamento predefinito della suddivisione il maggior numero possibile di volte.

Se più corrispondenze sono adiacenti tra loro o se viene trovata una corrispondenza all'inizio o alla fine di inpute il numero di corrispondenze trovate è almeno due minore di count, viene inserita una stringa vuota nella matrice. Ovvero, vengono conteggiate stringhe vuote risultanti da corrispondenze adiacenti o da corrispondenze all'inizio o alla fine della stringa di input per determinare se il numero di sottostringhe corrispondenti è uguale a count. Nell'esempio seguente, l'espressione regolare /d+ viene usata per suddividere una stringa di input che include una o più cifre decimali in un massimo di tre sottostringhe. 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.

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 le parentesi di acquisizione vengono usate in un'espressione regolare, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, tutti gli elementi della matrice che contengono testo acquisito non vengono conteggiati per determinare se il numero di corrispondenze è stato raggiunto count. Ad esempio, suddividendo la stringa "apple-albicocca-plum-pear-banana" in un massimo di quattro sottostringhe si ottiene una matrice di sette elementi, come illustrato nel codice seguente.

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 di .NET Framework. In .NET Framework 1.0 e 1.1, solo il testo acquisito dal primo set di parentesi di acquisizione è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto alla matrice restituita. Tuttavia, gli elementi nella matrice restituita che contengono testo acquisito non vengono conteggiati per determinare se il numero di sottostringhe corrispondenti è uguale a 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. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. La chiamata al metodo Split(String, Int32) specifica quindi un massimo di due elementi nella matrice restituita. 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. Se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, il metodo restituisce una matrice di stringhe a tre elementi.

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 alla stringa vuota, Split(String, Int32) suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi presenti nella stringa di input. Poiché la stringa Null corrisponde all'inizio della stringa di input, viene inserita una stringa Null all'inizio della matrice restituita. In questo modo il decimo elemento è costituito dai due caratteri alla fine della stringa di input.

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

Vedi anche

Si applica a