Regex.CompileToAssembly Método

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.

Compila expressões regulares e as salva em disco em um único assembly.

Sobrecargas

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)	Obsoleto. Compila um ou mais objetos Regex especificados e um arquivo de recurso especificado em um assembly nomeado com os atributos especificados.
CompileToAssembly(RegexCompilationInfo[], AssemblyName)	Obsoleto. Compila um ou mais objetos Regex especificados em um assembly nomeado.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])	Obsoleto. Compila um ou mais objetos Regex especificados em um assembly nomeado com os atributos especificados.

Comentários

Nota

No .NET Core e no .NET 5+, as chamadas para o método Regex.CompileToAssembly lançam um PlatformNotSupportedException. Não há suporte para gravar um assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

Cuidado

Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.

Compila um ou mais objetos Regex especificados e um arquivo de recurso especificado em um assembly nomeado com os atributos especificados.

public:
 static void CompileToAssembly(cli::array <System::Text::RegularExpressions::RegexCompilationInfo ^> ^ regexinfos, System::Reflection::AssemblyName ^ assemblyname, cli::array <System::Reflection::Emit::CustomAttributeBuilder ^> ^ attributes, System::String ^ resourceFile);

public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes, string? resourceFile);

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes, string? resourceFile);

public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[] attributes, string resourceFile);

static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] * string -> unit

[<System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] * string -> unit

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName, attributes As CustomAttributeBuilder(), resourceFile As String)

Parâmetros

regexinfos: RegexCompilationInfo[]

Uma matriz que descreve as expressões regulares a serem compiladas.

assemblyname: AssemblyName

O nome do arquivo do assembly.

attributes: CustomAttributeBuilder[]

Uma matriz que define os atributos a serem aplicados ao assembly.

resourceFile: String

O nome do arquivo de recurso Win32 a ser incluído no assembly.

Atributos: ObsoleteAttribute

Exceções

ArgumentException

O valor da propriedade Name do parâmetro assemblyname é uma cadeia de caracteres vazia ou nula.

-ou-

O padrão de expressão regular de um ou mais objetos em regexinfos contém sintaxe inválida.

ArgumentNullException

assemblyname ou regexinfos é null.

COMException

O parâmetro resourceFile designa um arquivo de recurso Win32 inválido.

FileNotFoundException

O arquivo designado pelo parâmetro resourceFile não pode ser encontrado.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: não há suporte para a criação de um assembly de expressões regulares compiladas.

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) gera um assembly do .NET Framework no qual cada expressão regular definida na matriz regexinfos é representada por uma classe. Normalmente, o método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) é chamado de um aplicativo separado que gera um assembly de expressões regulares compiladas. Cada expressão regular incluída no assembly tem as seguintes características:

Ela é derivada da classe Regex.
Ele recebe o nome totalmente qualificado definido pelos parâmetros fullnamespace e name de seu objeto RegexCompilationInfo correspondente.
Ele tem um construtor padrão (ou sem parâmetros).

Normalmente, o código que cria uma instância e usa a expressão regular compilada é encontrado em um assembly ou aplicativo separado do código que cria o assembly.

Como o método CompileToAssembly gera um assembly do .NET Framework de uma chamada de método em vez de usar uma palavra-chave de definição de classe de um idioma específico (como class em C# ou Class...End Class no Visual Basic), ele não permite que atributos do .NET Framework sejam atribuídos ao assembly usando a sintaxe de atributo padrão da linguagem de desenvolvimento. O parâmetro attributes fornece um método alternativo para definir os atributos que se aplicam ao assembly. Para cada atributo que você deseja aplicar ao assembly, faça o seguinte:

Crie uma matriz de objetos Type que representam os tipos de parâmetro do construtor de atributo que você deseja chamar.
Recupere um objeto Type que representa a classe de atributo que você deseja aplicar ao novo assembly.
Chame o método GetConstructor do objeto Type de atributo para recuperar um objeto ConstructorInfo que representa o construtor de atributo que você deseja chamar. Passe o método GetConstructor a matriz de objetos Type que representa os tipos de parâmetro do construtor
Crie uma matriz de Object que define os parâmetros a serem passados para o construtor do atributo.
Instancie um objeto CustomAttributeBuilder passando ao construtor o objeto ConstructorInfo recuperado na etapa 3 e a matriz Object criada na etapa 4.

Em seguida, você pode passar uma matriz desses objetos CustomAttributeBuilder em vez do parâmetro attributes para o método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String).

Notas aos Chamadores

Se você estiver desenvolvendo em um sistema que tenha o .NET Framework 4.5 ou suas versões de ponto instaladas, você terá como destino o .NET Framework 4 e usará o método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly em um sistema que tem o .NET Framework 4 gera uma exceção. Para contornar esse problema, você pode fazer qualquer um dos seguintes procedimentos:

Crie o assembly que contém as expressões regulares compiladas em um sistema que tenha o .NET Framework 4 em vez de versões posteriores instaladas.
Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada de um assembly, use métodos estáticos ou de instância Regex com a opção Compiled ao criar uma instância de um objeto Regex ou chamar um método de correspondência de padrão de expressão regular.

Confira também

compilação e reutilização

Aplica-se a

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

Cuidado

Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.

Compila um ou mais objetos Regex especificados em um assembly nomeado.

public:
 static void CompileToAssembly(cli::array <System::Text::RegularExpressions::RegexCompilationInfo ^> ^ regexinfos, System::Reflection::AssemblyName ^ assemblyname);

public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname);

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname);

static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName -> unit

[<System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName -> unit

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName)

Parâmetros

regexinfos: RegexCompilationInfo[]

Uma matriz que descreve as expressões regulares a serem compiladas.

assemblyname: AssemblyName

O nome do arquivo do assembly.

Atributos: ObsoleteAttribute

Exceções

ArgumentException

O valor da propriedade Name do parâmetro assemblyname é uma cadeia de caracteres vazia ou nula.

-ou-

O padrão de expressão regular de um ou mais objetos em regexinfos contém sintaxe inválida.

ArgumentNullException

assemblyname ou regexinfos é null.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: não há suporte para a criação de um assembly de expressões regulares compiladas.

Exemplos

O exemplo a seguir cria um assembly chamado RegexLib.dll. O assembly inclui duas expressões regulares compiladas. A primeira, Utilities.RegularExpressions.DuplicatedString, corresponde a duas palavras contíguas idênticas. O segundo, Utilities.RegularExpressions.EmailAddress, verifica se uma cadeia de caracteres tem o formato correto para ser um endereço de email.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text.RegularExpressions;

public class RegexCompilationTest
{
   public static void Main()
   {
      RegexCompilationInfo expr;
      List<RegexCompilationInfo> compilationList = new List<RegexCompilationInfo>();

      // Define regular expression to detect duplicate words
      expr = new RegexCompilationInfo(@"\b(?<word>\w+)\s+(\k<word>)\b", 
                 RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, 
                 "DuplicatedString", 
                 "Utilities.RegularExpressions", 
                 true);
      // Add info object to list of objects
      compilationList.Add(expr);

      // Define regular expression to validate format of email address
      expr = new RegexCompilationInfo(@"^(?("")(""[^""]+?""@)|(([0-9A-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9A-Z])@))" + 
                 @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9A-Z][-\w]*[0-9A-Z]\.)+[A-Z]{2,6}))$", 
                 RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, 
                 "EmailAddress", 
                 "Utilities.RegularExpressions", 
                 true);
      // Add info object to list of objects
      compilationList.Add(expr);
                                             
      // Generate assembly with compiled regular expressions
      RegexCompilationInfo[] compilationArray = new RegexCompilationInfo[compilationList.Count];
      AssemblyName assemName = new AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null");
      compilationList.CopyTo(compilationArray); 
      Regex.CompileToAssembly(compilationArray, assemName);                                                 
   }
}

Imports System.Collections.Generic
Imports System.Reflection
Imports System.Text.RegularExpressions

Module RegexCompilationTest
   Public Sub Main()
      Dim expr As RegexCompilationInfo
      Dim compilationList As New List(Of RegexCompilationInfo)
          
      ' Define regular expression to detect duplicate words
      expr = New RegexCompilationInfo("\b(?<word>\w+)\s+(\k<word>)\b", _
                 RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant, _
                 "DuplicatedString", _
                 "Utilities.RegularExpressions", _
                 True)
      ' Add info object to list of objects
      compilationList.Add(expr)

      ' Define regular expression to validate format of email address
      expr = New RegexCompilationInfo("^(?("")(""[^""]+?""@)|(([0-9A-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9A-Z])@))" + _
                 "(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9A-Z][-\w]*[0-9A-Z]\.)+[A-Z]{2,6}))$", _
                 RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant, _
                 "EmailAddress", _
                 "Utilities.RegularExpressions", _
                 True)
      ' Add info object to list of objects
      compilationList.Add(expr)
                                             
      ' Generate assembly with compiled regular expressions
      Dim compilationArray(compilationList.Count - 1) As RegexCompilationInfo
      Dim assemName As New AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null")
      compilationList.CopyTo(compilationArray) 
      Regex.CompileToAssembly(compilationArray, assemName)                                                 
   End Sub
End Module

A expressão regular que verifica uma cadeia de caracteres para palavras duplicadas é então instanciada e usada pelo exemplo a seguir.

using System;
using Utilities.RegularExpressions;

public class CompiledRegexUsage
{
   public static void Main()
   {
      string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
      DuplicatedString duplicateRegex = new DuplicatedString(); 
      if (duplicateRegex.Matches(text).Count > 0)
         Console.WriteLine("There are {0} duplicate words in \n   '{1}'", 
            duplicateRegex.Matches(text).Count, text);
      else
         Console.WriteLine("There are no duplicate words in \n   '{0}'", 
                           text);
   }
}
// The example displays the following output to the console:
//    There are 3 duplicate words in
//       'The the quick brown fox  fox jumps over the lazy dog dog.'

Imports Utilities.RegularExpressions

Module CompiledRegexUsage
   Public Sub Main()
      Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
      Dim duplicateRegex As New DuplicatedString()
      If duplicateRegex.Matches(text).Count > 0 Then
         Console.WriteLine("There are {0} duplicate words in {2}   '{1}'", _
            duplicateRegex.Matches(text).Count, text, vbCrLf)
      Else
         Console.WriteLine("There are no duplicate words in {1}   '{0}'", _
                           text, vbCrLf)
      End If
   End Sub
End Module
' The example displays the following output to the console:
'    There are 3 duplicate words in
'       'The the quick brown fox  fox jumps over the lazy dog dog.'

A compilação bem-sucedida deste segundo exemplo requer uma referência a RegexLib.dll (o assembly criado pelo primeiro exemplo) para ser adicionado ao projeto.

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName) gera um assembly do .NET Framework no qual cada expressão regular definida na matriz regexinfos é representada por uma classe. Normalmente, o método CompileToAssembly(RegexCompilationInfo[], AssemblyName) é chamado de um aplicativo separado que gera um assembly de expressões regulares compiladas. Cada expressão regular incluída no assembly tem as seguintes características:

Ela é derivada da classe Regex.
Ele recebe o nome totalmente qualificado definido pelos parâmetros fullnamespace e name de seu objeto RegexCompilationInfo correspondente.
Ele tem um construtor padrão (ou sem parâmetros).

Normalmente, o código que cria uma instância e usa a expressão regular compilada é encontrado em um assembly ou aplicativo separado do código que cria o assembly.

Notas aos Chamadores

Crie o assembly que contém as expressões regulares compiladas em um sistema que tenha o .NET Framework 4 em vez de versões posteriores instaladas.
Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada de um assembly, use métodos estáticos ou de instância Regex com a opção Compiled ao criar uma instância de um objeto Regex ou chamar um método de correspondência de padrão de expressão regular.

Confira também

compilação e reutilização

Aplica-se a

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Origem:: Regex.cs

Origem:: Regex.cs

Origem:: Regex.cs

Cuidado

Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.

Compila um ou mais objetos Regex especificados em um assembly nomeado com os atributos especificados.

public:
 static void CompileToAssembly(cli::array <System::Text::RegularExpressions::RegexCompilationInfo ^> ^ regexinfos, System::Reflection::AssemblyName ^ assemblyname, cli::array <System::Reflection::Emit::CustomAttributeBuilder ^> ^ attributes);

public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes);

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes);

public static void CompileToAssembly (System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[] attributes);

static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] -> unit

[<System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.", DiagnosticId="SYSLIB0036", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] -> unit

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName, attributes As CustomAttributeBuilder())

Parâmetros

regexinfos: RegexCompilationInfo[]

Uma matriz que descreve as expressões regulares a serem compiladas.

assemblyname: AssemblyName

O nome do arquivo do assembly.

attributes: CustomAttributeBuilder[]

Uma matriz que define os atributos a serem aplicados ao assembly.

Atributos: ObsoleteAttribute

Exceções

ArgumentException

O valor da propriedade Name do parâmetro assemblyname é uma cadeia de caracteres vazia ou nula.

-ou-

O padrão de expressão regular de um ou mais objetos em regexinfos contém sintaxe inválida.

ArgumentNullException

assemblyname ou regexinfos é null.

PlatformNotSupportedException

Somente .NET Core e .NET 5+: não há suporte para a criação de um assembly de expressões regulares compiladas.

Exemplos

O exemplo a seguir cria um assembly chamado RegexLib.dll e aplica o atributo AssemblyTitleAttribute a ele. O assembly inclui duas expressões regulares compiladas. A primeira, Utilities.RegularExpressions.DuplicatedString, corresponde a duas palavras contíguas idênticas. O segundo, Utilities.RegularExpressions.EmailAddress, verifica se uma cadeia de caracteres tem o formato correto para ser um endereço de email.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Text.RegularExpressions;

public class RegexCompilationTest
{
   public static void Main()
   {
      RegexCompilationInfo expr;
      List<RegexCompilationInfo> compilationList = new List<RegexCompilationInfo>();

      // Define regular expression to detect duplicate words
      expr = new RegexCompilationInfo(@"\b(?<word>\w+)\s+(\k<word>)\b", 
                 RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, 
                 "DuplicatedString", 
                 "Utilities.RegularExpressions", 
                 true);
      // Add info object to list of objects
      compilationList.Add(expr);

      // Define regular expression to validate format of email address
      expr = new RegexCompilationInfo(@"^(?("")(""[^""]+?""@)|(([0-9A-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9A-Z])@))" + 
                 @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9A-Z][-\w]*[0-9A-Z]\.)+[zA-Z]{2,6}))$", 
                 RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, 
                 "EmailAddress", 
                 "Utilities.RegularExpressions", 
                 true);
      // Add info object to list of objects
      compilationList.Add(expr);
                                             
      // Apply AssemblyTitle attribute to the new assembly
      //
      // Define the parameter(s) of the AssemblyTitle attribute's constructor 
      Type[] parameters = { typeof(string) };
      // Define the assembly's title
      object[] paramValues = { "General-purpose library of compiled regular expressions" };
      // Get the ConstructorInfo object representing the attribute's constructor
      ConstructorInfo ctor = typeof(System.Reflection.AssemblyTitleAttribute).GetConstructor(parameters);
      // Create the CustomAttributeBuilder object array
      CustomAttributeBuilder[] attBuilder = { new CustomAttributeBuilder(ctor, paramValues) }; 
                                                         
      // Generate assembly with compiled regular expressions
      RegexCompilationInfo[] compilationArray = new RegexCompilationInfo[compilationList.Count];
      AssemblyName assemName = new AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null");
      compilationList.CopyTo(compilationArray); 
      Regex.CompileToAssembly(compilationArray, assemName, attBuilder);                                                 
   }
}

Imports System.Collections.Generic
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Text.RegularExpressions

Module RegexCompilationTest
   Public Sub Main()
      Dim expr As RegexCompilationInfo
      Dim compilationList As New List(Of RegexCompilationInfo)
          
      ' Define regular expression to detect duplicate words
      expr = New RegexCompilationInfo("\b(?<word>\w+)\s+(\k<word>)\b", _
                 RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant, _
                 "DuplicatedString", _
                 "Utilities.RegularExpressions", _
                 True)
      ' Add info object to list of objects
      compilationList.Add(expr)

      ' Define regular expression to validate format of email address
      expr = New RegexCompilationInfo("^(?("")(""[^""]+?""@)|(([0-9A-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9A-Z])@))" + _ 
                 "(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9A-Z][-\w]*[0-9A-Z]\.)+[A-Z]{2,6}))$", _
                 RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant, _
                 "EmailAddress", _
                 "Utilities.RegularExpressions", _
                 True)
      ' Add info object to list of objects
      compilationList.Add(expr)

      ' Apply AssemblyTitle attribute to the new assembly
      '
      ' Define the parameter(s) of the AssemblyTitle attribute's constructor 
      Dim params() As Type = { GetType(String) }
      ' Define the assembly's title
      Dim paramValues() As Object = { "General-purpose library of compiled regular expressions" }
      ' Get the ConstructorInfo object representing the attribute's constructor
      Dim ctor As ConstructorInfo = GetType(System.Reflection.AssemblyTitleAttribute).GetConstructor(params)
      ' Create the CustomAttributeBuilder object array
      Dim attBuilder() As CustomAttributeBuilder = { New CustomAttributeBuilder(ctor, paramValues) } 
                                                         
      ' Generate assembly with compiled regular expressions
      Dim compilationArray(compilationList.Count - 1) As RegexCompilationInfo
      Dim assemName As New AssemblyName("RegexLib, Version=1.0.0.1001, Culture=neutral, PublicKeyToken=null")
      compilationList.CopyTo(compilationArray) 
      Regex.CompileToAssembly(compilationArray, assemName, attBuilder) 
   End Sub
End Module

Você pode verificar se o atributo AssemblyTitleAttribute foi aplicado ao assembly examinando seu manifesto com um utilitário de reflexão, como ILDasm.

A expressão regular que verifica uma cadeia de caracteres para palavras duplicadas é então instanciada e usada pelo exemplo a seguir.

using System;
using Utilities.RegularExpressions;

public class CompiledRegexUsage
{
   public static void Main()
   {
      string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
      DuplicatedString duplicateRegex = new DuplicatedString(); 
      if (duplicateRegex.Matches(text).Count > 0)
         Console.WriteLine("There are {0} duplicate words in \n   '{1}'", 
            duplicateRegex.Matches(text).Count, text);
      else
         Console.WriteLine("There are no duplicate words in \n   '{0}'", 
                           text);
   }
}
// The example displays the following output to the console:
//    There are 3 duplicate words in
//       'The the quick brown fox  fox jumps over the lazy dog dog.'

Imports Utilities.RegularExpressions

Module CompiledRegexUsage
   Public Sub Main()
      Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
      Dim duplicateRegex As New DuplicatedString()
      If duplicateRegex.Matches(text).Count > 0 Then
         Console.WriteLine("There are {0} duplicate words in {2}   '{1}'", _
            duplicateRegex.Matches(text).Count, text, vbCrLf)
      Else
         Console.WriteLine("There are no duplicate words in {1}   '{0}'", _
                           text, vbCrLf)
      End If
   End Sub
End Module
' The example displays the following output to the console:
'    There are 3 duplicate words in
'       'The the quick brown fox  fox jumps over the lazy dog dog.'

A compilação bem-sucedida deste segundo exemplo requer uma referência a RegexLib.dll (o assembly criado pelo primeiro exemplo) para ser adicionado ao projeto.

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) gera um assembly do .NET Framework no qual cada expressão regular definida na matriz regexinfos é representada por uma classe. Normalmente, o método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) é chamado de um aplicativo separado que gera um assembly de expressões regulares compiladas. Cada expressão regular incluída no assembly tem as seguintes características:

Ela é derivada da classe Regex.
Ele recebe o nome totalmente qualificado definido pelos parâmetros fullnamespace e name de seu objeto RegexCompilationInfo correspondente.
Ele tem um construtor padrão (ou sem parâmetros).

Normalmente, o código que cria uma instância e usa a expressão regular compilada é encontrado em um assembly ou aplicativo separado do código que cria o assembly.

Crie uma matriz de objetos Type que representam os tipos de parâmetro do construtor de atributo que você deseja chamar.
Recupere um objeto Type que representa a classe de atributo que você deseja aplicar ao novo assembly.
Chame o método GetConstructor do objeto Type de atributo para recuperar um objeto ConstructorInfo que representa o construtor de atributo que você deseja chamar. Passe o método GetConstructor a matriz de objetos Type que representa os tipos de parâmetro do construtor.
Crie uma matriz de Object que define os parâmetros a serem passados para o construtor do atributo.
Instancie um objeto CustomAttributeBuilder passando ao construtor o objeto ConstructorInfo recuperado na etapa 3 e a matriz Object criada na etapa 4.

Em seguida, você pode passar uma matriz desses objetos CustomAttributeBuilder em vez do parâmetro attributes para o método Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]).

Notas aos Chamadores

Crie o assembly que contém as expressões regulares compiladas em um sistema que tenha o .NET Framework 4 em vez de versões posteriores instaladas.
Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada de um assembly, use métodos estáticos ou de instância Regex com a opção Compiled ao criar uma instância de um objeto Regex ou chamar um método de correspondência de padrão de expressão regular.

Confira também

compilação e reutilização

Aplica-se a

Compartilhar via

Regex.CompileToAssembly Método

Definição

Sobrecargas

Comentários

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Parâmetros

Exceções

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Recursos adicionais