Regex.CompileToAssembly Método
Definición
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
Excepciones
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.
assemblyname
o regexinfos
es null
.
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 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 yname
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
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
Excepciones
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.
assemblyname
o regexinfos
es null
.
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.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 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 yname
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
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
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
Excepciones
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.
assemblyname
o regexinfos
es null
.
El parámetro resourceFile
designa un archivo de recursos de Win32 no válido.
No se pudo encontrar el archivo designado por el parámetro resourceFile
.
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 yname
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 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
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.