RegexCompilationInfo Konstruktoren

Definition

Initialisiert eine neue Instanz der RegexCompilationInfo-Klasse.

Überlädt

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

Initialisiert eine neue Instanz der RegexCompilationInfo-Klasse, die Informationen zu einem regulären Ausdruck enthält, der in eine Assembly eingeschlossen werden soll.

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

Initialisiert eine neue Instanz der RegexCompilationInfo-Klasse, die Informationen zu einem regulären Ausdruck mit einem angegebenen Timeoutwert enthält, der in eine Assembly eingeschlossen werden soll.

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

Initialisiert eine neue Instanz der RegexCompilationInfo-Klasse, die Informationen zu einem regulären Ausdruck enthält, der in eine Assembly eingeschlossen werden soll.

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)

Parameter

pattern
String

Der reguläre Ausdruck, der kompiliert werden soll.

options
RegexOptions

Die bei der Kompilierung des regulären Ausdrucks zu verwendenden Optionen für reguläre Ausdrücke.

name
String

Der Name des Typs, der den kompilierten regulären Ausdruck darstellt.

fullnamespace
String

Der Namespace, zu dem der neue Typ gehört.

ispublic
Boolean

true, um den kompilierten regulären Ausdruck öffentlich sichtbar zu machen, andernfalls false.

Ausnahmen

pattern ist null.

- oder - name ist null.

- oder - fullnamespace ist null.

Beispiele

Im folgenden Beispiel wird ein kompilierter regulärer Ausdruck in zwei Schritten erstellt und verwendet.

Kompilieren Sie im ersten Schritt das folgende Codebeispiel, und führen Sie es aus. Der RegexCompilationInfo Konstruktor im Codebeispiel definiert einen kompilierten regulären Ausdruck. Das Ergebnis der Codeausführung ist eine Assembly mit dem Namen FishRegex.dll, die einen kompilierten Typ eines regulären Ausdrucks namens FishRegex enthält.

// 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

Kompilieren Sie im zweiten Schritt das folgende Codebeispiel mithilfe eines Verweises auf FishRegex.dll, und führen Sie dann die resultierende ausführbare Datei aus. Die ausführbare Datei stimmt mithilfe des -Typs mit einer Zielzeichenfolge überein und zeigt die Übereinstimmung, Gruppe, Erfassungsgruppe und Indexposition der Übereinstimmungen in der FishRegex Zielzeichenfolge an.

// 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
'

Hinweise

Jeder Parameter des RegexCompilationInfo(String, RegexOptions, String, String, Boolean) Konstruktors entspricht direkt einer Eigenschaft der RegexCompilationInfo -Klasse. Da alle Eigenschaften Lese-/Schreibzugriff haben, können ihre Werte auch direkt zugewiesen werden.

Die CompileToAssembly -Methode generiert eine Assembly, die kompilierte reguläre Ausdrücke enthält. Daher sollten Sie nicht Compiled als einen der Werte von options angeben.

Wenn ispublic true ist, erhält die kompilierte Klasse für reguläre Ausdrücke öffentlichen Zugriff. Das heißt, sie kann aus Code instanziiert werden, der in einer beliebigen Assembly ausgeführt wird. Wenn ispublic false ist, erhält die kompilierte Klasse für reguläre Ausdrücke internal (in C#) Friend oder (in Visual Basic) Zugriff. Das heißt, sie kann nur aus Code instanziiert werden, der in derselben Assembly wie die Klasse für reguläre Ausdrücke ausgeführt wird.

Hinweise für Aufrufer

Dieser Konstruktor erstellt einen kompilierten regulären Ausdruck, der den Standard-Time out-Wert der Anwendungsdomäne verwendet, in der er erstellt wird. Wenn ein Time out-Wert für die Anwendungsdomäne definiert ist, verwendet der kompilierte reguläre Ausdruck den Wert , der verhindert, dass bei einem Musterabgleichsvorgang ein InfiniteMatchTimeout Time out erfolgt. Der empfohlene Konstruktor zum Erstellen eines kompilierten regulären Ausdrucks ist , mit dem RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) Sie das Time out-Intervall festlegen können.

Gilt für

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

Initialisiert eine neue Instanz der RegexCompilationInfo-Klasse, die Informationen zu einem regulären Ausdruck mit einem angegebenen Timeoutwert enthält, der in eine Assembly eingeschlossen werden soll.

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)

Parameter

pattern
String

Der reguläre Ausdruck, der kompiliert werden soll.

options
RegexOptions

Die bei der Kompilierung des regulären Ausdrucks zu verwendenden Optionen für reguläre Ausdrücke.

name
String

Der Name des Typs, der den kompilierten regulären Ausdruck darstellt.

fullnamespace
String

Der Namespace, zu dem der neue Typ gehört.

ispublic
Boolean

true, um den kompilierten regulären Ausdruck öffentlich sichtbar zu machen, andernfalls false.

matchTimeout
TimeSpan

Das standardmäßige Timeoutintervall für den regulären Ausdruck.

Ausnahmen

pattern ist null.

- oder - name ist null.

- oder - fullnamespace ist null.

matchTimeout ist negativ, null oder größer als ca. 24 Tage.

Beispiele

Im folgenden Beispiel wird ein einzelner kompilierter regulärer Ausdruck namens definiert, der zwei oder mehr Vorkommen desselben DuplicateChars Zeichens in einer Eingabezeichenfolge identifiziert. Der kompilierte reguläre Ausdruck hat ein Standard-Time out von 2 Sekunden. Wenn Sie das Beispiel ausführen, wird eine Klassenbibliothek mit dem Namen RegexLib.dll erstellt, die den kompilierten regulären Ausdruck enthält.

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

Das Muster für reguläre Ausdrücke (\w)\1+ wird entsprechend der folgenden Tabelle definiert:

Muster BESCHREIBUNG
(\w) Übereinstimmung mit einem beliebigen Wortzeichen, und weisen Sie es der ersten Erfassungsgruppe zu.
\1+ Übereinstimmung mit mindestens einem Vorkommen des Werts der ersten erfassten Gruppe.

Im folgenden Beispiel wird der DuplicatedChars reguläre Ausdruck verwendet, um doppelte Zeichen in einem Zeichenfolgenarray zu identifizieren. Wenn der Konstruktor aufgerufen DuplicatedChars wird, ändert er das Time out-Intervall in 0,5 Sekunden.

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

Hinweise

Jeder Parameter des RegexCompilationInfo(String, RegexOptions, String, String, Boolean) Konstruktors entspricht direkt einer Eigenschaft der RegexCompilationInfo -Klasse. Da alle Eigenschaften Lese-/Schreibzugriff haben, können ihre Werte auch direkt zugewiesen werden.

Die CompileToAssembly -Methode generiert eine Assembly, die kompilierte reguläre Ausdrücke enthält. Daher sollten Sie nicht Compiled als einen der Werte von options angeben.

Wenn ispublic true ist, erhält die kompilierte Klasse für reguläre Ausdrücke öffentlichen Zugriff. Das heißt, sie kann aus Code instanziiert werden, der in einer beliebigen Assembly ausgeführt wird. Wenn ispublic false ist, erhält die kompilierte Klasse für reguläre Ausdrücke internal (in C#) Friend oder (in Visual Basic) Zugriff. Das heißt, sie kann nur aus Code instanziiert werden, der in derselben Assembly wie die Klasse für reguläre Ausdrücke ausgeführt wird.

Der matchTimeout -Parameter definiert das Standard-Time out-Intervall für den kompilierten regulären Ausdruck. Dieser Wert stellt die ungefähre Zeitdauer dar, die ein kompiliertes Objekt für reguläre Ausdrücke vor dem Time out des Vorgangs ausführen wird und die Engine für reguläre Ausdrücke bei der nächsten Überprüfung der Zeitlichkeit eine Ausnahme RegexMatchTimeoutException auslöst. Weitere Informationen zum Time out-Wert finden Sie in der MatchTimeout -Eigenschaft.

Wichtig

Es wird empfohlen, immer einen Standard-Time out-Wert für einen kompilierten regulären Ausdruck festlegen. Benutzer Ihrer Bibliothek für reguläre Ausdrücke können diesen Time out-Wert überschreiben, indem sie einen Wert übergeben, der das neue Time out-Intervall an TimeSpan diese Konstruktorüberladung darstellt.

Siehe auch

Gilt für