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)

 

Data di pubblicazione: ottobre 2016

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

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

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

Parametri

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

Matrice che descrive le espressioni regolari da compilare.

assemblyname
Type: System.Reflection.AssemblyName

Nome file dell'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) 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) 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.

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

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: