Regex.CompileToAssembly Methode

Definition

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

Überlädt

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

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

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

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

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

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

Hinweise

Hinweis

In .NET Core und .NET 5 und mehr löst Aufrufe der Regex.CompileToAssembly -Methode eine PlatformNotSupportedException aus. Das Schreiben einer Assembly wird nicht unterstützt.

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

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

Ausnahmen

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.

assemblyname oder regexinfos ist null.

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

Beispiele

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

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 auf doppelte Wörter überprüft, wird dann instanziiert und im 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, dass dem Projekt ein Verweis auf RegexLib.dll (die im ersten Beispiel erstellte Assembly) hinzugefügt wird.

Hinweise

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

  • Sie wird von der -Klasse Regex abgeleitet.

  • Ihm wird der vollqualifizierte Name zugewiesen, der durch die Parameter fullnamespace und des entsprechenden Objekts definiert name RegexCompilationInfo wird.

  • Sie verfügt über einen Standardkonstruktor (oder parameterlosen Konstruktor).

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

Hinweise für Aufrufer

Wenn Sie auf einem System entwickeln, auf dem .NET Framework 4.5 oder dessen Punktversionen installiert sind, verwenden Sie .NET Framework 4 als Ziel, und Sie verwenden die -Methode, um eine Assembly zu erstellen, die kompilierte reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) enthält. Der Versuch, einen der regulären Ausdrücke in dieser Assembly auf einem System zu verwenden, das .NET Framework 4 hat, löst eine Ausnahme aus. Um dieses Problem zu umgehen, haben Sie die folgenden Möglichkeiten: – Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke enthält, auf einem System, auf dem .NET Framework 4 anstelle von neueren Versionen installiert ist.

– Anstatt den kompilierten regulären Ausdruck aus einer Assembly auf- und abrufen zu müssen, verwenden Sie entweder statische methoden oder Instanzmethoden mit der -Option, wenn Sie ein -Objekt instanziieren oder eine Musterabgleichsmethode für reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) Regex Compiled Regex aufrufen.

Siehe auch

Gilt für

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

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

Ausnahmen

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.

assemblyname oder regexinfos ist null.

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

Beispiele

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

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 Assembly angewendet wurde, indem Sie das Manifest mit einem Reflektions-Hilfsprogramm wie AssemblyTitleAttribute ILDasm untersuchen.

Der reguläre Ausdruck, der eine Zeichenfolge auf doppelte Wörter überprüft, wird dann instanziiert und im 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, dass dem Projekt ein Verweis auf RegexLib.dll (die im ersten Beispiel erstellte Assembly) hinzugefügt wird.

Hinweise

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

  • Sie wird von der -Klasse Regex abgeleitet.

  • Ihm wird der vollqualifizierte Name zugewiesen, der durch die Parameter fullnamespace und des entsprechenden Objekts definiert name RegexCompilationInfo wird.

  • Sie verfügt über einen Standardkonstruktor (oder parameterlosen Konstruktor).

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

Da die -Methode eine .NET Framework-Assembly aus einem Methodenaufruf generiert, anstatt das Klassendefinitionsschlüsselwort einer bestimmten Sprache zu verwenden (z. B. in C# oder ... in Visual Basic), lässt sie nicht zu, dass CompileToAssembly .NET Framework-Attribute der Assembly mithilfe der Standardattributsyntax der Entwicklungssprache zugewiesen class Class End Class werden. Der attributes -Parameter stellt eine alternative Methode zum Definieren der Attribute dar, die für die Assembly gelten. Führen Sie für jedes Attribut, das Sie auf die Assembly anwenden möchten, folgende Schritte aus:

  1. Erstellen Sie ein Array von Type -Objekten, das die Parametertypen des Attributkonstruktors darstellt, den Sie aufrufen möchten.

  2. Rufen Sie ein Type -Objekt ab, das die Attributklasse darstellt, die Sie auf die neue Assembly anwenden möchten.

  3. Rufen Sie die GetConstructor -Methode des Type Attributobjekts auf, um ein ConstructorInfo -Objekt abzurufen, das den Attributkonstruktor darstellt, den Sie aufrufen möchten. Übergeben Sie GetConstructor der -Methode das Array von Type -Objekten, das die Parametertypen des Konstruktors darstellt.

  4. Erstellen Sie Object ein Array, das die Parameter definiert, die an den Konstruktor des Attributs übergeben werden.

  5. Instanziieren Sie ein -Objekt, indem Sie seinen Konstruktor, das in Schritt 3 abgerufene Objekt und das in Schritt 4 erstellte CustomAttributeBuilder ConstructorInfo Array Object übergeben.

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

Hinweise für Aufrufer

Wenn Sie auf einem System entwickeln, auf dem .NET Framework 4.5 oder dessen Punktversionen installiert sind, verwenden Sie .NET Framework 4 als Ziel, und Sie verwenden die -Methode, um eine Assembly zu erstellen, die kompilierte reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) enthält. Der Versuch, einen der regulären Ausdrücke in dieser Assembly auf einem System zu verwenden, das .NET Framework 4 hat, löst eine Ausnahme aus. Um dieses Problem zu umgehen, haben Sie die folgenden Möglichkeiten: – Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke enthält, auf einem System, auf dem .NET Framework 4 anstelle von neueren Versionen installiert ist.

– Anstatt den kompilierten regulären Ausdruck aus einer Assembly auf- und abrufen zu müssen, verwenden Sie entweder statische methoden oder Instanzmethoden mit der -Option, wenn Sie ein -Objekt instanziieren oder eine Musterabgleichsmethode für reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) Regex Compiled Regex aufrufen.

Siehe auch

Gilt für

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

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

Ausnahmen

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.

assemblyname oder regexinfos ist null.

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

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

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

Hinweise

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

  • Sie wird von der -Klasse Regex abgeleitet.

  • Ihm wird der vollqualifizierte Name zugewiesen, der durch die Parameter fullnamespace und des entsprechenden Objekts definiert name RegexCompilationInfo wird.

  • Sie verfügt über einen Standardkonstruktor (oder parameterlosen Konstruktor).

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

Da die -Methode eine .NET Framework-Assembly aus einem Methodenaufruf generiert, anstatt das Klassendefinitionsschlüsselwort einer bestimmten Sprache zu verwenden (z. B. in C# oder ... in Visual Basic), lässt sie nicht zu, dass CompileToAssembly .NET Framework-Attribute der Assembly mithilfe der Standardattributsyntax der Entwicklungssprache zugewiesen class Class End Class werden. Der attributes -Parameter stellt eine alternative Methode zum Definieren der Attribute dar, die für die Assembly gelten. Führen Sie für jedes Attribut, das Sie auf die Assembly anwenden möchten, folgende Schritte aus:

  1. Erstellen Sie ein Array von Type -Objekten, das die Parametertypen des Attributkonstruktors darstellt, den Sie aufrufen möchten.

  2. Rufen Sie ein Type -Objekt ab, das die Attributklasse darstellt, die Sie auf die neue Assembly anwenden möchten.

  3. Rufen Sie die GetConstructor -Methode des Type Attributobjekts auf, um ein ConstructorInfo -Objekt abzurufen, das den Attributkonstruktor darstellt, den Sie aufrufen möchten. Übergeben Sie GetConstructor der -Methode das Array von Type -Objekten, das die Parametertypen des Konstruktors darstellt.

  4. Erstellen Sie Object ein Array, das die Parameter definiert, die an den Konstruktor des Attributs übergeben werden.

  5. Instanziieren Sie ein -Objekt, indem Sie seinen Konstruktor, das in Schritt 3 abgerufene Objekt und das in Schritt 4 erstellte CustomAttributeBuilder ConstructorInfo Array Object übergeben.

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

Hinweise für Aufrufer

Wenn Sie auf einem System entwickeln, auf dem .NET Framework 4.5 oder dessen Punktversionen installiert sind, verwenden Sie .NET Framework 4 als Ziel, und Sie verwenden die -Methode, um eine Assembly zu erstellen, die kompilierte reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) enthält. Der Versuch, einen der regulären Ausdrücke in dieser Assembly auf einem System zu verwenden, das .NET Framework 4 hat, löst eine Ausnahme aus. Um dieses Problem zu umgehen, haben Sie die folgenden Möglichkeiten: – Erstellen Sie die Assembly, die die kompilierten regulären Ausdrücke enthält, auf einem System, auf dem .NET Framework 4 anstelle von neueren Versionen installiert ist.

– Anstatt den kompilierten regulären Ausdruck aus einer Assembly auf- und abrufen zu müssen, verwenden Sie entweder statische methoden oder Instanzmethoden mit der -Option, wenn Sie ein -Objekt instanziieren oder eine Musterabgleichsmethode für reguläre Ausdrücke CompileToAssembly(RegexCompilationInfo[], AssemblyName) Regex Compiled Regex aufrufen.

Siehe auch

Gilt für