Regex.CompileToAssembly Método

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í.

Compila expresiones regulares y las guarda en el disco en un único ensamblado.

Sobrecargas

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)	Obsoletos. Compila uno o varios objetos Regex especificados y un archivo de recursos especificado en un ensamblado con nombre con los atributos especificados.
CompileToAssembly(RegexCompilationInfo[], AssemblyName)	Obsoletos. Compila uno o varios objetos Regex especificados en un ensamblado con nombre.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])	Obsoletos. Compila uno o varios objetos Regex especificados en un ensamblado con nombre con los atributos especificados.

Comentarios

Nota

En .NET Core y .NET 5+, las llamadas al método Regex.CompileToAssembly producen un PlatformNotSupportedException. No se admite la escritura de un ensamblado.

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

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Precaución

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

Compila uno o varios objetos Regex especificados y un archivo de recursos especificado en un ensamblado con nombre con los 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[]

Matriz que describe las expresiones regulares que se van a compilar.

assemblyname: AssemblyName

Nombre de archivo del ensamblado.

attributes: CustomAttributeBuilder[]

Matriz que define los atributos que se van a aplicar al ensamblado.

resourceFile: String

Nombre del archivo de recursos Win32 que se va a incluir en el ensamblado.

Atributos: ObsoleteAttribute

Excepciones

ArgumentException

El valor de la propiedad Name del parámetro assemblyname es una cadena vacía o nula.

-o-

El patrón de expresión regular de uno o varios objetos de regexinfos contiene sintaxis no válida.

ArgumentNullException

assemblyname o regexinfos es null.

COMException

El parámetro resourceFile designa un archivo de recursos Win32 no válido.

FileNotFoundException

No se encuentra el archivo designado por el parámetro resourceFile.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: no se admite la creación de un ensamblado de expresiones regulares compiladas.

Comentarios

El método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) genera un ensamblado de .NET Framework en el que cada expresión regular definida en la matriz regexinfos se representa mediante una clase . Normalmente, se llama al método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) desde una aplicación independiente que genera un ensamblado de expresiones regulares compiladas. Cada expresión regular incluida en el ensamblado tiene las siguientes características:

Se deriva de la clase Regex.
Se le asigna el nombre completo definido por los parámetros fullnamespace y name de su objeto de RegexCompilationInfo correspondiente.
Tiene un constructor predeterminado (o sin parámetros).

Normalmente, el código que crea instancias y usa la expresión regular compilada se encuentra en un ensamblado o aplicación independiente del código que crea el ensamblado.

Dado que el método CompileToAssembly genera un ensamblado de .NET Framework a partir de una llamada de método en lugar de usar la palabra clave de definición de clase de un lenguaje determinado (como class en C# o Class...End Class en Visual Basic), no permite asignar atributos de .NET Framework al ensamblado mediante la sintaxis de atributo estándar del lenguaje de desarrollo. El parámetro attributes proporciona un método alternativo para definir los atributos que se aplican al ensamblado. Para cada atributo que quiera aplicar al ensamblado, haga lo siguiente:

Cree una matriz de Type objetos que representen los tipos de parámetros del constructor de atributos al que desea llamar.
Recupere un objeto Type que represente la clase de atributo que desea aplicar al nuevo ensamblado.
Llame al método GetConstructor del atributo Type objeto para recuperar un objeto ConstructorInfo que representa el constructor de atributos al que desea llamar. Pase el método GetConstructor la matriz de objetos Type que representa los tipos de parámetros del constructor
Cree una matriz Object que defina los parámetros que se van a pasar al constructor del atributo.
Cree una instancia de un objeto CustomAttributeBuilder pasando su constructor el objeto ConstructorInfo recuperado en el paso 3 y la matriz de Object creada en el paso 4.

A continuación, puede pasar una matriz de estos objetos CustomAttributeBuilder en lugar del parámetro attributes al método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String).

Notas a los autores de las llamadas

Si está desarrollando en un sistema que tiene instalado .NET Framework 4.5 o sus versiones puntuales, tiene como destino .NET Framework 4 y usa el método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para crear un ensamblado que contenga expresiones regulares compiladas. Al intentar usar una de las expresiones regulares de ese ensamblado en un sistema que tiene .NET Framework 4, se produce una excepción. Para solucionar este problema, puede hacer lo siguiente:

Compile el ensamblado que contiene las expresiones regulares compiladas en un sistema que tenga .NET Framework 4 en lugar de versiones posteriores instaladas.
En lugar de llamar a CompileToAssembly(RegexCompilationInfo[], AssemblyName) y recuperar la expresión regular compilada de un ensamblado, use métodos estáticos o de instancia Regex con la opción Compiled cuando cree una instancia de un objeto Regex o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

compilación y reutilización de

Se aplica a

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Precaución

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

Compila uno o varios objetos Regex especificados en un ensamblado con nombre.

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[]

Matriz que describe las expresiones regulares que se van a compilar.

assemblyname: AssemblyName

Nombre de archivo del ensamblado.

Atributos: ObsoleteAttribute

Excepciones

ArgumentException

El valor de la propiedad Name del parámetro assemblyname es una cadena vacía o nula.

-o-

El patrón de expresión regular de uno o varios objetos de regexinfos contiene sintaxis no válida.

ArgumentNullException

assemblyname o regexinfos es null.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: no se admite la creación de un ensamblado de expresiones regulares compiladas.

Ejemplos

En el ejemplo siguiente se crea un ensamblado denominado RegexLib.dll. El ensamblado incluye dos expresiones regulares compiladas. La primera, Utilities.RegularExpressions.DuplicatedString, coincide con dos palabras contiguas idénticas. El segundo, Utilities.RegularExpressions.EmailAddress, comprueba si una cadena tiene el formato correcto para ser una dirección de correo electrónico.

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 continuación, se crea una instancia de la expresión regular que comprueba una cadena para las palabras duplicadas y se usa en el ejemplo siguiente.

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

La compilación correcta de este segundo ejemplo requiere que se agregue una referencia a RegexLib.dll (el ensamblado creado por el primer ejemplo) al proyecto.

Comentarios

El método CompileToAssembly(RegexCompilationInfo[], AssemblyName) genera un ensamblado de .NET Framework en el que cada expresión regular definida en la matriz regexinfos se representa mediante una clase . Normalmente, se llama al método CompileToAssembly(RegexCompilationInfo[], AssemblyName) desde una aplicación independiente que genera un ensamblado de expresiones regulares compiladas. Cada expresión regular incluida en el ensamblado tiene las siguientes características:

Se deriva de la clase Regex.
Se le asigna el nombre completo definido por los parámetros fullnamespace y name de su objeto de RegexCompilationInfo correspondiente.
Tiene un constructor predeterminado (o sin parámetros).

Normalmente, el código que crea instancias y usa la expresión regular compilada se encuentra en un ensamblado o aplicación independiente del código que crea el ensamblado.

Notas a los autores de las llamadas

Compile el ensamblado que contiene las expresiones regulares compiladas en un sistema que tenga .NET Framework 4 en lugar de versiones posteriores instaladas.
En lugar de llamar a CompileToAssembly(RegexCompilationInfo[], AssemblyName) y recuperar la expresión regular compilada de un ensamblado, use métodos estáticos o de instancia Regex con la opción Compiled cuando cree una instancia de un objeto Regex o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

compilación y reutilización de

Se aplica a

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

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Precaución

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

Compila uno o varios objetos Regex especificados en un ensamblado con nombre con los 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[]

Matriz que describe las expresiones regulares que se van a compilar.

assemblyname: AssemblyName

Nombre de archivo del ensamblado.

attributes: CustomAttributeBuilder[]

Matriz que define los atributos que se van a aplicar al ensamblado.

Atributos: ObsoleteAttribute

Excepciones

ArgumentException

El valor de la propiedad Name del parámetro assemblyname es una cadena vacía o nula.

-o-

El patrón de expresión regular de uno o varios objetos de regexinfos contiene sintaxis no válida.

ArgumentNullException

assemblyname o regexinfos es null.

PlatformNotSupportedException

Solo .NET Core y .NET 5+: no se admite la creación de un ensamblado de expresiones regulares compiladas.

Ejemplos

En el ejemplo siguiente se crea un ensamblado denominado RegexLib.dll y se aplica el atributo AssemblyTitleAttribute a él. El ensamblado incluye dos expresiones regulares compiladas. La primera, Utilities.RegularExpressions.DuplicatedString, coincide con dos palabras contiguas idénticas. El segundo, Utilities.RegularExpressions.EmailAddress, comprueba si una cadena tiene el formato correcto para ser una dirección de correo electrónico.

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

Puede comprobar que el atributo AssemblyTitleAttribute se ha aplicado al ensamblado examinando su manifiesto con una utilidad de reflexión como ILDasm.

A continuación, se crea una instancia de la expresión regular que comprueba una cadena para las palabras duplicadas y se usa en el ejemplo siguiente.

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

La compilación correcta de este segundo ejemplo requiere que se agregue una referencia a RegexLib.dll (el ensamblado creado por el primer ejemplo) al proyecto.

Comentarios

El método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) genera un ensamblado de .NET Framework en el que cada expresión regular definida en la matriz regexinfos se representa mediante una clase . Normalmente, se llama al método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) desde una aplicación independiente que genera un ensamblado de expresiones regulares compiladas. Cada expresión regular incluida en el ensamblado tiene las siguientes características:

Se deriva de la clase Regex.
Se le asigna el nombre completo definido por los parámetros fullnamespace y name de su objeto de RegexCompilationInfo correspondiente.
Tiene un constructor predeterminado (o sin parámetros).

Normalmente, el código que crea instancias y usa la expresión regular compilada se encuentra en un ensamblado o aplicación independiente del código que crea el ensamblado.

Cree una matriz de Type objetos que representen los tipos de parámetros del constructor de atributos al que desea llamar.
Recupere un objeto Type que represente la clase de atributo que desea aplicar al nuevo ensamblado.
Llame al método GetConstructor del atributo Type objeto para recuperar un objeto ConstructorInfo que representa el constructor de atributos al que desea llamar. Pase el método GetConstructor la matriz de objetos Type que representa los tipos de parámetros del constructor.
Cree una matriz Object que defina los parámetros que se van a pasar al constructor del atributo.
Cree una instancia de un objeto CustomAttributeBuilder pasando su constructor el objeto ConstructorInfo recuperado en el paso 3 y la matriz de Object creada en el paso 4.

A continuación, puede pasar una matriz de estos objetos CustomAttributeBuilder en lugar del parámetro attributes al método Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]).

Notas a los autores de las llamadas

Compile el ensamblado que contiene las expresiones regulares compiladas en un sistema que tenga .NET Framework 4 en lugar de versiones posteriores instaladas.
En lugar de llamar a CompileToAssembly(RegexCompilationInfo[], AssemblyName) y recuperar la expresión regular compilada de un ensamblado, use métodos estáticos o de instancia Regex con la opción Compiled cuando cree una instancia de un objeto Regex o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

compilación y reutilización de

Se aplica a

Compartir a través de

Regex.CompileToAssembly Método

Definición

Sobrecargas

Comentarios

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

Parámetros

Excepciones

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Comentarios

Recursos adicionales