Regex.CompileToAssembly Méthode

Source:

Regex.cs

Source:

Regex.cs

Source:

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)

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Remarques

La méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le tableau regexinfos est représentée par une classe. En règle générale, la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) est appelée à partir d’une application distincte qui génère un assembly d’expressions régulières compilées. Chaque expression régulière incluse dans l’assembly présente les caractéristiques suivantes :

• Elle est dérivée de la classe Regex.

• Il reçoit le nom qualifié complet défini par les paramètres fullnamespace et name de son objet RegexCompilationInfo correspondant.

• Il a un constructeur par défaut (ou sans paramètre).

En règle générale, le code qui instancie et utilise l’expression régulière compilée se trouve dans un assembly ou une application distinct du code qui crée l’assembly.

Étant donné que la méthode CompileToAssembly génère un assembly .NET Framework à partir d’un appel de méthode au lieu d’utiliser le mot clé de définition de classe d’un langage particulier (par exemple, class en C# ou Class...End Class en Visual Basic), il n’autorise pas les attributs .NET Framework à être attribués à l’assembly à l’aide de la syntaxe d’attribut standard du langage de développement. Le paramètre attributes fournit une autre méthode pour définir les attributs qui s’appliquent à l’assembly. Pour chaque attribut que vous souhaitez appliquer à l’assembly, procédez comme suit :

1. Créez un tableau d’objets Type représentant les types de paramètres du constructeur d’attribut que vous souhaitez appeler.

2. Récupérez un objet Type représentant la classe d’attribut que vous souhaitez appliquer au nouvel assembly.

3. Appelez la méthode GetConstructor de l’attribut Type objet pour récupérer un objet ConstructorInfo représentant le constructeur d’attribut que vous souhaitez appeler. Passez la méthode GetConstructor le tableau d’objets Type qui représente les types de paramètres du constructeur

4. Créez un tableau Object qui définit les paramètres à passer au constructeur de l’attribut.

5. Instanciez un objet CustomAttributeBuilder en transmettant son constructeur à l’objet ConstructorInfo récupéré à l’étape 3 et au tableau Object créé à l’étape 4.

Vous pouvez ensuite passer un tableau de ces objets CustomAttributeBuilder au lieu du paramètre attributes à la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String).

Notes pour les appelants

Si vous développez sur un système sur lequel .NET Framework 4.5 ou ses versions de point sont installées, vous ciblez .NET Framework 4 et utilisez la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName) pour créer un assembly qui contient des expressions régulières compilées. Essayer d’utiliser l’une des expressions régulières dans cet assembly sur un système doté de .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez effectuer l’une des opérations suivantes :

• Générez l’assembly qui contient les expressions régulières compilées sur un système sur lequel .NET Framework 4 est installé au lieu des versions ultérieures.

• Au lieu d’appeler CompileToAssembly(RegexCompilationInfo[], AssemblyName) et de récupérer l’expression régulière compilée à partir d’un assembly, utilisez des méthodes statiques ou d’instance Regex avec l’option Compiled lorsque vous instanciez un objet Regex ou appelez une méthode de correspondance de modèle d’expression régulière.

Voir aussi

• compilation et réutilisation des

Source:

Regex.cs

Source:

Regex.cs

Source:

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)

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Exemples

L’exemple suivant crée un assembly nommé RegexLib.dll. L’assembly inclut deux expressions régulières compilées. Le premier, Utilities.RegularExpressions.DuplicatedString, correspond à deux mots contigus identiques. Le deuxième, Utilities.RegularExpressions.EmailAddress, vérifie si une chaîne a le format approprié pour être une adresse e-mail.

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’expression régulière qui vérifie une chaîne pour les mots dupliqués est ensuite instanciée et utilisée par l’exemple suivant.

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

La compilation réussie de ce deuxième exemple nécessite une référence à RegexLib.dll (l’assembly créé par le premier exemple) à ajouter au projet.

Remarques

La méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName) génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le tableau regexinfos est représentée par une classe. En règle générale, la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName) est appelée à partir d’une application distincte qui génère un assembly d’expressions régulières compilées. Chaque expression régulière incluse dans l’assembly présente les caractéristiques suivantes :

• Elle est dérivée de la classe Regex.

• Il reçoit le nom qualifié complet défini par les paramètres fullnamespace et name de son objet RegexCompilationInfo correspondant.

• Il a un constructeur par défaut (ou sans paramètre).

En règle générale, le code qui instancie et utilise l’expression régulière compilée se trouve dans un assembly ou une application distinct du code qui crée l’assembly.

Notes pour les appelants

Si vous développez sur un système sur lequel .NET Framework 4.5 ou ses versions de point sont installées, vous ciblez .NET Framework 4 et utilisez la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName) pour créer un assembly qui contient des expressions régulières compilées. Essayer d’utiliser l’une des expressions régulières dans cet assembly sur un système doté de .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez effectuer l’une des opérations suivantes :

• Générez l’assembly qui contient les expressions régulières compilées sur un système sur lequel .NET Framework 4 est installé au lieu des versions ultérieures.

• Au lieu d’appeler CompileToAssembly(RegexCompilationInfo[], AssemblyName) et de récupérer l’expression régulière compilée à partir d’un assembly, utilisez des méthodes statiques ou d’instance Regex avec l’option Compiled lorsque vous instanciez un objet Regex ou appelez une méthode de correspondance de modèle d’expression régulière.

Voir aussi

• compilation et réutilisation des

Source:

Regex.cs

Source:

Regex.cs

Source:

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

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Exemples

L’exemple suivant crée un assembly nommé RegexLib.dll et applique l’attribut AssemblyTitleAttribute à celui-ci. L’assembly inclut deux expressions régulières compilées. Le premier, Utilities.RegularExpressions.DuplicatedString, correspond à deux mots contigus identiques. Le deuxième, Utilities.RegularExpressions.EmailAddress, vérifie si une chaîne a le format approprié pour être une adresse e-mail.

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

Vous pouvez vérifier que l’attribut AssemblyTitleAttribute a été appliqué à l’assembly en examinant son manifeste avec un utilitaire de réflexion tel qu’ILDasm.

L’expression régulière qui vérifie une chaîne pour les mots dupliqués est ensuite instanciée et utilisée par l’exemple suivant.

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

La compilation réussie de ce deuxième exemple nécessite une référence à RegexLib.dll (l’assembly créé par le premier exemple) à ajouter au projet.

Remarques

La méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le tableau regexinfos est représentée par une classe. En règle générale, la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) est appelée à partir d’une application distincte qui génère un assembly d’expressions régulières compilées. Chaque expression régulière incluse dans l’assembly présente les caractéristiques suivantes :

• Elle est dérivée de la classe Regex.

• Il reçoit le nom qualifié complet défini par les paramètres fullnamespace et name de son objet RegexCompilationInfo correspondant.

• Il a un constructeur par défaut (ou sans paramètre).

En règle générale, le code qui instancie et utilise l’expression régulière compilée se trouve dans un assembly ou une application distinct du code qui crée l’assembly.

Étant donné que la méthode CompileToAssembly génère un assembly .NET Framework à partir d’un appel de méthode au lieu d’utiliser le mot clé de définition de classe d’un langage particulier (par exemple, class en C# ou Class...End Class en Visual Basic), il n’autorise pas les attributs .NET Framework à être attribués à l’assembly à l’aide de la syntaxe d’attribut standard du langage de développement. Le paramètre attributes fournit une autre méthode pour définir les attributs qui s’appliquent à l’assembly. Pour chaque attribut que vous souhaitez appliquer à l’assembly, procédez comme suit :

1. Créez un tableau d’objets Type représentant les types de paramètres du constructeur d’attribut que vous souhaitez appeler.

2. Récupérez un objet Type représentant la classe d’attribut que vous souhaitez appliquer au nouvel assembly.

3. Appelez la méthode GetConstructor de l’attribut Type objet pour récupérer un objet ConstructorInfo représentant le constructeur d’attribut que vous souhaitez appeler. Transmettez la méthode GetConstructor le tableau d’objets Type qui représente les types de paramètres du constructeur.

4. Créez un tableau Object qui définit les paramètres à passer au constructeur de l’attribut.

5. Instanciez un objet CustomAttributeBuilder en transmettant son constructeur à l’objet ConstructorInfo récupéré à l’étape 3 et au tableau Object créé à l’étape 4.

Vous pouvez ensuite passer un tableau de ces objets CustomAttributeBuilder au lieu du paramètre attributes à la méthode Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]).

Notes pour les appelants

Si vous développez sur un système sur lequel .NET Framework 4.5 ou ses versions de point sont installées, vous ciblez .NET Framework 4 et utilisez la méthode CompileToAssembly(RegexCompilationInfo[], AssemblyName) pour créer un assembly qui contient des expressions régulières compilées. Essayer d’utiliser l’une des expressions régulières dans cet assembly sur un système doté de .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez effectuer l’une des opérations suivantes :

• Générez l’assembly qui contient les expressions régulières compilées sur un système sur lequel .NET Framework 4 est installé au lieu des versions ultérieures.

• Au lieu d’appeler CompileToAssembly(RegexCompilationInfo[], AssemblyName) et de récupérer l’expression régulière compilée à partir d’un assembly, utilisez des méthodes statiques ou d’instance Regex avec l’option Compiled lorsque vous instanciez un objet Regex ou appelez une méthode de correspondance de modèle d’expression régulière.

Voir aussi

• compilation et réutilisation des