RegexCompilationInfo Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza una nuova istanza della classe RegexCompilationInfo.

Overload

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)	Inizializza una nuova istanza della classe RegexCompilationInfo che contiene informazioni su un'espressione regolare da includere in un assembly.
RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)	Inizializza una nuova istanza della classe RegexCompilationInfo che contiene informazioni su un'espressione regolare con un valore di timeout specificato da includere in un assembly.

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Inizializza una nuova istanza della classe RegexCompilationInfo che contiene informazioni su un'espressione regolare da includere in un assembly.

public:
 RegexCompilationInfo(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, System::String ^ name, System::String ^ fullnamespace, bool ispublic);

public RegexCompilationInfo (string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic);

new System.Text.RegularExpressions.RegexCompilationInfo : string * System.Text.RegularExpressions.RegexOptions * string * string * bool -> System.Text.RegularExpressions.RegexCompilationInfo

Public Sub New (pattern As String, options As RegexOptions, name As String, fullnamespace As String, ispublic As Boolean)

Parametri

pattern: String

Espressione regolare da compilare.

options: RegexOptions

Opzioni dell'espressione regolare da utilizzare per compilare l'espressione regolare.

name: String

Nome del tipo che rappresenta l'espressione regolare compilata.

fullnamespace: String

Spazio dei nomi al quale appartiene il nuovo tipo.

ispublic: Boolean

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

Eccezioni

ArgumentException

name è Empty.

ArgumentNullException

pattern è null.

-oppure-

name è null.

-oppure-

fullnamespace è null.

Esempio

Nell'esempio seguente viene creata e usata un'espressione regolare compilata in due passaggi.

Nel primo passaggio compilare ed eseguire l'esempio di codice seguente. Il RegexCompilationInfo costruttore nell'esempio di codice definisce un'espressione regolare compilata. Il risultato dell'esecuzione del codice è un assembly denominato FishRegex.dll che contiene un tipo di espressione regolare compilato denominato FishRegex.

// This code example demonstrates the RegexCompilationInfo constructor
// and the Regex.CompileToAssembly() method.
// compile: csc genFishRegex.cs

namespace MyApp
{
    using System;
    using System.Reflection;
    using System.Text.RegularExpressions;
    class GenFishRegEx
    {
        public static void Main()
        {
// Pattern = Group matches one or more word characters,
//           one or more white space characters,
//           group matches the string "fish".
        string pat = @"(\w+)\s+(fish)";

// Create the compilation information.
// Case-insensitive matching; type name = "FishRegex";
// namespace = "MyApp"; type is public.
        RegexCompilationInfo rci = new RegexCompilationInfo(
                    pat, RegexOptions.IgnoreCase,
                    "FishRegex", "MyApp", true);

// Setup to compile.
        AssemblyName an = new AssemblyName();
        an.Name = "FishRegex";
        RegexCompilationInfo[] rciList = { rci };

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

' This code example demonstrates the RegexCompilationInfo constructor
' and the Regex.CompileToAssembly() method.
' compile: csc genFishRegex.cs

Imports System.Reflection
Imports System.Text.RegularExpressions

Class GenFishRegEx
    Public Shared Sub Main() 
        ' Pattern = Group matches one or more word characters, 
        '           one or more white space characters, 
        '           group matches the string "fish".
        Dim pat As String = "(\w+)\s+(fish)"
        
        ' Create the compilation information.
        ' Case-insensitive matching; type name = "FishRegex"; 
        ' namespace = "MyApp"; type is public.
        Dim rci As New RegexCompilationInfo(pat, RegexOptions.IgnoreCase, _
                                            "FishRegex", "MyApp", True)
        
        ' Setup to compile.
        Dim an As New AssemblyName()
        an.Name = "FishRegex"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }
        
        ' Compile the regular expression.
        Regex.CompileToAssembly(rciList, an)
    
    End Sub
End Class

Nel secondo passaggio compilare l'esempio di codice seguente usando un riferimento a FishRegex.dll e quindi eseguire il file eseguibile risultante. Il file eseguibile corrisponde a una stringa di destinazione usando il tipo e visualizza la corrispondenza, il FishRegex gruppo, il gruppo di acquisizione e la posizione di indice delle corrispondenze nella stringa di destinazione.

// This code example demonstrates the RegexCompilationInfo constructor.
// Execute this code example after executing genFishRegex.exe.
// compile: csc /r:FishRegex.dll useFishRegex.cs

namespace MyApp
  {
  using System;
  using System.Reflection;
  using System.Text.RegularExpressions;

  class UseFishRegEx
    {
    public static void Main()
      {
// Match against the following target string.
      string targetString = "One fish two fish red fish blue fish";
      int matchCount = 0;
      FishRegex f = new FishRegex();

// Display the target string.
      Console.WriteLine("\nInput string = \"" + targetString + "\"");

// Display each match, capture group, capture, and match position.
      foreach (Match m in f.Matches(targetString))
    {
    Console.WriteLine("\nMatch(" + (++matchCount) + ")");
    for (int i = 1; i <= 2; i++)
      {
      Group g = m.Groups[i];
      Console.WriteLine("Group(" + i + ") = \"" + g + "\"");
      CaptureCollection cc = g.Captures;
      for (int j = 0; j < cc.Count; j++)
        {
        Capture c = cc[j];
        System.Console.WriteLine(
          "Capture(" + j + ") = \"" + c + "\", Position = " + c.Index);
        }
      }
    }
      }
    }
  }

/*
This code example produces the following results:

Input string = "One fish two fish red fish blue fish"

Match(1)
Group(1) = "One"
Capture(0) = "One", Position = 0
Group(2) = "fish"
Capture(0) = "fish", Position = 4

Match(2)
Group(1) = "two"
Capture(0) = "two", Position = 9
Group(2) = "fish"
Capture(0) = "fish", Position = 13

Match(3)
Group(1) = "red"
Capture(0) = "red", Position = 18
Group(2) = "fish"
Capture(0) = "fish", Position = 22

Match(4)
Group(1) = "blue"
Capture(0) = "blue", Position = 27
Group(2) = "fish"
Capture(0) = "fish", Position = 32

*/

' This code example demonstrates the RegexCompilationInfo constructor.
' Execute this code example after executing genFishRegex.exe.
' compile: vbc /r:FishRegex.dll useFishRegex.vb

Imports System.Reflection
Imports System.Text.RegularExpressions

Class UseFishRegEx
    Public Shared Sub Main() 
        ' Match against the following target string.
        Dim targetString As String = "One fish two fish red fish blue fish"
        Dim matchCount As Integer = 0
        Dim f As New MyApp.FishRegex()
        
        ' Display the target string.
        Console.WriteLine(vbLf & "Input string = """ & targetString & """")
        
        ' Display each match, capture group, capture, and match position.
        Dim m As Match
        For Each m In f.Matches(targetString)
            matchCount = matchCount + 1
            Console.WriteLine(vbLf & "Match(" & matchCount & ")")

            Dim i As Integer
            For i = 1 to 2
                Dim g As Group = m.Groups(i)
                Console.WriteLine("Group(" & i & ") = """ & g.ToString() & """")
                Dim cc As CaptureCollection = g.Captures
                Dim j As Integer
                For j = 0 To cc.Count-1
                    Dim c As Capture = cc(j)
                    System.Console.WriteLine("Capture(" & j & ") = """ & c.ToString() & _
                                             """, Position = " & c.Index)
                Next j
            Next i
        Next m
    End Sub
End Class

'
'This code example produces the following results:
'
'Input string = "One fish two fish red fish blue fish"
'
'Match(1)
'Group(1) = "One"
'Capture(0) = "One", Position = 0
'Group(2) = "fish"
'Capture(0) = "fish", Position = 4
'
'Match(2)
'Group(1) = "two"
'Capture(0) = "two", Position = 9
'Group(2) = "fish"
'Capture(0) = "fish", Position = 13
'
'Match(3)
'Group(1) = "red"
'Capture(0) = "red", Position = 18
'Group(2) = "fish"
'Capture(0) = "fish", Position = 22
'
'Match(4)
'Group(1) = "blue"
'Capture(0) = "blue", Position = 27
'Group(2) = "fish"
'Capture(0) = "fish", Position = 32
'

Commenti

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

Il CompileToAssembly metodo genera un assembly contenente espressioni regolari compilate. Pertanto, non è consigliabile specificare Compiled come uno dei valori di options.

Se ispublic è true, la classe di espressioni regolari compilata viene data accessibilità pubblica. Vale a dire, può essere creata un'istanza dal codice che viene eseguito in qualsiasi assembly. Se ispublic è false, la classe di espressioni regolari compilata viene specificata internal (in C#) o Friend (in Visual Basic) accessibilità. Vale a dire, può essere creata un'istanza solo dal codice eseguito nello stesso assembly della classe di espressioni regolari.

Note per i chiamanti

Questo costruttore crea un'espressione regolare compilata che usa il valore di timeout predefinito del dominio applicazione in cui viene creato. Se viene definito un valore di timeout per il dominio dell'applicazione, l'espressione regolare compilata usa il valore InfiniteMatchTimeout, che impedisce il timeout di un'operazione di corrispondenza dei modelli. Il costruttore consigliato per la creazione di un'espressione regolare compilata è RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan), che consente di impostare l'intervallo di timeout.

Si applica a

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

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

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

public:
 RegexCompilationInfo(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, System::String ^ name, System::String ^ fullnamespace, bool ispublic, TimeSpan matchTimeout);

public RegexCompilationInfo (string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic, TimeSpan matchTimeout);

new System.Text.RegularExpressions.RegexCompilationInfo : string * System.Text.RegularExpressions.RegexOptions * string * string * bool * TimeSpan -> System.Text.RegularExpressions.RegexCompilationInfo

Public Sub New (pattern As String, options As RegexOptions, name As String, fullnamespace As String, ispublic As Boolean, matchTimeout As TimeSpan)

Parametri

pattern: String

Espressione regolare da compilare.

options: RegexOptions

Opzioni dell'espressione regolare da utilizzare per compilare l'espressione regolare.

name: String

Nome del tipo che rappresenta l'espressione regolare compilata.

fullnamespace: String

Spazio dei nomi al quale appartiene il nuovo tipo.

ispublic: Boolean

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

matchTimeout: TimeSpan

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

Eccezioni

ArgumentException

name è Empty.

ArgumentNullException

pattern è null.

-oppure-

name è null.

-oppure-

fullnamespace è null.

ArgumentOutOfRangeException

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

Esempio

Nell'esempio seguente viene definita una singola espressione regolare compilata denominata DuplicateChars che identifica due o più occorrenze dello stesso carattere in una stringa di input. L'espressione regolare compilata ha un timeout predefinito di 2 secondi. Quando si esegue l'esempio, crea una libreria di classi denominata RegexLib.dll contenente 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);
   }
}

Imports System.Reflection
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        ' Match two or more occurrences of the same character.
        Dim pattern As String = "(\w)\1+"
        
        ' Use case-insensitive matching. 
        Dim rci As New RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                            "DuplicateChars", "CustomRegexes", 
                                            True, TimeSpan.FromSeconds(2))

        ' Define an assembly to contain the compiled regular expression.
        Dim an As New AssemblyName()
        an.Name = "RegexLib"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }

        ' Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an)
   End Sub
End Module

Il criterio di ricerca di espressioni regolari (\w)\1+ è definito nel modo illustrato nella tabella seguente.

Modello	Descrizione
`(\w)`	Corrisponde a qualsiasi carattere di parola e assegnarlo al primo gruppo di acquisizione.
`\1+`	Corrisponde a una o più occorrenze del valore del primo gruppo acquisito.

Nell'esempio seguente viene usata l'espressione DuplicatedChars regolare per identificare i caratteri duplicati in una matrice di stringhe. Quando chiama il costruttore, modifica l'intervallo DuplicatedChars 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

Imports CustomRegexes
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim rgx As New DuplicateChars(TimeSpan.FromSeconds(.5))
      
      Dim values() As String = { "Greeeeeat", "seed", "deed", "beam", 
                                 "loop", "Aardvark" }
      ' Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx)
      Console.WriteLine("Regex timeout value: {0} seconds", 
                        rgx.MatchTimeout.TotalSeconds)
      Console.WriteLine()
      
      ' Display matching information.
      For Each value In values
         Dim m As Match = rgx.Match(value)
         If m.Success Then
            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)
         End If   
      Next                                                         
   End Sub
End Module
' 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

Commenti

Il CompileToAssembly metodo genera un assembly contenente espressioni regolari compilate. Pertanto, non è consigliabile specificare Compiled come uno dei valori di options.

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

Importante

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

Vedi anche

MatchTimeout

Si applica a

RegexCompilationInfo Costruttori

Definizione

Overload

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)

Parametri

Eccezioni

Esempio

Commenti

Note per i chiamanti

Si applica a

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

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive