Regex.CompileToAssembly Methode

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Kompiliert reguläre Ausdrücke und speichert diese in einer einzelnen Assembly auf der Festplatte.

Überlädt

CompileToAssembly(RegexCompilationInfo[], AssemblyName)	Veraltet. Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])	Veraltet. Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly mit den angegebenen Attributen.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)	Veraltet. Kompiliert ein oder mehrere angegebene Regex-Objekte und eine angegebene Ressourcendatei in eine benannte Assembly mit den angegebenen Attributen.

Hinweise

Hinweis

Bei .NET Core und .NET 5+wird eine Regex.CompileToAssembly PlatformNotSupportedExceptionAufrufe der Methode ausgelöst. Das Schreiben einer Assembly wird nicht unterstützt.

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Achtung

Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly.

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)

Parameter

regexinfos: RegexCompilationInfo[]

Ein Array, das die zu kompilierenden regulären Ausdrücke beschreibt.

assemblyname: AssemblyName

Der Dateiname der Assembly.

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentException

Der Wert der Name-Eigenschaft des assemblyname-Parameters ist eine leere oder eine NULL-Zeichenfolge.

- oder - Das Muster des regulären Ausdrucks eines oder mehrerer Objekte in regexinfos enthält eine ungültige Syntax.

ArgumentNullException

assemblyname oder regexinfos ist null.

PlatformNotSupportedException

.NET Core und .NET 5+ nur: Erstellen einer Assembly kompilierter regulärer Ausdrücke wird nicht unterstützt.

Beispiele

Im folgenden Beispiel wird eine Assembly mit dem Namen RegexLib.dll erstellt. Die Assembly enthält zwei kompilierte reguläre Ausdrücke. Der erste, , Utilities.RegularExpressions.DuplicatedStringentspricht zwei identischen zusammenhängenden Wörtern. Die zweite, , Utilities.RegularExpressions.EmailAddressüberprüft, ob eine Zeichenfolge das richtige Format hat, um eine E-Mail-Adresse zu sein.

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

Der reguläre Ausdruck, der eine Zeichenfolge für doppelte Wörter überprüft, wird dann instanziiert und von dem folgenden Beispiel verwendet.

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

Die erfolgreiche Kompilierung dieses zweiten Beispiels erfordert einen Verweis auf RegexLib.dll (die assembly, die vom ersten Beispiel erstellt wurde), die dem Projekt hinzugefügt werden soll.

Hinweise

Die CompileToAssembly(RegexCompilationInfo[], AssemblyName) Methode generiert eine .NET Framework Assembly, in der regexinfos jeder im Array definierte reguläre Ausdruck durch eine Klasse dargestellt wird. In der Regel wird die CompileToAssembly(RegexCompilationInfo[], AssemblyName) Methode aus einer separaten Anwendung aufgerufen, die eine Assembly kompilierter regulärer Ausdrücke generiert. Jeder in der Assembly enthaltene reguläre Ausdruck weist die folgenden Merkmale auf:

Es wird aus der Regex Klasse abgeleitet.
Es wird dem vollqualifizierten Namen zugewiesen, der durch die und name die fullnamespace Parameter des entsprechenden RegexCompilationInfo Objekts definiert wird.
Es verfügt über einen Standardkonstruktor (oder einen parameterlosen) Konstruktor.

Ordinarily, der Code, der den kompilierten regulären Ausdruck instanziiert und verwendet, wird in einer Assembly oder Anwendung gefunden, die von dem Code getrennt ist, der die Assembly erstellt.

Hinweise für Aufrufer

Wenn Sie auf einem System entwickeln, das .NET Framework 4.5 oder dessen Punktversionen installiert hat, zielen Sie auf .NET Framework 4 und verwenden die Methode, um eine Assembly zu erstellen, die CompileToAssembly(RegexCompilationInfo[], AssemblyName) kompilierte reguläre Ausdrücke enthält. Wenn Sie versuchen, einen der regulären Ausdrücke in dieser Assembly auf einem System zu verwenden, das .NET Framework 4 enthält, wird eine Ausnahme ausgelöst. Um dieses Problem zu umgehen, haben Sie die folgenden Möglichkeiten:

Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke auf einem System enthält, das .NET Framework 4 anstelle von späteren Versionen installiert ist.

CompileToAssembly(RegexCompilationInfo[], AssemblyName)- Anstatt den kompilierten regulären Ausdruck aus einer Assembly abzurufen, verwenden Sie entweder statische oder Instanzmethoden Regex mit der Compiled Option, wenn Sie ein Regex Objekt instanziieren oder eine reguläre Ausdrucksmusterabgleichsmethode aufrufen.

Siehe auch

Kompilierung und Wiederverwendung

Gilt für

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Achtung

Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly mit den angegebenen Attributen.

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

Parameter

regexinfos: RegexCompilationInfo[]

Ein Array, das die zu kompilierenden regulären Ausdrücke beschreibt.

assemblyname: AssemblyName

Der Dateiname der Assembly.

attributes: CustomAttributeBuilder[]

Ein Array, das die auf die Assembly anzuwendenden Attribute definiert.

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentException

Der Wert der Name-Eigenschaft des assemblyname-Parameters ist eine leere oder eine NULL-Zeichenfolge.

- oder - Das Muster des regulären Ausdrucks eines oder mehrerer Objekte in regexinfos enthält eine ungültige Syntax.

ArgumentNullException

assemblyname oder regexinfos ist null.

PlatformNotSupportedException

.NET Core und .NET 5+ nur: Erstellen einer Assembly kompilierter regulärer Ausdrücke wird nicht unterstützt.

Beispiele

Im folgenden Beispiel wird eine Assembly mit dem Namen RegexLib.dll erstellt und das AssemblyTitleAttribute Attribut darauf angewendet. Die Assembly enthält zwei kompilierte reguläre Ausdrücke. Der erste, , Utilities.RegularExpressions.DuplicatedStringentspricht zwei identischen zusammenhängenden Wörtern. Die zweite, , Utilities.RegularExpressions.EmailAddressüberprüft, ob eine Zeichenfolge das richtige Format hat, um eine E-Mail-Adresse zu sein.

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

Sie können überprüfen, ob das Attribut auf die AssemblyTitleAttribute Assembly angewendet wurde, indem Sie ihr Manifest mit einem Spiegelungsprogramm wie ILDasm untersuchen.

Der reguläre Ausdruck, der eine Zeichenfolge für doppelte Wörter überprüft, wird dann instanziiert und von dem folgenden Beispiel verwendet.

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

Die erfolgreiche Kompilierung dieses zweiten Beispiels erfordert einen Verweis auf RegexLib.dll (die assembly, die vom ersten Beispiel erstellt wurde), die dem Projekt hinzugefügt werden soll.

Hinweise

Die CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) Methode generiert eine .NET Framework Assembly, in der regexinfos jeder im Array definierte reguläre Ausdruck durch eine Klasse dargestellt wird. In der Regel wird die CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) Methode aus einer separaten Anwendung aufgerufen, die eine Assembly kompilierter regulärer Ausdrücke generiert. Jeder in der Assembly enthaltene reguläre Ausdruck weist die folgenden Merkmale auf:

Es wird aus der Regex Klasse abgeleitet.
Es wird dem vollqualifizierten Namen zugewiesen, der durch die und name die fullnamespace Parameter des entsprechenden RegexCompilationInfo Objekts definiert wird.
Es verfügt über einen Standardkonstruktor (oder einen parameterlosen) Konstruktor.

Ordinarily, der Code, der den kompilierten regulären Ausdruck instanziiert und verwendet, wird in einer Assembly oder Anwendung gefunden, die von dem Code getrennt ist, der die Assembly erstellt.

Da die CompileToAssembly Methode eine .NET Framework Assembly aus einem Methodenaufruf generiert, anstatt das Klassendefinitionswort einer bestimmten Sprache (zclass. B. in C# oder Class...End Class in Visual Basic) zu verwenden, kann .NET Framework Attribute nicht der Assembly zugewiesen werden, indem die Standardattributsyntax der Entwicklungssprache verwendet wird. Der attributes Parameter stellt eine alternative Methode zum Definieren der Attribute bereit, die für die Assembly gelten. Führen Sie für jedes Attribut, das Sie für die Assembly anwenden möchten, folgendes aus:

Erstellen Sie ein Array von Type Objekten, die die Parametertypen des Attributkonstruktors darstellen, die Sie aufrufen möchten.
Rufen Sie ein Type Objekt ab, das die Attributklasse darstellt, die Sie auf die neue Assembly anwenden möchten.
Rufen Sie die GetConstructor Methode des Attributobjekts Type auf, um ein ConstructorInfo Objekt abzurufen, das den Attributkonstruktor darstellt, den Sie aufrufen möchten. Übergeben Sie die Methode an das GetConstructor Array von Type Objekten, die die Parametertypen des Konstruktors darstellen.
Erstellen Sie ein Object Array, das die Parameter definiert, die an den Konstruktor des Attributs übergeben werden sollen.
Instanziieren Sie ein CustomAttributeBuilder Objekt, indem Sie den Konstruktor übergeben, das ConstructorInfo in Schritt 3 abgerufen wurde und das Object Array in Schritt 4 erstellt wurde.

Anschließend können Sie ein Array dieser CustomAttributeBuilder Objekte anstelle des attributes Parameters an die Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) Methode übergeben.

Hinweise für Aufrufer

Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke auf einem System enthält, das .NET Framework 4 anstelle von späteren Versionen installiert ist.

Siehe auch

Kompilierung und Wiederverwendung

Gilt für

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Achtung

Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.

Kompiliert ein oder mehrere angegebene Regex-Objekte und eine angegebene Ressourcendatei in eine benannte Assembly mit den angegebenen Attributen.

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)

Parameter

regexinfos: RegexCompilationInfo[]

Ein Array, das die zu kompilierenden regulären Ausdrücke beschreibt.

assemblyname: AssemblyName

Der Dateiname der Assembly.

attributes: CustomAttributeBuilder[]

Ein Array, das die auf die Assembly anzuwendenden Attribute definiert.

resourceFile: String

Der Name der in die Assembly einzufügenden Win32-Ressourcendatei.

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentException

Der Wert der Name-Eigenschaft des assemblyname-Parameters ist eine leere oder eine NULL-Zeichenfolge.

- oder - Das Muster des regulären Ausdrucks eines oder mehrerer Objekte in regexinfos enthält eine ungültige Syntax.

ArgumentNullException

assemblyname oder regexinfos ist null.

COMException

Der resourceFile-Parameter legt eine ungültige Win32-Ressourcendatei fest.

FileNotFoundException

Die vom resourceFile-Parameter angegebene Datei kann nicht gefunden werden.

PlatformNotSupportedException

.NET Core und .NET 5+ nur: Erstellen einer Assembly kompilierter regulärer Ausdrücke wird nicht unterstützt.

Hinweise

Die CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) Methode generiert eine .NET Framework Assembly, in der regexinfos jeder im Array definierte reguläre Ausdruck durch eine Klasse dargestellt wird. In der Regel wird die CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) Methode aus einer separaten Anwendung aufgerufen, die eine Assembly kompilierter regulärer Ausdrücke generiert. Jeder in der Assembly enthaltene reguläre Ausdruck weist die folgenden Merkmale auf:

Es wird aus der Regex Klasse abgeleitet.
Es wird dem vollqualifizierten Namen zugewiesen, der durch die und name die fullnamespace Parameter des entsprechenden RegexCompilationInfo Objekts definiert wird.
Es verfügt über einen Standardkonstruktor (oder einen parameterlosen) Konstruktor.

Ordinarily, der Code, der den kompilierten regulären Ausdruck instanziiert und verwendet, wird in einer Assembly oder Anwendung gefunden, die von dem Code getrennt ist, der die Assembly erstellt.

Erstellen Sie ein Array von Type Objekten, die die Parametertypen des Attributkonstruktors darstellen, die Sie aufrufen möchten.
Rufen Sie ein Type Objekt ab, das die Attributklasse darstellt, die Sie auf die neue Assembly anwenden möchten.
Rufen Sie die GetConstructor Methode des Attributobjekts Type auf, um ein ConstructorInfo Objekt abzurufen, das den Attributkonstruktor darstellt, den Sie aufrufen möchten. Übergeben Sie die Methode an das GetConstructor Array von Type Objekten, die die Parametertypen des Konstruktors darstellen.
Erstellen Sie ein Object Array, das die Parameter definiert, die an den Konstruktor des Attributs übergeben werden sollen.
Instanziieren Sie ein CustomAttributeBuilder Objekt, indem Sie den Konstruktor übergeben, das ConstructorInfo in Schritt 3 abgerufen wurde und das Object Array in Schritt 4 erstellt wurde.

Anschließend können Sie ein Array dieser CustomAttributeBuilder Objekte anstelle des attributes Parameters an die CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) Methode übergeben.

Hinweise für Aufrufer

Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke auf einem System enthält, das .NET Framework 4 anstelle von späteren Versionen installiert ist.

Siehe auch

Kompilierung und Wiederverwendung

Gilt für

Regex.CompileToAssembly Methode

Definition

Überlädt

Hinweise

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Parameter

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

Parameter

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

Parameter

Ausnahmen

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

Zusätzliche Ressourcen