Regex.CompileToAssembly Método

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

static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName -> unit

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName)

Parâmetros

Exceções

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) para ser adicionado ao projeto.

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName) gera um assembly .NET Framework no qual cada expressão regular definida na matriz regexinfos é 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 cria uma instância 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 método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly em um sistema que .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 criar uma instância de um Regex objeto ou chamar um método de correspondência de padrão de expressão regular.

Confira também

• Compilação e reutilização

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

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

Exceções

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) para ser adicionado ao projeto.

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) gera um assembly .NET Framework no qual cada expressão regular definida na matriz regexinfos é 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 cria uma instância e usa a expressão regular compilada é encontrado em um assembly ou aplicativo separado do código que cria o assembly.

Como o método CompileToAssembly gera um assembly .NET Framework de uma chamada de método em vez de usar uma 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:

1. Crie uma matriz de Type objetos que representam os tipos de parâmetro do construtor de atributos que você deseja chamar.

2. Recupere um Type objeto que representa a classe de atributo que você deseja aplicar ao novo assembly.

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

4. Crie uma Object matriz que defina os parâmetros a serem passados para o construtor do atributo.

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

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 método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly em um sistema que .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 criar uma instância de um Regex objeto ou chamar um método de correspondência de padrão de expressão regular.

Confira também

• Compilação e reutilização

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

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

Exceções

Comentários

O método CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) gera um assembly .NET Framework no qual cada expressão regular definida na matriz regexinfos é 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 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 cria uma instância e usa a expressão regular compilada é encontrado em um assembly ou aplicativo separado do código que cria o assembly.

Como o método CompileToAssembly gera um assembly .NET Framework de uma chamada de método em vez de usar uma 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:

1. Crie uma matriz de Type objetos que representam os tipos de parâmetro do construtor de atributos que você deseja chamar.

2. Recupere um Type objeto que representa a classe de atributo que você deseja aplicar ao novo assembly.

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

4. Crie uma Object matriz que defina os parâmetros a serem passados para o construtor do atributo.

5. 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 método CompileToAssembly(RegexCompilationInfo[], AssemblyName) para criar um assembly que contenha expressões regulares compiladas. Tentar usar uma das expressões regulares nesse assembly em um sistema que .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 criar uma instância de um Regex objeto ou chamar um método de correspondência de padrão de expressão regular.

Confira também

• Compilação e reutilização