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

Costruttore RegexCompilationInfo (String, RegexOptions, String, String, Boolean, TimeSpan)

.NET Framework (current version)
 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza di RegexCompilationInfo classe che contiene informazioni su un'espressione regolare con un valore di timeout specificato da includere in un assembly.

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

public RegexCompilationInfo(
	string pattern,
	RegexOptions options,
	string name,
	string fullnamespace,
	bool ispublic,
	TimeSpan matchTimeout
)

Parametri

pattern
Type: System.String

L'espressione regolare per la compilazione.

options
Type: System.Text.RegularExpressions.RegexOptions

Le opzioni di espressione regolare da utilizzare quando si compila l'espressione regolare.

name
Type: System.String

Il nome del tipo che rappresenta l'espressione regolare compilata.

fullnamespace
Type: System.String

Lo spazio dei nomi a cui appartiene il nuovo tipo.

ispublic
Type: System.Boolean

true Per rendere l'espressione regolare compilata visibile pubblicamente; in caso contrario, false.

matchTimeout
Type: System.TimeSpan

L'intervallo di timeout predefinito per l'espressione regolare.

Exception Condition
ArgumentException

name è String.Empty.

ArgumentNullException

pattern è null.

-oppure-

name è null.

-oppure-

fullnamespace è null.

ArgumentOutOfRangeException

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

Ogni parametro del RegexCompilationInfo(String, RegexOptions, String, String, Boolean) costruttore corrisponde direttamente a una proprietà del RegexCompilationInfo (classe). Poiché tutte le proprietà sono di lettura/scrittura, anche i relativi valori possono essere assegnati direttamente.

Il CompileToAssembly metodo genera un assembly che contiene le espressioni regolari compilate. Pertanto, non è necessario specificare Compiled come uno dei valori di options.

Se ispublic è true, la classe di espressione regolare compilata viene fornita l'accessibilità pubblica. Vale a dire, può essere creata un'istanza dal codice eseguito in qualsiasi assembly. Se ispublic è false, alla classe di espressione regolare compilata viene fornita internal (in c#) o Friend (in Visual Basic) accessibilità. Vale a dire, è possibile creare istanze solo dal codice eseguito nello stesso assembly della classe di espressioni regolari.

Il matchTimeout parametro definisce l'intervallo di timeout predefinito per l'espressione regolare compilata. Questo valore rappresenta la quantità approssimativa di tempo che un oggetto di espressione regolare compilata eseguirà una singola operazione corrispondente prima di timeout dell'operazione e il motore delle espressioni regolari genera un RegexMatchTimeoutException eccezione durante il successivo controllo di temporizzazione. Per ulteriori informazioni sul valore di timeout, vedere la MatchTimeout proprietà.

System_CAPS_importantImportante

È consigliabile impostare sempre un valore di timeout predefinito per un'espressione regolare compilata. I consumer della libreria di espressioni regolari possono eseguire l'override di tale valore di timeout passando un TimeSpan che rappresenta il nuovo intervallo di timeout per l'overload del costruttore.

Nell'esempio seguente definisce una singola espressione regolare compilata denominata DuplicateChars che identifica due o più occorrenze dello stesso carattere nella stringa di input. L'espressione regolare compilata dispone di un timeout predefinito di 2 secondi. Quando si esegue l'esempio, crea una libreria di classi denominata RegexLib. dll che contiene l'espressione regolare compilata.

using System;
using System.Reflection;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
        // Match two or more occurrences of the same character.
        string pattern = @"(\w)\1+";

        // Use case-insensitive matching. 
        var rci = new RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                           "DuplicateChars", "CustomRegexes", 
                                           true, TimeSpan.FromSeconds(2));

        // Define an assembly to contain the compiled regular expression.
        var an = new AssemblyName();
        an.Name = "RegexLib";
        RegexCompilationInfo[] rciList = { rci };

        // Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an);
   }
}

The regular expression pattern (\w)\1+ is defined as shown in the following table.

Pattern

Description

(\w)

Match any word character and assign it to the first capturing group.

\1+

Match one or more occurrences of the value of the first captured group.

Nell'esempio seguente viene utilizzata la DuplicatedChars espressione regolare per identificare i caratteri duplicati in una matrice di stringhe. Quando chiama il DuplicatedChars costruttore, modificare l'intervallo di timeout su 5 secondi.

using CustomRegexes;
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      var rgx = new DuplicateChars(TimeSpan.FromSeconds(.5));

      string[] values = { "Greeeeeat", "seed", "deed", "beam", 
                          "loop", "Aardvark" };
      // Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx);
      Console.WriteLine("Regex timeout value: {0} seconds\n", 
                        rgx.MatchTimeout.TotalSeconds);

      // Display matching information.
      foreach (var value in values) {
         Match m = rgx.Match(value);
         if (m.Success)
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1);
         else
            Console.WriteLine("No match found in '{0}'", value);
      }                                                         
   }
}
// The example displays the following output:
//       Regular Expression Pattern: (\w)\1+
//       Regex timeout value: 0.5 seconds
//       
//       //eeeee// found in //Greeeeeat// at positions 2-6
//       //ee// found in //seed// at positions 1-2
//       //ee// found in //deed// at positions 1-2
//       No match found in //beam//
//       //oo// found in //loop// at positions 1-2
//       //Aa// found in //Aardvark// at positions 0-1

.NET Framework
Disponibile da 4.5
Torna all'inizio
Mostra: