Regex.CompileToAssembly Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Compile les expressions régulières et les enregistre sur le disque dans un assembly unique.
Surcharges
CompileToAssembly(RegexCompilationInfo[], AssemblyName) |
Obsolète.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé. |
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) |
Obsolète.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé avec les attributs spécifiés. |
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) |
Obsolète.
Compile un ou plusieurs objets Regex spécifiés et un fichier de ressources spécifié dans un assembly nommé avec les attributs spécifiés. |
Remarques
Notes
Sur .NET Core et .NET 5+, les appels à la Regex.CompileToAssembly
méthode lèvent un PlatformNotSupportedException. L’écriture d’un assembly n’est pas prise en charge.
CompileToAssembly(RegexCompilationInfo[], AssemblyName)
Attention
Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé.
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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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
- regexinfos
- RegexCompilationInfo[]
Tableau qui décrit les expressions régulières à compiler.
- assemblyname
- AssemblyName
Nom de fichier de l’assembly.
- Attributs
Exceptions
La valeur de la propriété Name du paramètre assemblyname
est une chaîne vide ou null.
- ou -
Le modèle d'expression régulière d'un ou plusieurs objets de
regexinfos
contient une syntaxe non valide.
assemblyname
ou regexinfos
est null
.
.NET Core et .NET 5+ uniquement : la création d’un assembly d’expressions régulières compilées n’est pas prise en charge.
Exemples
L’exemple suivant crée un assembly nommé RegexLib.dll. L’assembly inclut deux expressions régulières compilées. Le premier, correspond Utilities.RegularExpressions.DuplicatedString
à deux mots contigus identiques. Deuxièmement, 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 en double 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 CompileToAssembly(RegexCompilationInfo[], AssemblyName) méthode génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le regexinfos
tableau est représentée par une classe. En règle générale, la CompileToAssembly(RegexCompilationInfo[], AssemblyName) méthode 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 Regex classe.
Il reçoit le nom complet défini par les paramètres et
name
lesfullnamespace
paramètres de son objet correspondantRegexCompilationInfo.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 CompileToAssembly(RegexCompilationInfo[], AssemblyName) méthode pour créer un assembly qui contient des expressions régulières compilées. La tentative d’utilisation de l’une des expressions régulières dans cet assembly sur un système avec .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez procéder de l'une des manières 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 Regex objet ou appelez une méthode de correspondance de modèle d’expression régulière.
Voir aussi
S’applique à
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
Attention
Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.
Compile un ou plusieurs objets Regex spécifiés dans un assembly nommé avec les attributs spécifiés.
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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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
- regexinfos
- RegexCompilationInfo[]
Tableau qui décrit les expressions régulières à compiler.
- assemblyname
- AssemblyName
Nom de fichier de l’assembly.
- attributes
- CustomAttributeBuilder[]
Tableau qui définit les attributs à appliquer à l'assembly.
- Attributs
Exceptions
La valeur de la propriété Name du paramètre assemblyname
est une chaîne vide ou null.
- ou -
Le modèle d'expression régulière d'un ou plusieurs objets de
regexinfos
contient une syntaxe non valide.
assemblyname
ou regexinfos
est null
.
.NET Core et .NET 5+ uniquement : la création d’un assembly d’expressions régulières compilées n’est pas prise en charge.
Exemples
L’exemple suivant crée un assembly nommé RegexLib.dll et lui applique l’attribut AssemblyTitleAttribute . L’assembly inclut deux expressions régulières compilées. Le premier, correspond Utilities.RegularExpressions.DuplicatedString
à deux mots contigus identiques. Deuxièmement, 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 en double 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 CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) méthode génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le regexinfos
tableau est représentée par une classe. En règle générale, la CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) méthode 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 Regex classe.
Il reçoit le nom complet défini par les paramètres et
name
lesfullnamespace
paramètres de son objet correspondantRegexCompilationInfo.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 CompileToAssembly méthode 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 exempleclass
, en C# ou Class
...End Class
dans Visual Basic), il n’autorise pas l’attribution d’attributs .NET Framework à l’assembly à l’aide de la syntaxe d’attribut standard du langage de développement. Le attributes
paramètre 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 :
Créez un tableau d’objets Type représentant les types de paramètres du constructeur d’attribut que vous souhaitez appeler.
Récupérez un Type objet représentant la classe d’attribut que vous souhaitez appliquer au nouvel assembly.
Appelez la GetConstructor méthode de l’objet d’attribut Type pour récupérer un ConstructorInfo objet représentant le constructeur d’attribut que vous souhaitez appeler. Transmettez la méthode au GetConstructor tableau d’objets Type qui représente les types de paramètres du constructeur.
Créez un Object tableau qui définit les paramètres à passer au constructeur de l’attribut.
Instanciez un CustomAttributeBuilder objet en passant son constructeur à l’objet récupéré à l’étape ConstructorInfo 3 et le tableau créé à l’étape Object 4.
Vous pouvez ensuite passer un tableau de ces CustomAttributeBuilder objets au lieu du attributes
paramètre à la Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) méthode.
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 CompileToAssembly(RegexCompilationInfo[], AssemblyName) méthode pour créer un assembly qui contient des expressions régulières compilées. La tentative d’utilisation de l’une des expressions régulières dans cet assembly sur un système avec .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez procéder de l'une des manières 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 Regex objet ou appelez une méthode de correspondance de modèle d’expression régulière.
Voir aussi
S’applique à
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
Attention
Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.
Compile un ou plusieurs objets Regex spécifiés et un fichier de ressources spécifié dans un assembly nommé avec les attributs spécifiés.
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 RegexGeneratorAttribute 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 RegexGeneratorAttribute 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
- regexinfos
- RegexCompilationInfo[]
Tableau qui décrit les expressions régulières à compiler.
- assemblyname
- AssemblyName
Nom de fichier de l’assembly.
- attributes
- CustomAttributeBuilder[]
Tableau qui définit les attributs à appliquer à l'assembly.
- resourceFile
- String
Nom du fichier de ressources Win32 à inclure dans l'assembly.
- Attributs
Exceptions
La valeur de la propriété Name du paramètre assemblyname
est une chaîne vide ou null.
- ou -
Le modèle d'expression régulière d'un ou plusieurs objets de
regexinfos
contient une syntaxe non valide.
assemblyname
ou regexinfos
est null
.
Le paramètre resourceFile
désigne un fichier ressource Win32 non valide.
Le fichier désigné par le paramètre resourceFile
est introuvable.
.NET Core et .NET 5+ uniquement : la création d’un assembly d’expressions régulières compilées n’est pas prise en charge.
Remarques
La CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) méthode génère un assembly .NET Framework dans lequel chaque expression régulière définie dans le regexinfos
tableau est représentée par une classe. En règle générale, la CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) méthode 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 Regex classe.
Il reçoit le nom complet défini par les paramètres et
name
lesfullnamespace
paramètres de son objet correspondantRegexCompilationInfo.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 CompileToAssembly méthode 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 exempleclass
, en C# ou Class
...End Class
dans Visual Basic), il n’autorise pas l’attribution d’attributs .NET Framework à l’assembly à l’aide de la syntaxe d’attribut standard du langage de développement. Le attributes
paramètre 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 :
Créez un tableau d’objets Type représentant les types de paramètres du constructeur d’attribut que vous souhaitez appeler.
Récupérez un Type objet représentant la classe d’attribut que vous souhaitez appliquer au nouvel assembly.
Appelez la GetConstructor méthode de l’objet d’attribut Type pour récupérer un ConstructorInfo objet représentant le constructeur d’attribut que vous souhaitez appeler. Passez la méthode au GetConstructor tableau d’objets Type qui représente les types de paramètres du constructeur
Créez un Object tableau qui définit les paramètres à passer au constructeur de l’attribut.
Instanciez un CustomAttributeBuilder objet en passant son constructeur à l’objet récupéré à l’étape ConstructorInfo 3 et le tableau créé à l’étape Object 4.
Vous pouvez ensuite passer un tableau de ces CustomAttributeBuilder objets au lieu du attributes
paramètre à la CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) méthode.
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 CompileToAssembly(RegexCompilationInfo[], AssemblyName) méthode pour créer un assembly qui contient des expressions régulières compilées. La tentative d’utilisation de l’une des expressions régulières dans cet assembly sur un système avec .NET Framework 4 lève une exception. Pour contourner ce problème, vous pouvez procéder de l'une des manières 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 Regex objet ou appelez une méthode de correspondance de modèle d’expression régulière.