Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Regex.CompileToAssembly (RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

 

Data di pubblicazione: ottobre 2016

Compila uno o più oggetti Regex specificati in un assembly denominato con gli attributi specificati.

Spazio dei nomi:   System.Text.RegularExpressions
Assembly:  System (in System.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public static void CompileToAssembly(
	RegexCompilationInfo[] regexinfos,
	AssemblyName assemblyname,
	CustomAttributeBuilder[] attributes
)

Parametri

regexinfos
Type: System.Text.RegularExpressions.RegexCompilationInfo[]

Matrice che descrive le espressioni regolari da compilare.

assemblyname
Type: System.Reflection.AssemblyName

Nome file dell'assembly.

attributes
Type: System.Reflection.Emit.CustomAttributeBuilder[]

Matrice che definisce gli attributi da applicare all'assembly.

Exception Condition
ArgumentException

Il valore di assemblyname del parametro AssemblyName.Name proprietà è una stringa vuota o null.

-oppure-

Criterio di espressione regolare di uno o più oggetti in regexinfos contiene sintassi non valida.

ArgumentNullException

assemblyname o regexinfos è null.

Il CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) metodo genera un assembly .NET Framework in cui ogni espressione regolare definita nel regexinfos matrice è rappresentata da una classe. In genere, il CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) viene chiamato da un'applicazione separata che genera un assembly di espressioni regolari compilate. Ogni espressione regolare inclusi nell'assembly ha le caratteristiche seguenti:

  • Deriva dalla Regex classe.

  • Viene assegnato il nome completo è definito per il fullnamespace e name i parametri del relativo valore corrispondente RegexCompilationInfo oggetto.

  • Ha un valore predefinito (o senza parametri) costruttore.

In genere, il codice che crea e utilizza l'espressione regolare compilata è disponibile in un assembly o applicazione che è separato dal codice che crea l'assembly.

Poiché il CompileToAssembly metodo genera un assembly .NET Framework da una chiamata al metodo anziché la parola chiave definizione della classe del linguaggio specifico (ad esempio class in c# o Class...End Class in Visual Basic), non consente gli attributi di .NET Framework da assegnare all'assembly utilizzando la sintassi di attributo standard del linguaggio di sviluppo. Il attributes parametro fornisce un metodo alternativo per definire gli attributi applicati all'assembly. Per ogni attributo che si desidera applicare all'assembly, eseguire le operazioni seguenti:

  1. Creare una matrice di Type gli oggetti che rappresentano i tipi di parametro del costruttore di attributo che si desidera chiamare.

  2. Recuperare un Type oggetto che rappresenta la classe di attributo che si desidera applicare al nuovo assembly.

  3. Chiamare il GetConstructor metodo dell'attributo Type per recuperare un ConstructorInfo oggetto che rappresenta il costruttore dell'attributo che si desidera chiamare. Passare il GetConstructor metodo la matrice di Type gli oggetti che rappresentano i tipi di parametro del costruttore.

  4. Creare un Object matrice che definisce i parametri da passare al costruttore dell'attributo.

  5. Creare un'istanza di un CustomAttributeBuilder oggetto passando al costruttore di ConstructorInfo oggetto recuperato nel passaggio 3 e Object matrice creata nel passaggio 4.

È quindi possibile passare una matrice di questi CustomAttributeBuilder oggetti anziché il attributes parametro per il Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) metodo.

Note per i chiamanti:

Se si sviluppa in un sistema con .NET Framework 4.5 o relative versioni intermedie installati, la destinazione è .NET Framework 4, e si utilizza il CompileToAssembly metodo per creare un assembly che contiene le espressioni regolari compilate. Tentativo di utilizzare una delle espressioni regolari in assembly in un sistema che dispone di .NET Framework 4 genera un'eccezione. Per risolvere il problema, è possibile eseguire una delle operazioni seguenti:

  • Compilare l'assembly che contiene le espressioni regolari compilate in un sistema con .NET Framework 4 anziché versioni successive installato.

  • Anziché chiamare CompileToAssembly e recupera l'espressione regolare compilata da un assembly, utilizzare statico o di istanza Regex metodi con il RegexOptions.Compiled opzione quando crea un'istanza di un Regex dell'oggetto o chiamare il metodo corrispondente criterio di espressione regolare.

Nell'esempio seguente viene creato un assembly denominato RegexLib. dll e si applica il AssemblyTitleAttribute attributo. L'assembly include due espressioni regolari compilate. Il primo, Utilities.RegularExpressions.DuplicatedString, corrisponde a due parole contigue identiche. Il secondo, Utilities.RegularExpressions.EmailAddress, controlla se una stringa ha il formato corretto per un indirizzo di posta elettronica.

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

È possibile verificare che il AssemblyTitleAttribute attributi applicati all'assembly esaminandone il manifesto con un'utilità di reflection, ad esempio ILDasm.

L'espressione regolare che controlla una stringa per le parole duplicate viene quindi creata e utilizzata nell'esempio seguente.

using System;
using Utilities.RegularExpressions;

public class CompiledRegexUsage
{
   public static void Main()
   {
      string text = "The the quick brown fox  fox jumped 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 jumped over the lazy dog dog.'

La compilazione ha esito positivo di questo secondo esempio richiede un riferimento a RegexLib. dll (assembly creato dal primo esempio) da aggiungere al progetto.

.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: