Regex.CompileToAssembly Methode

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

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

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

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] * string -> unit

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)

Parameters

Kenmerken

ObsoleteAttribute

Uitzonderingen

Opmerkingen

De methode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) genereert een .NET Framework-assembly waarin elke reguliere expressie die is gedefinieerd in de regexinfos-matrix wordt vertegenwoordigd door een klasse. Normaal gesproken wordt de CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) methode aangeroepen vanuit een afzonderlijke toepassing waarmee een assembly van gecompileerde reguliere expressies wordt gegenereerd. Elke reguliere expressie die in de assembly is opgenomen, heeft de volgende kenmerken:

• Het is afgeleid van de Regex klasse.

• Deze wordt de volledig gekwalificeerde naam toegewezen die is gedefinieerd door de fullnamespace en name parameters van het bijbehorende RegexCompilationInfo object.

• Het heeft een standaardconstructor (of parameterloos).

Normaal gesproken wordt de code die de gecompileerde reguliere expressie instanteert en gebruikt, gevonden in een assembly of toepassing die losstaat van de code waarmee de assembly wordt gemaakt.

Omdat de methode CompileToAssembly een .NET Framework-assembly genereert vanuit een methode-aanroep in plaats van een trefwoord voor de klassedefinitie van een bepaalde taal te gebruiken (zoals class in C# of Class... End Class in Visual Basic), kunnen .NET Framework-kenmerken niet worden toegewezen aan de assembly met behulp van de standaardkenmerksyntaxis van de ontwikkeltaal. De attributes parameter biedt een alternatieve methode voor het definiëren van de kenmerken die van toepassing zijn op de assembly. Ga als volgt te werk voor elk kenmerk dat u wilt toepassen op de assembly:

1. Maak een matrix met Type objecten die de parametertypen van de kenmerkconstructor vertegenwoordigen die u wilt aanroepen.

2. Haal een Type object op dat de kenmerkklasse vertegenwoordigt die u wilt toepassen op de nieuwe assembly.

3. Roep de GetConstructor methode van het kenmerkobject Type aan om een ConstructorInfo object op te halen dat de kenmerkconstructor vertegenwoordigt die u wilt aanroepen. Geef de methode door aan de GetConstructor matrix van objecten die de parametertypen van Type de constructor vertegenwoordigen

4. Maak een Object matrix die de parameters definieert die moeten worden doorgegeven aan de constructor van het kenmerk.

5. Instantieer een CustomAttributeBuilder object door de constructor door te geven aan het ConstructorInfo object dat is opgehaald in stap 3 en de Object matrix die in stap 4 is gemaakt.

Vervolgens kunt u een matrix van deze CustomAttributeBuilder objecten doorgeven in plaats van de attributes parameter aan de CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) methode.

Notities voor bellers

Als u ontwikkelt op een systeem waarop .NET Framework 4.5 of de puntreleases zijn geïnstalleerd, richt u zich op .NET Framework 4 en gebruikt u de methode CompileToAssembly(RegexCompilationInfo[], AssemblyName) om een assembly te maken die gecompileerde reguliere expressies bevat. Als u een van de reguliere expressies in die assembly wilt gebruiken op een systeem met .NET Framework 4, wordt er een uitzondering gegenereerd. U kunt dit probleem omzeilen door een van de volgende handelingen uit te voeren:

• Bouw de assembly die de gecompileerde reguliere expressies bevat op een systeem waarop .NET Framework 4 is geïnstalleerd in plaats van latere versies.

• Gebruik in plaats van de gecompileerde reguliere expressie van een assembly aan te roepen CompileToAssembly(RegexCompilationInfo[], AssemblyName) en op te halen, statische methoden of exemplaarmethoden Regex met de Compiled optie wanneer u een Regex object instantieert of een reguliere expressiepatroonkoppelingsmethode aanroept.

Zie ook

• Compilatie en hergebruik

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

public:
 static void CompileToAssembly(cli::array <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);

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName -> unit

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

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

Parameters

Kenmerken

ObsoleteAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt een assembly met de naam RegexLib.dllgemaakt. De assembly bevat twee gecompileerde reguliere expressies. De eerste, Utilities.RegularExpressions.DuplicatedStringkomt overeen met twee identieke aaneengesloten woorden. De tweede, Utilities.RegularExpressions.EmailAddresscontroleert of een tekenreeks de juiste indeling heeft om een e-mailadres te zijn.

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

De reguliere expressie waarmee een tekenreeks wordt gecontroleerd op dubbele woorden, wordt vervolgens geïnstantieerd en gebruikt in het volgende voorbeeld.

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

Voor een geslaagde compilatie van dit tweede voorbeeld moet een verwijzing naar RegexLib.dll (de assembly die door het eerste voorbeeld is gemaakt) aan het project worden toegevoegd.

Opmerkingen

De methode CompileToAssembly(RegexCompilationInfo[], AssemblyName) genereert een .NET Framework-assembly waarin elke reguliere expressie die is gedefinieerd in de regexinfos-matrix wordt vertegenwoordigd door een klasse. Normaal gesproken wordt de CompileToAssembly(RegexCompilationInfo[], AssemblyName) methode aangeroepen vanuit een afzonderlijke toepassing waarmee een assembly van gecompileerde reguliere expressies wordt gegenereerd. Elke reguliere expressie die in de assembly is opgenomen, heeft de volgende kenmerken:

• Het is afgeleid van de Regex klasse.

• Deze wordt de volledig gekwalificeerde naam toegewezen die is gedefinieerd door de fullnamespace en name parameters van het bijbehorende RegexCompilationInfo object.

• Het heeft een standaardconstructor (of parameterloos).

Normaal gesproken wordt de code die de gecompileerde reguliere expressie instanteert en gebruikt, gevonden in een assembly of toepassing die losstaat van de code waarmee de assembly wordt gemaakt.

Notities voor bellers

Als u ontwikkelt op een systeem waarop .NET Framework 4.5 of de puntreleases zijn geïnstalleerd, richt u zich op .NET Framework 4 en gebruikt u de methode CompileToAssembly(RegexCompilationInfo[], AssemblyName) om een assembly te maken die gecompileerde reguliere expressies bevat. Als u een van de reguliere expressies in die assembly wilt gebruiken op een systeem met .NET Framework 4, wordt er een uitzondering gegenereerd. U kunt dit probleem omzeilen door een van de volgende handelingen uit te voeren:

• Bouw de assembly die de gecompileerde reguliere expressies bevat op een systeem waarop .NET Framework 4 is geïnstalleerd in plaats van latere versies.

• Gebruik in plaats van de gecompileerde reguliere expressie van een assembly aan te roepen CompileToAssembly(RegexCompilationInfo[], AssemblyName) en op te halen, statische methoden of exemplaarmethoden Regex met de Compiled optie wanneer u een Regex object instantieert of een reguliere expressiepatroonkoppelingsmethode aanroept.

Zie ook

• Compilatie en hergebruik

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

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

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}")>]
static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo[] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder[] -> unit

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

Parameters

Kenmerken

ObsoleteAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt een assembly met de naam RegexLib.dll gemaakt en wordt het AssemblyTitleAttribute kenmerk hierop toegepast. De assembly bevat twee gecompileerde reguliere expressies. De eerste, Utilities.RegularExpressions.DuplicatedStringkomt overeen met twee identieke aaneengesloten woorden. De tweede, Utilities.RegularExpressions.EmailAddresscontroleert of een tekenreeks de juiste indeling heeft om een e-mailadres te zijn.

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

U kunt controleren of het AssemblyTitleAttribute kenmerk is toegepast op de assembly door het manifest ervan te controleren met een weerspiegelingshulpprogramma zoals ILDasm.

De reguliere expressie waarmee een tekenreeks wordt gecontroleerd op dubbele woorden, wordt vervolgens geïnstantieerd en gebruikt in het volgende voorbeeld.

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

Voor een geslaagde compilatie van dit tweede voorbeeld moet een verwijzing naar RegexLib.dll (de assembly die door het eerste voorbeeld is gemaakt) aan het project worden toegevoegd.

Opmerkingen

De methode CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) genereert een .NET Framework-assembly waarin elke reguliere expressie die is gedefinieerd in de regexinfos-matrix wordt vertegenwoordigd door een klasse. Normaal gesproken wordt de CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) methode aangeroepen vanuit een afzonderlijke toepassing waarmee een assembly van gecompileerde reguliere expressies wordt gegenereerd. Elke reguliere expressie die in de assembly is opgenomen, heeft de volgende kenmerken:

• Het is afgeleid van de Regex klasse.

• Deze wordt de volledig gekwalificeerde naam toegewezen die is gedefinieerd door de fullnamespace en name parameters van het bijbehorende RegexCompilationInfo object.

• Het heeft een standaardconstructor (of parameterloos).

Normaal gesproken wordt de code die de gecompileerde reguliere expressie instanteert en gebruikt, gevonden in een assembly of toepassing die losstaat van de code waarmee de assembly wordt gemaakt.

Omdat de methode CompileToAssembly een .NET Framework-assembly genereert vanuit een methode-aanroep in plaats van een trefwoord voor de klassedefinitie van een bepaalde taal te gebruiken (zoals class in C# of Class... End Class in Visual Basic), kunnen .NET Framework-kenmerken niet worden toegewezen aan de assembly met behulp van de standaardkenmerksyntaxis van de ontwikkeltaal. De attributes parameter biedt een alternatieve methode voor het definiëren van de kenmerken die van toepassing zijn op de assembly. Ga als volgt te werk voor elk kenmerk dat u wilt toepassen op de assembly:

1. Maak een matrix met Type objecten die de parametertypen van de kenmerkconstructor vertegenwoordigen die u wilt aanroepen.

2. Haal een Type object op dat de kenmerkklasse vertegenwoordigt die u wilt toepassen op de nieuwe assembly.

3. Roep de GetConstructor methode van het kenmerkobject Type aan om een ConstructorInfo object op te halen dat de kenmerkconstructor vertegenwoordigt die u wilt aanroepen. Geef de methode door aan de GetConstructor matrix van objecten die de parametertypen van Type de constructor vertegenwoordigen.

4. Maak een Object matrix die de parameters definieert die moeten worden doorgegeven aan de constructor van het kenmerk.

5. Instantieer een CustomAttributeBuilder object door de constructor door te geven aan het ConstructorInfo object dat is opgehaald in stap 3 en de Object matrix die in stap 4 is gemaakt.

Vervolgens kunt u een matrix van deze CustomAttributeBuilder objecten doorgeven in plaats van de attributes parameter aan de Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) methode.

Notities voor bellers

Als u ontwikkelt op een systeem waarop .NET Framework 4.5 of de puntreleases zijn geïnstalleerd, richt u zich op .NET Framework 4 en gebruikt u de methode CompileToAssembly(RegexCompilationInfo[], AssemblyName) om een assembly te maken die gecompileerde reguliere expressies bevat. Als u een van de reguliere expressies in die assembly wilt gebruiken op een systeem met .NET Framework 4, wordt er een uitzondering gegenereerd. U kunt dit probleem omzeilen door een van de volgende handelingen uit te voeren:

• Bouw de assembly die de gecompileerde reguliere expressies bevat op een systeem waarop .NET Framework 4 is geïnstalleerd in plaats van latere versies.

• Gebruik in plaats van de gecompileerde reguliere expressie van een assembly aan te roepen CompileToAssembly(RegexCompilationInfo[], AssemblyName) en op te halen, statische methoden of exemplaarmethoden Regex met de Compiled optie wanneer u een Regex object instantieert of een reguliere expressiepatroonkoppelingsmethode aanroept.

Zie ook

• Compilatie en hergebruik