Regex.CompileToAssembly Método

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

Sobrecargas

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

Comentários

Observação

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

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Cuidado

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

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

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

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

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the 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[]

Uma matriz que descreve as expressões regulares a compilar.

assemblyname: AssemblyName

O nome do arquivo do assembly.

Atributos: ObsoleteAttribute

Exceções

ArgumentException

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

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

ArgumentNullException

assemblyname ou regexinfos é null.

PlatformNotSupportedException

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

Exemplos

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

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

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

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

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

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

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

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

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

using System;
using Utilities.RegularExpressions;

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

Imports Utilities.RegularExpressions

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

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

Comentários

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

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

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

Notas aos Chamadores

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

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

Confira também

Compilação e reutilização

Aplica-se a

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

Cuidado

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

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

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

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

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the 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[]

Uma matriz que descreve as expressões regulares a compilar.

assemblyname: AssemblyName

O nome do arquivo do assembly.

attributes: CustomAttributeBuilder[]

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

Atributos: ObsoleteAttribute

Exceções

ArgumentException

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

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

ArgumentNullException

assemblyname ou regexinfos é null.

PlatformNotSupportedException

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

Exemplos

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

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

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

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

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

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

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

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

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

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

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

using System;
using Utilities.RegularExpressions;

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

Imports Utilities.RegularExpressions

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

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

Comentários

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

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

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

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

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

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

Notas aos Chamadores

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

Confira também

Compilação e reutilização

Aplica-se a

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

Cuidado

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

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

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

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

[System.Obsolete("Regex.CompileToAssembly is obsolete and not supported. Use the 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[]

Uma matriz que descreve as expressões regulares a compilar.

assemblyname: AssemblyName

O nome do arquivo do assembly.

attributes: CustomAttributeBuilder[]

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

resourceFile: String

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

Atributos: ObsoleteAttribute

Exceções

ArgumentException

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

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

ArgumentNullException

assemblyname ou regexinfos é null.

COMException

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

FileNotFoundException

O arquivo designado pelo parâmetro resourceFile não pôde ser encontrado.

PlatformNotSupportedException

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

Comentários

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

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

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

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

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

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

Notas aos Chamadores

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

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

Confira também

Compilação e reutilização

Aplica-se a

Regex.CompileToAssembly Método

Definição

Sobrecargas

Comentários

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

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

Parâmetros

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

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

Parâmetros

Exceções

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Recursos adicionais