Regex.CompileToAssembly Método

Source:

Regex.cs

Source:

Regex.cs

Source:

Regex.cs

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

Atributos

ObsoleteAttribute

Excepciones

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:

1. Cree una matriz de Type objetos que representen los tipos de parámetros del constructor de atributos al que desea llamar.

2. Recupere un objeto Type que represente la clase de atributo que desea aplicar al nuevo ensamblado.

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

4. Cree una matriz Object que defina los parámetros que se van a pasar al constructor del atributo.

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

Source:

Regex.cs

Source:

Regex.cs

Source:

Regex.cs

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

Atributos

ObsoleteAttribute

Excepciones

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

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

Source:

Regex.cs

Source:

Regex.cs

Source:

Regex.cs

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

Atributos

ObsoleteAttribute

Excepciones

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.

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:

1. Cree una matriz de Type objetos que representen los tipos de parámetros del constructor de atributos al que desea llamar.

2. Recupere un objeto Type que represente la clase de atributo que desea aplicar al nuevo ensamblado.

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

4. Cree una matriz Object que defina los parámetros que se van a pasar al constructor del atributo.

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

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