RegexCompilationInfo Konstruktory

Definice

Inicializuje novou instanci RegexCompilationInfo třídy .

Přetížení

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

Inicializuje novou instanci třídy RegexCompilationInfo , která obsahuje informace o regulárním výrazu, který má být součástí sestavení.

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

Inicializuje novou instanci třídy , která obsahuje informace o regulárním výrazu se zadanou hodnotou časového limitu, která má být RegexCompilationInfo součástí sestavení.

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

Inicializuje novou instanci třídy RegexCompilationInfo , která obsahuje informace o regulárním výrazu, který má být součástí sestavení.

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)

Parametry

pattern
String

Regulární výraz, který se má zkompilovat.

options
RegexOptions

Možnosti regulárního výrazu, které se mají použít při kompilaci regulárního výrazu.

name
String

Název typu, který představuje zkompilovaný regulární výraz.

fullnamespace
String

Obor názvů, do kterého nový typ patří.

ispublic
Boolean

true , aby byl zkompilovaný regulární výraz veřejně viditelný; v opačném případě false .

Výjimky

pattern je null.

-nebo- name je null.

-nebo- fullnamespace je null.

Příklady

Následující příklad vytvoří a použije zkompilovaný regulární výraz ve dvou krocích.

V prvním kroku zkompilujte a spusťte následující příklad kódu. Konstruktor RegexCompilationInfo v příkladu kódu definuje zkompilovaný regulární výraz. Výsledkem spuštění kódu je sestavení s názvem FishRegex.dll, které obsahuje zkompilovaný typ regulárního výrazu s názvem 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

V druhém kroku zkompilujte následující příklad kódu pomocí odkazu na FishRegex.dll a pak spusťte výsledný spustitelný soubor. Spustitelný soubor odpovídá cílovému řetězci pomocí typu a zobrazuje shodu, skupinu, skupinu zachycení a pozici indexu shod v FishRegex cílovém řetězci.

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

Poznámky

Každý parametr RegexCompilationInfo(String, RegexOptions, String, String, Boolean) konstruktoru přímo odpovídá vlastnosti RegexCompilationInfo třídy. Vzhledem k tomu, že všechny vlastnosti jsou pro čtení a zápis, je možné jejich hodnoty přiřadit také přímo.

Metoda CompileToAssembly generuje sestavení, které obsahuje zkompilované regulární výrazy. Proto byste neměli zazadat Compiled jednu z hodnot options .

Pokud ispublic je true , zkompilovaná třída regulárních výrazů je dána veřejné přístupnosti. To znamená, že je možné vytvořit instanci z kódu, který se spustí v jakémkoli sestavení. Pokud ispublic je , je false zkompilovaná třída regulárních výrazů dána internal (v jazyce C#) Friend nebo (v Visual Basic) přístupnosti. To znamená, že je možné vytvořit instanci pouze z kódu, který se provádí ve stejném sestavení jako třída regulárního výrazu.

Poznámky pro volající

Tento konstruktor vytvoří zkompilovaný regulární výraz, který používá výchozí hodnotu časového limitu domény aplikace, ve které je vytvořen. Pokud je pro doménu aplikace definovaná hodnota časového limitu, zkompilovaný regulární výraz použije hodnotu , která brání časovému limitu operace porovnávání InfiniteMatchTimeout vzorů. Doporučený konstruktor pro vytvoření zkompilovaných regulárních výrazů je , který umožňuje nastavit interval RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan) časového limitu.

Platí pro

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

Inicializuje novou instanci třídy , která obsahuje informace o regulárním výrazu se zadanou hodnotou časového limitu, která má být RegexCompilationInfo součástí sestavení.

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)

Parametry

pattern
String

Regulární výraz, který se má zkompilovat.

options
RegexOptions

Možnosti regulárního výrazu, které se mají použít při kompilaci regulárního výrazu.

name
String

Název typu, který představuje zkompilovaný regulární výraz.

fullnamespace
String

Obor názvů, do kterého nový typ patří.

ispublic
Boolean

true , aby byl zkompilovaný regulární výraz veřejně viditelný; v opačném případě false .

matchTimeout
TimeSpan

Výchozí interval časového limitu regulárního výrazu.

Výjimky

pattern je null.

-nebo- name je null.

-nebo- fullnamespace je null.

matchTimeout je záporná, nula nebo větší než přibližně 24 dnů.

Příklady

Následující příklad definuje jeden zkompilovaný regulární výraz s názvem , který identifikuje dva nebo více výskytů stejného znaku ve DuplicateChars vstupním řetězci. Zkompilovaný regulární výraz má výchozí časový limit 2 sekund. Při spuštění příkladu se vytvoří knihovna tříd s názvem RegexLib.dll obsahující zkompilovaný regulární výraz.

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

Vzor regulárního (\w)\1+ výrazu je definován tak, jak je znázorněno v následující tabulce.

Vzor Popis
(\w) Porovná libovolný znak slova a přiřadí ho k první zachytávající skupině.
\1+ Porovná jeden nebo více výskytů hodnoty první zachycené skupiny.

Následující příklad používá regulární DuplicatedChars výraz k identifikaci duplicitních znaků v poli řetězců. Když volá DuplicatedChars konstruktor, změní interval časového limitu na 0,5 sekundy.

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

Poznámky

Každý parametr RegexCompilationInfo(String, RegexOptions, String, String, Boolean) konstruktoru přímo odpovídá vlastnosti RegexCompilationInfo třídy. Vzhledem k tomu, že všechny vlastnosti jsou pro čtení a zápis, je možné jejich hodnoty přiřadit také přímo.

Metoda CompileToAssembly generuje sestavení, které obsahuje zkompilované regulární výrazy. Proto byste neměli zazadat Compiled jednu z hodnot options .

Pokud ispublic je true , zkompilovaná třída regulárních výrazů je dána veřejné přístupnosti. To znamená, že je možné vytvořit instanci z kódu, který se spustí v jakémkoli sestavení. Pokud ispublic je , je false zkompilovaná třída regulárních výrazů dána internal (v jazyce C#) Friend nebo (v Visual Basic) přístupnosti. To znamená, že je možné vytvořit instanci pouze z kódu, který se provádí ve stejném sestavení jako třída regulárního výrazu.

Parametr matchTimeout definuje výchozí interval časového limitu pro zkompilovaný regulární výraz. Tato hodnota představuje přibližnou dobu, po kterou zkompilovaný objekt regulárního výrazu provede jednu odpovídající operaci před časovým limitem operace a modul regulárních výrazů vyvolá během příští kontroly RegexMatchTimeoutException časování výjimku. Další informace o hodnotě časového limitu najdete ve MatchTimeout vlastnosti .

Důležité

Doporučujeme vždy nastavit výchozí hodnotu časového limitu pro zkompilovaný regulární výraz. Spotřebiteli knihovny regulárních výrazů mohou tuto hodnotu časového limitu přepsat předáním hodnoty, která představuje nový interval časového TimeSpan limitu tomuto přetížení konstruktoru.

Viz také

Platí pro