Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Metodo Regex.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. La ricerca del criterio di ricerca di espressioni regolari si avvia a una posizione di 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
Tipo: System.String
Stringa da suddividere.
count
Tipo: System.Int32
Numero massimo di volte in cui la divisione può aver luogo.
startat
Tipo: System.Int32
Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.

Valore restituito

Tipo: System.String[]
Matrice di stringhe.

EccezioneCondizione
ArgumentNullException

input è null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Si è verificato un timeout. Per ulteriori informazioni sui timeout, vedere la sezione Note.

I metodi Regex.Split sono simili al metodo String.Split, ma divisioni che Regex.Split la stringa a un rettangolo ha determinato da un'espressione regolare anziché un set di caratteri. Il parametro count specifica il numero massimo di sottostringhe nel quale la stringa input viene suddivisa; l'ultima stringa contiene il resto della stringa non divisa. Impostando il valore di count su zero si ottiene il funzionamento predefinito che implica la suddivisione il maggior numero di volte possibile. Il parametro startat definisce il punto dove inizia la ricerca del primo separatore (ad esempio, questa funzione può essere utilizzata per saltare gli spazi vuoti iniziali).

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

Se più corrispondenze sono adiacenti e il numero di corrispondenze trovate è almeno due meno di count, una stringa vuota viene inserita nella matrice. Analogamente, se viene individuata una corrispondenza a startat, ovvero il primo carattere della stringa, il primo elemento della matrice restituita è una stringa vuota. Ovvero, stringhe vuote che sono il risultato di corrispondenze adiacenti vengono contate per determinare se il numero di sottostringhe corrispondente è uguale a count. Nell'esempio, l'espressione regolare \d+ viene utilizzata per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa e quindi per suddividere una stringa un massimo di tre volte inizianti in quella posizione. Poiché il modello 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- carattere 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 contenga testo acquisito non viene contato nel determinare se il numero di corrispondenze ha raggiunto count. Ad esempio, se si suddivide la stringa " apple-apricot-plum-pear-pomegranate-pineapple-peach " in un massimo di quattro sottostringhe iniziando dal carattere numero 15 nella stringa viene restituita una matrice di sette elementi, come illustrato nel codice riportato di seguito.


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 ricerca di espressioni regolari include più insiemi di parentesi di cattura, il funzionamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1,1, in caso contrario all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi aggiuntive di acquisizione non è incluso nella matrice restituita. A partire da.NET Framework 2.0, tutto il testo acquisito inoltre aggiunto alla matrice restituita. Ad esempio, nel codice riportato di seguito vengono utilizzati due insiemi di parentesi di cattura per estrarre le singole parole in una stringa. Primo set di parentesi di acquisizione acquisisce il trattino e il secondo set deve acquisire la barra verticale. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1,1, esclusi i caratteri di barra verticale; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, li contiene.


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 alla stringa vuota, Split dividerà la stringa in una matrice di stringhe a un solo carattere, dal momento che è possibile trovare il delimitatore della stringa vuota in qualunque posizione. Nell'esempio riportato di seguito i "caratteri" della stringa vengono suddivisi in tanti elementi quanti sono contenuti nella stringa di input, iniziando dal carattere "a". Poiché la stringa null corrisponde alla fine della stringa di input, una stringa null è 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}


L'eccezione RegexMatchTimeoutException se il tempo di esecuzione di un'operazione dividi 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, viene generata un'eccezione se l'operazione supera il valore di timeout impostato per il dominio applicazione in cui l'oggetto Regex viene creato. Se il timeout non viene definito nella chiamata al costruttore Regex o nelle proprietà del dominio applicazione, o se il valore di timeout viene Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione

.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft