Regex.CompileToAssembly Metod

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

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)

Parametrar

Attribut

ObsoleteAttribute

Undantag

Kommentarer

Metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) genererar en .NET Framework-sammansättning där varje reguljärt uttryck som definieras i matrisen regexinfos representeras av en klass. CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) Vanligtvis anropas metoden från ett separat program som genererar en sammansättning av kompilerade reguljära uttryck. Varje reguljärt uttryck som ingår i sammansättningen har följande egenskaper:

• Den härleds från Regex klassen.

• Det tilldelas det fullständigt kvalificerade namnet som definieras av parametrarna fullnamespace och name för motsvarande RegexCompilationInfo objekt.

• Den har en standardkonstruktor (eller parameterlös) konstruktor.

Vanligtvis finns koden som instansierar och använder det kompilerade reguljära uttrycket i en sammansättning eller ett program som är separat från koden som skapar sammansättningen.

Eftersom metoden CompileToAssembly genererar en .NET Framework-sammansättning från ett metodanrop i stället för att använda ett visst språks nyckelord för klassdefinition (till exempel class i C# eller Class... End Class i Visual Basic) tillåter det inte att .NET Framework-attribut tilldelas till sammansättningen med hjälp av standardattributsyntaxen för utvecklingsspråket. Parametern attributes innehåller en alternativ metod för att definiera de attribut som gäller för sammansättningen. Gör följande för varje attribut som du vill använda för sammansättningen:

1. Skapa en matris med Type objekt som representerar parametertyperna för attributkonstruktorn som du vill anropa.

2. Hämta ett Type objekt som representerar attributklassen som du vill använda för den nya sammansättningen.

3. GetConstructor Anropa -metoden för attributobjektet Type för att hämta ett ConstructorInfo objekt som representerar attributkonstruktorn som du vill anropa. GetConstructor Skicka metoden till matrisen med Type objekt som representerar konstruktorns parametertyper

4. Skapa en Object matris som definierar parametrarna som ska skickas till attributets konstruktor.

5. Instansiera ett CustomAttributeBuilder objekt genom att skicka konstruktorn objektet ConstructorInfo som hämtades i steg 3 och matrisen Object som skapades i steg 4.

Du kan sedan skicka en matris med dessa CustomAttributeBuilder objekt i stället för parametern attributes till CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) metoden.

Anteckningar till anropare

Om du utvecklar på ett system som har .NET Framework 4.5 eller dess punktversioner installerade, riktar du dig mot .NET Framework 4 och använder metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName) för att skapa en sammansättning som innehåller kompilerade reguljära uttryck. Om du försöker använda ett av de reguljära uttrycken i sammansättningen i ett system som har .NET genererar Framework 4 ett undantag. Du kan lösa det här problemet genom att göra något av följande:

• Skapa sammansättningen som innehåller de kompilerade reguljära uttrycken i ett system som har .NET Framework 4 i stället för senare versioner installerade.

• I stället för att anropa CompileToAssembly(RegexCompilationInfo[], AssemblyName) och hämta det kompilerade reguljära uttrycket från en sammansättning använder du antingen statiska metoder eller instansmetoder Regex med Compiled alternativet när du instansierar ett Regex objekt eller anropar en mönstermatchningsmetod för reguljära uttryck.

Se även

• Kompilering och återanvändning

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

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)

Parametrar

Attribut

ObsoleteAttribute

Undantag

Exempel

I följande exempel skapas en sammansättning med namnet RegexLib.dll. Sammansättningen innehåller två kompilerade reguljära uttryck. Den första, Utilities.RegularExpressions.DuplicatedString, matchar två identiska sammanhängande ord. Den andra, Utilities.RegularExpressions.EmailAddress, kontrollerar om en sträng har rätt format för att vara en e-postadress.

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

Det reguljära uttrycket som kontrollerar en sträng efter duplicerade ord instansieras sedan och används i följande exempel.

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

En lyckad kompilering av det här andra exemplet kräver att en referens till RegexLib.dll (sammansättningen som skapades i det första exemplet) läggs till i projektet.

Kommentarer

Metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName) genererar en .NET Framework-sammansättning där varje reguljärt uttryck som definieras i matrisen regexinfos representeras av en klass. CompileToAssembly(RegexCompilationInfo[], AssemblyName) Vanligtvis anropas metoden från ett separat program som genererar en sammansättning av kompilerade reguljära uttryck. Varje reguljärt uttryck som ingår i sammansättningen har följande egenskaper:

• Den härleds från Regex klassen.

• Det tilldelas det fullständigt kvalificerade namnet som definieras av parametrarna fullnamespace och name för motsvarande RegexCompilationInfo objekt.

• Den har en standardkonstruktor (eller parameterlös) konstruktor.

Vanligtvis finns koden som instansierar och använder det kompilerade reguljära uttrycket i en sammansättning eller ett program som är separat från koden som skapar sammansättningen.

Anteckningar till anropare

Om du utvecklar på ett system som har .NET Framework 4.5 eller dess punktversioner installerade, riktar du dig mot .NET Framework 4 och använder metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName) för att skapa en sammansättning som innehåller kompilerade reguljära uttryck. Om du försöker använda ett av de reguljära uttrycken i sammansättningen i ett system som har .NET genererar Framework 4 ett undantag. Du kan lösa det här problemet genom att göra något av följande:

• Skapa sammansättningen som innehåller de kompilerade reguljära uttrycken i ett system som har .NET Framework 4 i stället för senare versioner installerade.

• I stället för att anropa CompileToAssembly(RegexCompilationInfo[], AssemblyName) och hämta det kompilerade reguljära uttrycket från en sammansättning använder du antingen statiska metoder eller instansmetoder Regex med Compiled alternativet när du instansierar ett Regex objekt eller anropar en mönstermatchningsmetod för reguljära uttryck.

Se även

• Kompilering och återanvändning

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

Regex.cs

Källa:

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

Parametrar

Attribut

ObsoleteAttribute

Undantag

Exempel

I följande exempel skapas en sammansättning med namnet RegexLib.dll och attributet tillämpas på den AssemblyTitleAttribute . Sammansättningen innehåller två kompilerade reguljära uttryck. Den första, Utilities.RegularExpressions.DuplicatedString, matchar två identiska sammanhängande ord. Den andra, Utilities.RegularExpressions.EmailAddress, kontrollerar om en sträng har rätt format för att vara en e-postadress.

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

Du kan kontrollera att AssemblyTitleAttribute attributet har tillämpats på sammansättningen genom att undersöka dess manifest med ett reflektionsverktyg som ILDasm.

Det reguljära uttrycket som kontrollerar en sträng efter duplicerade ord instansieras sedan och används i följande exempel.

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

En lyckad kompilering av det här andra exemplet kräver att en referens till RegexLib.dll (sammansättningen som skapades i det första exemplet) läggs till i projektet.

Kommentarer

Metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) genererar en .NET Framework-sammansättning där varje reguljärt uttryck som definieras i matrisen regexinfos representeras av en klass. CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) Vanligtvis anropas metoden från ett separat program som genererar en sammansättning av kompilerade reguljära uttryck. Varje reguljärt uttryck som ingår i sammansättningen har följande egenskaper:

• Den härleds från Regex klassen.

• Det tilldelas det fullständigt kvalificerade namnet som definieras av parametrarna fullnamespace och name för motsvarande RegexCompilationInfo objekt.

• Den har en standardkonstruktor (eller parameterlös) konstruktor.

Vanligtvis finns koden som instansierar och använder det kompilerade reguljära uttrycket i en sammansättning eller ett program som är separat från koden som skapar sammansättningen.

Eftersom metoden CompileToAssembly genererar en .NET Framework-sammansättning från ett metodanrop i stället för att använda ett visst språks nyckelord för klassdefinition (till exempel class i C# eller Class... End Class i Visual Basic) tillåter det inte att .NET Framework-attribut tilldelas till sammansättningen med hjälp av standardattributsyntaxen för utvecklingsspråket. Parametern attributes innehåller en alternativ metod för att definiera de attribut som gäller för sammansättningen. Gör följande för varje attribut som du vill använda för sammansättningen:

1. Skapa en matris med Type objekt som representerar parametertyperna för attributkonstruktorn som du vill anropa.

2. Hämta ett Type objekt som representerar attributklassen som du vill använda för den nya sammansättningen.

3. GetConstructor Anropa -metoden för attributobjektet Type för att hämta ett ConstructorInfo objekt som representerar attributkonstruktorn som du vill anropa. GetConstructor Skicka metoden till matrisen med Type objekt som representerar konstruktorns parametertyper.

4. Skapa en Object matris som definierar parametrarna som ska skickas till attributets konstruktor.

5. Instansiera ett CustomAttributeBuilder objekt genom att skicka konstruktorn objektet ConstructorInfo som hämtades i steg 3 och matrisen Object som skapades i steg 4.

Du kan sedan skicka en matris med dessa CustomAttributeBuilder objekt i stället för parametern attributes till Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) metoden.

Anteckningar till anropare

Om du utvecklar på ett system som har .NET Framework 4.5 eller dess punktversioner installerade, riktar du dig mot .NET Framework 4 och använder metoden CompileToAssembly(RegexCompilationInfo[], AssemblyName) för att skapa en sammansättning som innehåller kompilerade reguljära uttryck. Om du försöker använda ett av de reguljära uttrycken i sammansättningen i ett system som har .NET genererar Framework 4 ett undantag. Du kan lösa det här problemet genom att göra något av följande:

• Skapa sammansättningen som innehåller de kompilerade reguljära uttrycken i ett system som har .NET Framework 4 i stället för senare versioner installerade.

• I stället för att anropa CompileToAssembly(RegexCompilationInfo[], AssemblyName) och hämta det kompilerade reguljära uttrycket från en sammansättning använder du antingen statiska metoder eller instansmetoder Regex med Compiled alternativet när du instansierar ett Regex objekt eller anropar en mönstermatchningsmetod för reguljära uttryck.

Se även

• Kompilering och återanvändning