Regex.CompileToAssembly Método

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

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);

[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);

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] * string -> unit

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

Exceções

Observações

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) gera um conjunto .NET Framework em que cada expressão regular definida no array regexinfos é representada por uma classe. Normalmente, o CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) método é chamado a partir de uma aplicação separada que gera um conjunto de expressões regulares compiladas. Cada expressão regular incluída na montagem tem as seguintes características:

• Deriva da Regex classe.

• É-lhe atribuído o nome totalmente qualificado, definido pelos fullnamespace parâmetros e name do seu objeto correspondente RegexCompilationInfo .

• Tem um construtor por defeito (ou sem parâmetros).

Normalmente, o código que instancia e utiliza a expressão regular compilada encontra-se numa assembleia ou aplicação separada do código que cria a assembleia.

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

1. Crie um array de Type objetos que represente os tipos de parâmetros do construtor de atributos que pretende chamar.

2. Recupera um Type objeto que represente a classe de atributo que queres aplicar à nova assembleia.

3. Chame o GetConstructor método do objeto atributo Type para recuperar um ConstructorInfo objeto que represente o construtor de atributos que pretende chamar. Passe ao GetConstructor método o array de Type objetos que representa os tipos de parâmetros do construtor

4. Crie um Object array que defina os parâmetros a passar ao construtor do atributo.

5. Instanciar um CustomAttributeBuilder objeto passando ao seu construtor o ConstructorInfo objeto recuperado no passo 3 e o Object array criado no passo 4.

Pode então passar um array destes CustomAttributeBuilder objetos em vez do attributes parâmetro para o CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) método.

Notas para Chamadores

Se estiver a desenvolver num sistema que tenha instalado .NET Framework 4.5 ou as suas versões pontuais, deve apontar .NET Framework 4 e usar o método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly num sistema que tenha .NET Framework 4 lança uma exceção. Para contornar esse problema, você pode fazer o seguinte:

• Construa o assembly que contém as expressões regulares compiladas num sistema que tenha o .NET Framework 4 instalado em vez de versões posteriores.

• Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada a partir de uma assembleia, use métodos estáticos ou de instância Regex com a Compiled opção de instanciar um Regex objeto ou chamar um método de correspondência de padrões de expressões regulares.

Ver também

• Compilação e Reutilização

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

public:
 static void CompileToAssembly(cli::array <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);

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName -> unit

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

Exceções

Exemplos

O exemplo seguinte cria uma assembleia chamada RegexLib.dll. O assembly inclui duas expressões regulares compiladas. A primeira, Utilities.RegularExpressions.DuplicatedString, corresponde a duas palavras contíguas idênticas. A segunda, Utilities.RegularExpressions.EmailAddress, verifica se uma cadeia 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 string para palavras duplicadas é então instanciada e usada pelo seguinte exemplo.

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 que uma referência a RegexLib.dll (a montagem criada pelo primeiro exemplo) seja adicionada ao projeto.

Observações

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName) gera um conjunto .NET Framework em que cada expressão regular definida no array regexinfos é representada por uma classe. Normalmente, o CompileToAssembly(RegexCompilationInfo[], AssemblyName) método é chamado a partir de uma aplicação separada que gera um conjunto de expressões regulares compiladas. Cada expressão regular incluída na montagem tem as seguintes características:

• Deriva da Regex classe.

• É-lhe atribuído o nome totalmente qualificado, definido pelos fullnamespace parâmetros e name do seu objeto correspondente RegexCompilationInfo .

• Tem um construtor por defeito (ou sem parâmetros).

Normalmente, o código que instancia e utiliza a expressão regular compilada encontra-se numa assembleia ou aplicação separada do código que cria a assembleia.

Notas para Chamadores

Se estiver a desenvolver num sistema que tenha instalado .NET Framework 4.5 ou as suas versões pontuais, deve apontar .NET Framework 4 e usar o método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly num sistema que tenha .NET Framework 4 lança uma exceção. Para contornar esse problema, você pode fazer o seguinte:

• Construa o assembly que contém as expressões regulares compiladas num sistema que tenha o .NET Framework 4 instalado em vez de versões posteriores.

• Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada a partir de uma assembleia, use métodos estáticos ou de instância Regex com a Compiled opção de instanciar um Regex objeto ou chamar um método de correspondência de padrões de expressões regulares.

Ver também

• Compilação e Reutilização

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

Regex.cs

Origem:

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.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);

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] -> unit

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

Exceções

Exemplos

O exemplo seguinte cria um assembly chamado RegexLib.dll e aplica-lhe o AssemblyTitleAttribute atributo. O assembly inclui duas expressões regulares compiladas. A primeira, Utilities.RegularExpressions.DuplicatedString, corresponde a duas palavras contíguas idênticas. A segunda, Utilities.RegularExpressions.EmailAddress, verifica se uma cadeia 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

Pode verificar que o AssemblyTitleAttribute atributo foi aplicado à montagem examinando o seu manifesto com uma ferramenta de reflexão como o ILDasm.

A expressão regular que verifica uma string para palavras duplicadas é então instanciada e usada pelo seguinte exemplo.

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 que uma referência a RegexLib.dll (a montagem criada pelo primeiro exemplo) seja adicionada ao projeto.

Observações

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) gera um conjunto .NET Framework em que cada expressão regular definida no array regexinfos é representada por uma classe. Normalmente, o CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) método é chamado a partir de uma aplicação separada que gera um conjunto de expressões regulares compiladas. Cada expressão regular incluída na montagem tem as seguintes características:

• Deriva da Regex classe.

• É-lhe atribuído o nome totalmente qualificado, definido pelos fullnamespace parâmetros e name do seu objeto correspondente RegexCompilationInfo .

• Tem um construtor por defeito (ou sem parâmetros).

Normalmente, o código que instancia e utiliza a expressão regular compilada encontra-se numa assembleia ou aplicação separada do código que cria a assembleia.

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

1. Crie um array de Type objetos que represente os tipos de parâmetros do construtor de atributos que pretende chamar.

2. Recupera um Type objeto que represente a classe de atributo que queres aplicar à nova assembleia.

3. Chame o GetConstructor método do objeto atributo Type para recuperar um ConstructorInfo objeto que represente o construtor de atributos que pretende chamar. Passe ao GetConstructor método o array de Type objetos que representa os tipos de parâmetros do construtor.

4. Crie um Object array que defina os parâmetros a passar ao construtor do atributo.

5. Instanciar um CustomAttributeBuilder objeto passando ao seu construtor o ConstructorInfo objeto recuperado no passo 3 e o Object array criado no passo 4.

Pode então passar um array destes CustomAttributeBuilder objetos em vez do attributes parâmetro para o Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) método.

Notas para Chamadores

Se estiver a desenvolver num sistema que tenha instalado .NET Framework 4.5 ou as suas versões pontuais, deve apontar .NET Framework 4 e usar o método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly num sistema que tenha .NET Framework 4 lança uma exceção. Para contornar esse problema, você pode fazer o seguinte:

• Construa o assembly que contém as expressões regulares compiladas num sistema que tenha o .NET Framework 4 instalado em vez de versões posteriores.

• Em vez de chamar CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperar a expressão regular compilada a partir de uma assembleia, use métodos estáticos ou de instância Regex com a Compiled opção de instanciar um Regex objeto ou chamar um método de correspondência de padrões de expressões regulares.

Ver também

• Compilação e Reutilização