RegexCompilationInfo Constructores

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Inicializa una nueva instancia de la clase RegexCompilationInfo.

Sobrecargas

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)	Inicializa una nueva instancia de la clase RegexCompilationInfo que contiene información sobre una expresión regular que se va a incluir en un ensamblado.
RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)	Inicializa una nueva instancia de la clase RegexCompilationInfo que contiene información sobre una expresión regular con un valor de tiempo de espera especificado que se va a incluir en un ensamblado.

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

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Inicializa una nueva instancia de la clase RegexCompilationInfo que contiene información sobre una expresión regular que se va a incluir en un ensamblado.

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)

Parámetros

pattern: String

Expresión regular que se va a compilar.

options: RegexOptions

Opciones de la expresión regular que se van a usar al compilar la expresión regular.

name: String

Nombre del tipo que representa la expresión regular compilada.

fullnamespace: String

Espacio de nombres al que pertenece el nuevo tipo.

ispublic: Boolean

true para hacer públicamente visible la expresión regular compilada; en caso contrario, false.

Excepciones

ArgumentException

name es Empty.

ArgumentNullException

pattern es null.

o bien

name es null.

o bien

fullnamespace es null.

Ejemplos

En el ejemplo siguiente se crea y se usa una expresión regular compilada en dos pasos.

En el primer paso, compile y ejecute el siguiente ejemplo de código. El RegexCompilationInfo constructor del ejemplo de código define una expresión regular compilada. El resultado de ejecutar el código es un ensamblado denominado FishRegex.dll que contiene un tipo de expresión regular compilado denominado 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

En el segundo paso, compile el ejemplo de código siguiente con una referencia a FishRegex.dll y, a continuación, ejecute el archivo ejecutable resultante. El archivo ejecutable coincide con una cadena de destino mediante el FishRegex tipo y muestra la coincidencia, el grupo, el grupo de captura y la posición de índice de las coincidencias en la cadena de destino.

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

Comentarios

Cada parámetro del RegexCompilationInfo(String, RegexOptions, String, String, Boolean) constructor corresponde directamente a una propiedad de la RegexCompilationInfo clase . Dado que todas las propiedades son de lectura y escritura, sus valores también se pueden asignar directamente.

El CompileToAssembly método genera un ensamblado que contiene expresiones regulares compiladas. Por lo tanto, no debe especificar Compiled como uno de los valores de options.

Si ispublic es true, la clase de expresión regular compilada recibe accesibilidad pública. Es decir, se puede crear una instancia del código que se ejecuta en cualquier ensamblado. Si ispublic es false, la clase de expresión regular compilada se da internal (en C#) o Friend (en Visual Basic) accesibilidad. Es decir, solo se puede crear una instancia desde el código que se ejecuta en el mismo ensamblado que la clase de expresión regular.

Notas a los autores de las llamadas

Este constructor crea una expresión regular compilada que usa el valor de tiempo de espera predeterminado del dominio de aplicación en el que se crea. Si se define un valor de tiempo de espera para el dominio de aplicación, la expresión regular compilada usa el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera de una operación de coincidencia de patrones. El constructor recomendado para crear una expresión regular compilada es RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Se aplica a

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

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Inicializa una nueva instancia de la clase RegexCompilationInfo que contiene información sobre una expresión regular con un valor de tiempo de espera especificado que se va a incluir en un ensamblado.

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)

Parámetros

pattern: String

Expresión regular que se va a compilar.

options: RegexOptions

Opciones de la expresión regular que se van a usar al compilar la expresión regular.

name: String

Nombre del tipo que representa la expresión regular compilada.

fullnamespace: String

Espacio de nombres al que pertenece el nuevo tipo.

ispublic: Boolean

true para hacer públicamente visible la expresión regular compilada; en caso contrario, false.

matchTimeout: TimeSpan

Intervalo de tiempo de espera predeterminado para la expresión regular.

Excepciones

ArgumentException

name es Empty.

ArgumentNullException

pattern es null.

o bien

name es null.

o bien

fullnamespace es null.

ArgumentOutOfRangeException

matchTimeout es negativo, cero o mayor que 24 días aproximadamente.

Ejemplos

En el ejemplo siguiente se define una única expresión regular compilada denominada DuplicateChars que identifica dos o más apariciones del mismo carácter en una cadena de entrada. La expresión regular compilada tiene un tiempo de espera predeterminado de 2 segundos. Al ejecutar el ejemplo, crea una biblioteca de clases denominada RegexLib.dll que contiene la expresión regular compilada.

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

El patrón de expresión regular (\w)\1+ se define como se muestra en la tabla siguiente.

Modelo	Descripción
`(\w)`	Coincide con cualquier carácter de palabra y asígnelo al primer grupo de captura.
`\1+`	Coincide con una o varias repeticiones del valor del primer grupo capturado.

En el ejemplo siguiente se usa la DuplicatedChars expresión regular para identificar caracteres duplicados en una matriz de cadenas. Cuando llama al DuplicatedChars constructor, cambia el intervalo de tiempo de espera a .5 segundos.

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

Comentarios

El CompileToAssembly método genera un ensamblado que contiene expresiones regulares compiladas. Por lo tanto, no debe especificar Compiled como uno de los valores de options.

El matchTimeout parámetro define el intervalo de tiempo de espera predeterminado para la expresión regular compilada. Este valor representa la cantidad aproximada de tiempo que un objeto de expresión regular compilada ejecutará una sola operación coincidente antes de que se agote el tiempo de espera de la operación y el motor de expresiones regulares produzca una RegexMatchTimeoutException excepción durante su siguiente comprobación de tiempo. Para obtener información adicional sobre el valor de tiempo de espera, vea la MatchTimeout propiedad .

Importante

Se recomienda establecer siempre un valor de tiempo de espera predeterminado para una expresión regular compilada. Los consumidores de la biblioteca de expresiones regulares pueden invalidar ese valor de tiempo de espera pasando un TimeSpan valor que representa el nuevo intervalo de tiempo de espera a esta sobrecarga del constructor.

Consulte también

MatchTimeout

Se aplica a

Compartir a través de

RegexCompilationInfo Constructores

Definición

Sobrecargas

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

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Se aplica a

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

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales