Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Regex.Split (String, Int32, Int32)

 

Data di pubblicazione: ottobre 2016

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. La ricerca del criterio di espressione regolare inizia da una posizione del carattere specificata nella stringa di input.

Spazio dei nomi:   System.Text.RegularExpressions
Assembly:  System (in System.dll)

public string[] Split(
	string input,
	int count,
	int startat
)

Parametri

input
Type: System.String

Stringa da suddividere.

count
Type: System.Int32

Numero massimo di volte in cui la suddivisione può aver luogo.

startat
Type: System.Int32

Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.

Valore restituito

Type: System.String[]

Matrice di stringhe.

Exception Condition
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.

Il Regex.Split sono simili ai metodi di String.Split (metodo), con la differenza che Regex.Split suddivide la stringa delimitatore determinato da un'espressione regolare anziché un set di caratteri. Il count parametro specifica il numero massimo di sottostringhe in cui il input stringa viene suddivisa; l'ultima stringa contiene il resto della stringa non diviso. Oggetto count valore pari a zero fornisce il comportamento predefinito di suddividere il numero di volte possibile. Il startat parametro definisce il punto in cui inizia la ricerca per il primo delimitatore (può essere utilizzato per ignorare gli spazi vuoti iniziali).

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

Se più corrispondenze sono adiacenti e il numero di corrispondenze trovate è almeno due meno count, una stringa vuota viene inserita nella matrice. Analogamente, se viene individuata una corrispondenza a startat, che rappresenta il primo carattere nella stringa, il primo elemento della matrice restituita è una stringa vuota. Ovvero, stringhe vuote che risultato di corrispondenze adiacenti vengono contate per determinare se il numero di sottostringhe corrispondente è uguale count. Nell'esempio seguente, l'espressione regolare \d+ viene utilizzato per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa, quindi suddividere la stringa di un massimo di tre volte a partire da tale posizione. Poiché il criterio di espressione regolare corrisponde all'inizio della stringa di input, la stringa restituita matrice costituita da una stringa vuota, una stringa di cinque caratteri alfabetica 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'

Se in un'espressione regolare vengono utilizzate le parentesi di cattura, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, qualsiasi elemento di matrice che contengono testo acquisito non viene conteggiati per determinare se ha raggiunto il numero di corrispondenze count. Ad esempio, suddividere la stringa ' "peach" in un massimo di quattro sottostringhe iniziando dal carattere 15 nei risultati della stringa in una matrice di sette elementi, come illustrato nel codice seguente.

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 cattura, 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 cattura, il testo acquisito dalle parentesi di cattura aggiuntive non incluse nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene inoltre aggiunto alla matrice restituita. Ad esempio, il codice seguente utilizza due insiemi di parentesi di cattura per estrarre le singole parole in una stringa. Il primo set di parentesi di cattura acquisisce il trattino e il secondo insieme acquisisce la barra verticale. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude verticale della barra di caratteri. Se viene compilato ed eseguito con il .NET Framework 2.0 o versioni successive, li 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'

Se l'espressione regolare può corrispondere a una stringa vuota, Split dividerà la stringa in una matrice di stringhe di caratteri a singolo, in quanto il delimitatore di stringa vuota è reperibile in ogni posizione. Nell'esempio seguente suddivide i caratteri"stringa" in tutti gli elementi come stringa di input contiene, inizia con il carattere "a". Poiché la stringa null corrisponde alla fine della stringa di input, una stringa null viene inserita 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}

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: