Regex.Split Metodo

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

I Regex.Split metodi sono simili al String.Split(Char[]) metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene suddivisa 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 modello \d+ di espressione regolare per dividere una stringa di input su 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 all'interno delle 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 modello 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, li 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. Ad 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 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 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 Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione

Vedi anche

• Linguaggio di espressioni regolari - Riferimento rapido

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

I Regex.Split metodi sono simili al String.Split metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il count parametro specifica il numero massimo di sottostringhe in cui è possibile suddividere la input stringa. L'ultima stringa contiene il resto senzasplit della stringa. Il count valore 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 /d+ regolare viene usata per dividere 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 ha 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 modello 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 Split(String, Int32) metodo 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 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 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 Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione

Vedi anche

• Linguaggio di espressioni regolari - Riferimento rapido

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

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

Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.

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 modello \d+ di espressione regolare per dividere una stringa di input su 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 all'interno delle 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 modello 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, li 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. Ad 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 dell'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 utilizzato 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

• Elementi del linguaggio di espressioni regolari

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

I Regex.Split metodi sono simili al String.Split metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il count parametro specifica il numero massimo di sottostringhe in cui viene divisa la input stringa. L'ultima stringa contiene il resto non inserito della stringa. Il count valore zero fornisce il comportamento predefinito della suddivisione il maggior numero possibile di volte. Il startat parametro definisce il punto in cui inizia la ricerca del primo delimitatore ( che può essere usato per ignorare gli spazi vuoti iniziali).

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

Se nella stringa non vengono trovate corrispondenze dalla countposizione +1, il metodo restituisce una matrice di un elemento contenente la input stringa. Se vengono trovate una o più corrispondenze, il primo elemento della matrice restituita contiene la prima parte della stringa dal primo carattere fino 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, le stringhe vuote risultanti da corrispondenze adiacenti vengono conteggiate per determinare se il numero di sottostringhe corrispondenti è uguale a count. Nell'esempio seguente l'espressione \d+ regolare viene usata per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa e quindi per dividere 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, da una stringa alfabetica a cinque caratteri e dal 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 ha raggiunto count. Ad esempio, suddividendo la stringa '"apple-albicocca-plum-pear-pomegranate-ananas-pesca" in un massimo di quattro sottostringhe a partire dal carattere 15 nella stringa 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-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 modello 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, 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'

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 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 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 Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione

Vedi anche

• Linguaggio di espressioni regolari - Riferimento rapido

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

I Regex.Split metodi sono simili al String.Split(Char[]) metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene suddivisa 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 pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.

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.

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 modello [a-z]+ di espressione regolare per dividere 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 all'interno delle 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 modello 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, li 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 dell'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 utilizzato 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

• Elementi del linguaggio di espressioni regolari

Source:

Regex.Split.cs

Source:

Regex.Split.cs

Source:

Regex.Split.cs

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

Restituisce

Matrice di stringhe.

Eccezioni

Commenti

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

Il pattern parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressione regolare - Riferimento rapido.

Se più corrispondenze sono adiacenti tra loro, una stringa vuota viene inserita nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino causa l'inclusione di 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, una stringa vuota viene inclusa all'inizio o alla fine della matrice restituita. Nell'esempio seguente viene usato il modello [a-z]+ di espressione regolare per dividere 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 l'acquisizione delle parentesi viene usata in un'espressione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si suddivide la stringa "plum-pear" su un trattino posizionato all'interno delle parentesi di acquisizione, la matrice restituita include un elemento stringa contenente 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 modello 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 una corrispondenza non viene trovata 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 in avanti. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri della 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 caratteri singoli perché il delimitatore stringa vuoto può essere trovato in ogni posizione.

Il matchTimeout parametro specifica la durata di un metodo di corrispondenza del modello per cercare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce alle espressioni regolari che si basano su un backtracking eccessivo di apparire per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere Procedure consigliate per espressioni regolari e Backtracking. Se non viene trovata alcuna corrispondenza nell'intervallo di tempo, il metodo genera un'eccezione RegexMatchTimeoutException . matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene eseguito il metodo.

Note per i chiamanti

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

• Quando l'input elaborato da un'espressione regolare deriva da un'origine nota e attendibile o è costituita da testo statico. Ciò esclude il testo che è stato immesso dinamicamente dagli utenti.

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

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

Vedi anche

• Elementi del linguaggio di espressioni regolari