RegexCompilationInfo Construtores

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicializa uma nova instância da classe RegexCompilationInfo.

Sobrecargas

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)	Inicializa uma nova instância da classe RegexCompilationInfo que contém informações sobre uma expressão regular a ser incluída em um assembly.
RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)	Inicializa uma nova instância da classe RegexCompilationInfo que contém informações sobre uma expressão regular com um valor de tempo limite especificado a ser incluído em um assembly.

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

Origem:: RegexCompilationInfo.cs

Origem:: RegexCompilationInfo.cs

Origem:: RegexCompilationInfo.cs

Inicializa uma nova instância da classe RegexCompilationInfo que contém informações sobre uma expressão regular a ser incluída em um 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)

Parâmetros

pattern: String

A expressão regular a ser compilada.

options: RegexOptions

As opções de expressão regular a serem usadas ao compilar a expressão regular.

name: String

O nome do tipo que representa a expressão regular compilada.

fullnamespace: String

O namespace ao qual o novo tipo pertence.

ispublic: Boolean

true para tornar a expressão regular compilada publicamente visível; caso contrário, false.

Exceções

ArgumentException

name é Empty.

ArgumentNullException

pattern é null.

- ou -

name é null.

- ou -

fullnamespace é null.

Exemplos

O exemplo a seguir cria e usa uma expressão regular compilada em duas etapas.

Na primeira etapa, compile e execute o exemplo de código a seguir. O RegexCompilationInfo construtor no exemplo de código define uma expressão regular compilada. O resultado da execução do código é um assembly chamado FishRegex.dll que contém um tipo de expressão regular compilado chamado 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

Na segunda etapa, compile o exemplo de código a seguir usando uma referência para FishRegex.dll e execute o arquivo executável resultante. O arquivo executável corresponde a uma cadeia de caracteres de destino usando o FishRegex tipo e exibe a correspondência, o grupo, o grupo de captura e a posição de índice das correspondências na cadeia de caracteres 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
'

Comentários

Cada parâmetro do RegexCompilationInfo(String, RegexOptions, String, String, Boolean) construtor corresponde diretamente a uma propriedade da RegexCompilationInfo classe . Como todas as propriedades são de leitura/gravação, seus valores também podem ser atribuídos diretamente.

O CompileToAssembly método gera um assembly que contém expressões regulares compiladas. Portanto, você não deve especificar Compiled como um dos valores de options.

Se ispublic for true, a classe de expressão regular compilada recebe acessibilidade pública. Ou seja, ele pode ser instanciado do código que é executado em qualquer assembly. Se ispublic for false, a classe de expressão regular compilada será fornecida internal (em C#) ou Friend (no Visual Basic) acessibilidade. Ou seja, ele só pode ser instanciado do código que é executado no mesmo assembly que a classe de expressão regular.

Notas aos Chamadores

Esse construtor cria uma expressão regular compilada que usa o valor de tempo limite padrão do domínio do aplicativo no qual ele é criado. Se um valor de tempo limite for definido para o domínio do aplicativo, a expressão regular compilada usará o valor InfiniteMatchTimeout, o que impede que uma operação de correspondência de padrões atinja o tempo limite. O construtor recomendado para criar uma expressão regular compilada é RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan), que permite definir o intervalo de tempo limite.

Aplica-se a

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

Origem:: RegexCompilationInfo.cs

Origem:: RegexCompilationInfo.cs

Origem:: RegexCompilationInfo.cs

Inicializa uma nova instância da classe RegexCompilationInfo que contém informações sobre uma expressão regular com um valor de tempo limite especificado a ser incluído em um 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)

Parâmetros

pattern: String

A expressão regular a ser compilada.

options: RegexOptions

As opções de expressão regular a serem usadas ao compilar a expressão regular.

name: String

O nome do tipo que representa a expressão regular compilada.

fullnamespace: String

O namespace ao qual o novo tipo pertence.

ispublic: Boolean

true para tornar a expressão regular compilada publicamente visível; caso contrário, false.

matchTimeout: TimeSpan

O intervalo de tempo limite padrão para a expressão regular.

Exceções

ArgumentException

name é Empty.

ArgumentNullException

pattern é null.

- ou -

name é null.

- ou -

fullnamespace é null.

ArgumentOutOfRangeException

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

Exemplos

O exemplo a seguir define uma única expressão regular compilada chamada DuplicateChars que identifica duas ou mais ocorrências do mesmo caractere em uma cadeia de caracteres de entrada. A expressão regular compilada tem um tempo limite padrão de 2 segundos. Quando você executa o exemplo, ele cria uma biblioteca de classes chamada RegexLib.dll que contém a expressão 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

O padrão de expressão regular (\w)\1+ é definido conforme mostrado na tabela a seguir.

Padrão	Descrição
`(\w)`	Corresponda a qualquer caractere de palavra e atribua-o ao primeiro grupo de captura.
`\1+`	Corresponde a uma ou mais ocorrências do valor do primeiro grupo capturado.

O exemplo a seguir usa a DuplicatedChars expressão regular para identificar caracteres duplicados em uma matriz de cadeia de caracteres. Quando ele chama o DuplicatedChars construtor, ele altera o intervalo de tempo limite para 0,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

Comentários

O CompileToAssembly método gera um assembly que contém expressões regulares compiladas. Portanto, você não deve especificar Compiled como um dos valores de options.

O matchTimeout parâmetro define o intervalo de tempo limite padrão para a expressão regular compilada. Esse valor representa a quantidade aproximada de tempo que um objeto de expressão regular compilado executará uma única operação de correspondência antes que a operação atinja o tempo limite e o mecanismo de expressão regular gere uma RegexMatchTimeoutException exceção durante seu próximo intervalo marcar. Para obter informações adicionais sobre o valor de tempo limite, consulte a MatchTimeout propriedade .

Importante

Recomendamos que você sempre defina um valor de tempo limite padrão para uma expressão regular compilada. Os consumidores da biblioteca de expressões regulares podem substituir esse valor de tempo limite passando um TimeSpan valor que representa o novo intervalo de tempo limite para essa sobrecarga do construtor.

Confira também

MatchTimeout

Aplica-se a

Partilhar via

RegexCompilationInfo Construtores

Definição

Sobrecargas

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

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Aplica-se a

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

Parâmetros

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais