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 disco en un ensamblado único.

Sobrecargas

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

Comentarios

Nota

En .NET Core y .NET 5 y versiones posteriores, las llamadas al Regex.CompileToAssembly método inician una PlatformNotSupportedExceptionexcepción . No se admite la escritura de un ensamblado.

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Precaución

Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute 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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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

El 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 NULL.

O bien El modelo de expresión regular de uno o varios objetos de regexinfos contiene una 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.DuplicatedStringcoincide 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 una referencia a RegexLib.dll (el ensamblado creado por el primer ejemplo) que se va a agregar al proyecto.

Comentarios

El CompileToAssembly(RegexCompilationInfo[], AssemblyName) método genera un ensamblado de .NET Framework en el que cada expresión regular definida en la regexinfos matriz se representa mediante una clase . Normalmente, se llama al CompileToAssembly(RegexCompilationInfo[], AssemblyName) método 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 Regex clase .
Se le asigna el nombre completo definido por los fullnamespace parámetros y name de su objeto correspondiente RegexCompilationInfo .
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 CompileToAssembly(RegexCompilationInfo[], AssemblyName) método 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 evitar este problema, realice una de las acciones siguientes: : compile el ensamblado que contiene las expresiones regulares compiladas en un sistema que tenga instalado .NET Framework 4 en lugar de versiones posteriores instaladas.

En lugar de llamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) a y recuperar la expresión regular compilada desde un ensamblado, use métodos estáticos o de instancia Regex con la Compiled opción cuando cree una instancia de un Regex objeto o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

Compilar y volver a utilizar

Se aplica a

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

Precaución

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

Compila uno o varios objetos Regex especificados en un ensamblado con nombre que tiene 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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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

El 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 NULL.

O bien El modelo de expresión regular de uno o varios objetos de regexinfos contiene una 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 AssemblyTitleAttribute atributo a él. El ensamblado incluye dos expresiones regulares compiladas. La primera, , Utilities.RegularExpressions.DuplicatedStringcoincide 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 AssemblyTitleAttribute atributo 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 una referencia a RegexLib.dll (el ensamblado creado por el primer ejemplo) que se va a agregar al proyecto.

Comentarios

El CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) método genera un ensamblado de .NET Framework en el que cada expresión regular definida en la regexinfos matriz se representa mediante una clase . Normalmente, se llama al CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) método 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 Regex clase .
Se le asigna el nombre completo definido por los fullnamespace parámetros y name de su objeto correspondiente RegexCompilationInfo .
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 CompileToAssembly método 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 attributes parámetro 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 Type objeto que representa la clase de atributo que desea aplicar al nuevo ensamblado.
Llame al GetConstructor método del objeto de atributo Type para recuperar un ConstructorInfo objeto que representa el constructor de atributos al que desea llamar. Pase el método a la GetConstructor matriz de Type objetos que representa los tipos de parámetros del constructor.
Cree una Object matriz que defina los parámetros que se van a pasar al constructor del atributo.
Cree una instancia de un CustomAttributeBuilder objeto pasando su constructor el objeto recuperado en el ConstructorInfo paso 3 y la matriz creada en el Object paso 4.

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

Notas a los autores de las llamadas

En lugar de llamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) a y recuperar la expresión regular compilada desde un ensamblado, use métodos estáticos o de instancia Regex con la Compiled opción cuando cree una instancia de un Regex objeto o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

Compilar y volver a utilizar

Se aplica a

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

Precaución

Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute 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 que tiene los atributos indicados.

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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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

El 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 NULL.

O bien El modelo de expresión regular de uno o varios objetos de regexinfos contiene una sintaxis no válida.

ArgumentNullException

assemblyname o regexinfos es null.

COMException

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

FileNotFoundException

No se pudo encontrar 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 CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) método genera un ensamblado de .NET Framework en el que cada expresión regular definida en la regexinfos matriz se representa mediante una clase . Normalmente, se llama al CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) método 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 Regex clase .
Se le asigna el nombre completo definido por los fullnamespace parámetros y name de su objeto correspondiente RegexCompilationInfo .
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 Type objeto que representa la clase de atributo que desea aplicar al nuevo ensamblado.
Llame al GetConstructor método del objeto de atributo Type para recuperar un ConstructorInfo objeto que representa el constructor de atributos al que desea llamar. Pase el método a GetConstructor la matriz de Type objetos que representa los tipos de parámetros del constructor.
Cree una Object matriz que defina los parámetros que se van a pasar al constructor del atributo.
Cree una instancia de un CustomAttributeBuilder objeto pasando su constructor el objeto recuperado en el ConstructorInfo paso 3 y la matriz creada en el Object paso 4.

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

Notas a los autores de las llamadas

En lugar de llamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) a y recuperar la expresión regular compilada desde un ensamblado, use métodos estáticos o de instancia Regex con la Compiled opción cuando cree una instancia de un Regex objeto o llame a un método de coincidencia de patrones de expresión regular.

Consulte también

Compilar y volver a utilizar

Se aplica a

Regex.CompileToAssembly Método

Definición

Sobrecargas

Comentarios

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

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

Parámetros

Excepciones

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Recursos adicionales