Regex.CompileToAssembly Metodo

Origine:

Regex.cs

Origine:

Regex.cs

Origine:

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

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}")]
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 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

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName, attributes As CustomAttributeBuilder(), resourceFile As String)

Parametri

Attributi

ObsoleteAttribute

Eccezioni

Commenti

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

• Derivata dalla classe Regex.

• Viene assegnato il nome completo definito dai parametri fullnamespace e name dell'oggetto RegexCompilationInfo corrispondente.

• Ha un costruttore predefinito (o senza parametri).

In genere, il codice che crea un'istanza e usa l'espressione regolare compilata si trova in un assembly o in un'applicazione separata dal codice che crea l'assembly.

Poiché il metodo CompileToAssembly genera un assembly .NET Framework da una chiamata al metodo anziché usare la parola chiave di definizione della classe di un linguaggio specifico ,ad esempio class in C# o Class...End Class in Visual Basic, non consente l'assegnazione di attributi .NET Framework all'assembly usando la sintassi degli attributi standard del linguaggio di sviluppo. Il parametro attributes fornisce un metodo alternativo per definire gli attributi applicabili all'assembly. Per ogni attributo da applicare all'assembly, eseguire le operazioni seguenti:

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

2. Recuperare un oggetto Type che rappresenta la classe di attributi da applicare al nuovo assembly.

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

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

5. Creare un'istanza di un oggetto CustomAttributeBuilder passando il relativo costruttore, l'oggetto ConstructorInfo recuperato nel passaggio 3 e la matrice Object creata nel passaggio 4.

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

Note per i chiamanti

Se si sviluppa in un sistema in cui è installato .NET Framework 4.5 o le relative versioni intermedie, si usa .NET Framework 4 e si usa il metodo CompileToAssembly(RegexCompilationInfo[], AssemblyName) per creare un assembly contenente espressioni regolari compilate. Il tentativo di usare una delle espressioni regolari in tale assembly in un sistema con .NET Framework 4 genera un'eccezione. Per risolvere questo problema, è possibile eseguire una delle operazioni seguenti:

• Compilare l'assembly contenente le espressioni regolari compilate in un sistema in cui è installato .NET Framework 4 anziché versioni successive.

• Anziché chiamare CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperare l'espressione regolare compilata da un assembly, usare metodi statici o di istanza Regex con l'opzione Compiled quando si crea un'istanza di un oggetto Regex o si chiama un metodo di ricerca di criteri di espressione regolare.

Vedi anche

• compilazione e riutilizzo

Origine:

Regex.cs

Origine:

Regex.cs

Origine:

Regex.cs

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

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

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

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

Parametri

Attributi

ObsoleteAttribute

Eccezioni

Esempio

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, verifica se una stringa ha il formato corretto per essere 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);                                                 
   }
}

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

L'espressione regolare che controlla la presenza di parole duplicate viene quindi creata un'istanza e usata dall'esempio seguente.

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

Per la corretta compilazione di questo secondo esempio è necessario che un riferimento a RegexLib.dll (l'assembly creato dal primo esempio) venga aggiunto al progetto.

Commenti

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

• Derivata dalla classe Regex.

• Viene assegnato il nome completo definito dai parametri fullnamespace e name dell'oggetto RegexCompilationInfo corrispondente.

• Ha un costruttore predefinito (o senza parametri).

In genere, il codice che crea un'istanza e usa l'espressione regolare compilata si trova in un assembly o in un'applicazione separata dal codice che crea l'assembly.

Note per i chiamanti

Se si sviluppa in un sistema in cui è installato .NET Framework 4.5 o le relative versioni intermedie, si usa .NET Framework 4 e si usa il metodo CompileToAssembly(RegexCompilationInfo[], AssemblyName) per creare un assembly contenente espressioni regolari compilate. Il tentativo di usare una delle espressioni regolari in tale assembly in un sistema con .NET Framework 4 genera un'eccezione. Per risolvere questo problema, è possibile eseguire una delle operazioni seguenti:

• Compilare l'assembly contenente le espressioni regolari compilate in un sistema in cui è installato .NET Framework 4 anziché versioni successive.

• Anziché chiamare CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperare l'espressione regolare compilata da un assembly, usare metodi statici o di istanza Regex con l'opzione Compiled quando si crea un'istanza di un oggetto Regex o si chiama un metodo di ricerca di criteri di espressione regolare.

Vedi anche

• compilazione e riutilizzo

Origine:

Regex.cs

Origine:

Regex.cs

Origine:

Regex.cs

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

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

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

Parametri

Attributi

ObsoleteAttribute

Eccezioni

Esempio

Nell'esempio seguente viene creato un assembly denominato RegexLib.dll e viene applicato l'attributo AssemblyTitleAttribute. L'assembly include due espressioni regolari compilate. Il primo, Utilities.RegularExpressions.DuplicatedString, corrisponde a due parole contigue identiche. Il secondo, Utilities.RegularExpressions.EmailAddress, verifica se una stringa ha il formato corretto per essere 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);                                                 
   }
}

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

È possibile verificare che l'attributo AssemblyTitleAttribute sia stato applicato all'assembly esaminandone il manifesto con un'utilità di reflection, ad esempio ILDasm.

L'espressione regolare che controlla la presenza di parole duplicate viene quindi creata un'istanza e usata dall'esempio seguente.

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

Per la corretta compilazione di questo secondo esempio è necessario che un riferimento a RegexLib.dll (l'assembly creato dal primo esempio) venga aggiunto al progetto.

Commenti

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

• Derivata dalla classe Regex.

• Viene assegnato il nome completo definito dai parametri fullnamespace e name dell'oggetto RegexCompilationInfo corrispondente.

• Ha un costruttore predefinito (o senza parametri).

In genere, il codice che crea un'istanza e usa l'espressione regolare compilata si trova in un assembly o in un'applicazione separata dal codice che crea l'assembly.

Poiché il metodo CompileToAssembly genera un assembly .NET Framework da una chiamata al metodo anziché usare la parola chiave di definizione della classe di un linguaggio specifico ,ad esempio class in C# o Class...End Class in Visual Basic, non consente l'assegnazione di attributi .NET Framework all'assembly usando la sintassi degli attributi standard del linguaggio di sviluppo. Il parametro attributes fornisce un metodo alternativo per definire gli attributi applicabili all'assembly. Per ogni attributo da applicare all'assembly, eseguire le operazioni seguenti:

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

2. Recuperare un oggetto Type che rappresenta la classe di attributi da applicare al nuovo assembly.

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

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

5. Creare un'istanza di un oggetto CustomAttributeBuilder passando il relativo costruttore, l'oggetto ConstructorInfo recuperato nel passaggio 3 e la matrice Object creata nel passaggio 4.

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

Note per i chiamanti

Se si sviluppa in un sistema in cui è installato .NET Framework 4.5 o le relative versioni intermedie, si usa .NET Framework 4 e si usa il metodo CompileToAssembly(RegexCompilationInfo[], AssemblyName) per creare un assembly contenente espressioni regolari compilate. Il tentativo di usare una delle espressioni regolari in tale assembly in un sistema con .NET Framework 4 genera un'eccezione. Per risolvere questo problema, è possibile eseguire una delle operazioni seguenti:

• Compilare l'assembly contenente le espressioni regolari compilate in un sistema in cui è installato .NET Framework 4 anziché versioni successive.

• Anziché chiamare CompileToAssembly(RegexCompilationInfo[], AssemblyName) e recuperare l'espressione regolare compilata da un assembly, usare metodi statici o di istanza Regex con l'opzione Compiled quando si crea un'istanza di un oggetto Regex o si chiama un metodo di ricerca di criteri di espressione regolare.

Vedi anche

• compilazione e riutilizzo