Regex.CompileToAssembly Metoda

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zkompiluje regulární výrazy a uloží je na disk v jednom sestavení.

Přetížení

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)	Zastaralé. Zkompiluje jeden nebo více zadaných objektů Regex a zadaný soubor prostředků do pojmenovaného sestavení se zadanými atributy.
CompileToAssembly(RegexCompilationInfo[], AssemblyName)	Zastaralé. Zkompiluje jeden nebo více zadaných objektů Regex do pojmenovaného sestavení.
CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])	Zastaralé. Zkompiluje jeden nebo více zadaných Regex objektů do pojmenovaného sestavení se zadanými atributy.

Poznámky

Poznámka

V .NET Core a .NET 5+ volání metody Regex.CompileToAssembly vyvolá PlatformNotSupportedException. Zápis sestavení není podporován.

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

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Upozornění

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

Zkompiluje jeden nebo více zadaných objektů Regex a zadaný soubor prostředků do pojmenovaného sestavení se zadanými atributy.

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

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

Public Shared Sub CompileToAssembly (regexinfos As RegexCompilationInfo(), assemblyname As AssemblyName, attributes As CustomAttributeBuilder(), resourceFile As String)

Parametry

regexinfos: RegexCompilationInfo[]

Pole, které popisuje regulární výrazy ke kompilaci.

assemblyname: AssemblyName

Název souboru sestavení.

attributes: CustomAttributeBuilder[]

Pole, které definuje atributy, které se mají použít na sestavení.

resourceFile: String

Název souboru prostředků Win32, který se má zahrnout do sestavení.

Atributy: ObsoleteAttribute

Výjimky

ArgumentException

Hodnota vlastnosti assemblyname parametru Name je prázdný řetězec nebo řetězec null.

-nebo-

Vzor regulárního výrazu jednoho nebo více objektů v regexinfos obsahuje neplatnou syntaxi.

ArgumentNullException

assemblyname nebo regexinfos je null.

COMException

Parametr resourceFile určuje neplatný soubor prostředků Win32.

FileNotFoundException

Soubor určený parametrem resourceFile nebyl nalezen.

PlatformNotSupportedException

Pouze .NET Core a .NET 5+: Vytvoření sestavení zkompilovaných regulárních výrazů není podporováno.

Poznámky

Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) generuje sestavení rozhraní .NET Framework, ve kterém je každý regulární výraz definovaný v poli regexinfos reprezentován třídou. Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String) je obvykle volána z samostatné aplikace, která generuje sestavení kompilovaných regulárních výrazů. Každý regulární výraz zahrnutý v sestavení má následující vlastnosti:

Je odvozena z třídy Regex.
Je přiřazen plně kvalifikovaný název definovaný fullnamespace a name parametry odpovídajícího objektu RegexCompilationInfo.
Má výchozí konstruktor (nebo bez parametrů).

Obvykle se kód, který vytvoří instanci a používá zkompilovaný regulární výraz, nachází v sestavení nebo aplikaci, která je oddělená od kódu, který vytváří sestavení.

Protože CompileToAssembly metoda generuje sestavení rozhraní .NET Framework z volání metody namísto použití klíčového slova definice třídy konkrétního jazyka (například class v jazyce C# nebo Class...End Class v jazyce Visual Basic), neumožňuje přiřazení atributů rozhraní .NET Framework k sestavení pomocí standardní syntaxe atributu vývojového jazyka. Parametr attributes poskytuje alternativní metodu pro definování atributů, které se vztahují na sestavení. Pro každý atribut, který chcete použít na sestavení, postupujte takto:

Vytvořte pole Type objektů představujících typy parametrů konstruktoru atributů, který chcete volat.
Načtení objektu Type představující třídu atributu, kterou chcete použít pro nové sestavení.
Volání GetConstructor metody atributu Type objekt načtení ConstructorInfo objekt představující konstruktor atributu, který chcete volat. Předejte GetConstructor metodu pole objektů Type, které představují typy parametrů konstruktoru.
Vytvořte Object pole, které definuje parametry, které se mají předat konstruktoru atributu.
Vytvoření instance objektu CustomAttributeBuilder předáním jeho konstruktoru objektu ConstructorInfo načteného v kroku 3 a pole Object vytvořené v kroku 4.

Pole těchto objektů CustomAttributeBuilder pak můžete předat namísto parametru attributes metodě CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String).

Poznámky pro volající

Pokud vyvíjíte v systému s nainstalovaným rozhraním .NET Framework 4.5 nebo jeho bodovými verzemi, cílíte na rozhraní .NET Framework 4 a použijete metodu CompileToAssembly(RegexCompilationInfo[], AssemblyName) k vytvoření sestavení, které obsahuje zkompilované regulární výrazy. Pokus o použití jednoho z regulárních výrazů v daném sestavení v systému, který má rozhraní .NET Framework 4 vyvolá výjimku. Chcete-li tento problém vyřešit, můžete provést jednu z následujících akcí:

Sestavení, které obsahuje zkompilované regulární výrazy v systému, který má nainstalované rozhraní .NET Framework 4 místo novějších verzí.
Místo volání CompileToAssembly(RegexCompilationInfo[], AssemblyName) a načtení kompilovaného regulárního výrazu ze sestavení použijte statické metody nebo metody Regex instance s možností Compiled při vytvoření instance objektu Regex nebo volání metody porovnávání vzorů regulárních výrazů.

Viz také

kompilace a opakované použití

Platí pro

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Upozornění

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

Zkompiluje jeden nebo více zadaných objektů Regex do pojmenovaného sestavení.

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

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

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

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

Parametry

regexinfos: RegexCompilationInfo[]

Pole, které popisuje regulární výrazy ke kompilaci.

assemblyname: AssemblyName

Název souboru sestavení.

Atributy: ObsoleteAttribute

Výjimky

ArgumentException

Hodnota vlastnosti assemblyname parametru Name je prázdný řetězec nebo řetězec null.

-nebo-

Vzor regulárního výrazu jednoho nebo více objektů v regexinfos obsahuje neplatnou syntaxi.

ArgumentNullException

assemblyname nebo regexinfos je null.

PlatformNotSupportedException

Pouze .NET Core a .NET 5+: Vytvoření sestavení zkompilovaných regulárních výrazů není podporováno.

Příklady

Následující příklad vytvoří sestavení s názvem RegexLib.dll. Sestavení obsahuje dva kompilované regulární výrazy. První Utilities.RegularExpressions.DuplicatedStringodpovídá dvěma stejným souvislým slovům. Druhý Utilities.RegularExpressions.EmailAddresszkontroluje, jestli má řetězec správný formát, který má e-mailovou adresu.

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

Regulární výraz, který kontroluje řetězec duplicitních slov, se vytvoří instance a použije ho v následujícím příkladu.

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

Úspěšná kompilace tohoto druhého příkladu vyžaduje, aby byl do projektu přidán odkaz na RegexLib.dll (sestavení vytvořeného prvním příkladem).

Poznámky

Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName) generuje sestavení rozhraní .NET Framework, ve kterém je každý regulární výraz definovaný v poli regexinfos reprezentován třídou. Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName) je obvykle volána z samostatné aplikace, která generuje sestavení kompilovaných regulárních výrazů. Každý regulární výraz zahrnutý v sestavení má následující vlastnosti:

Je odvozena z třídy Regex.
Je přiřazen plně kvalifikovaný název definovaný fullnamespace a name parametry odpovídajícího objektu RegexCompilationInfo.
Má výchozí konstruktor (nebo bez parametrů).

Obvykle se kód, který vytvoří instanci a používá zkompilovaný regulární výraz, nachází v sestavení nebo aplikaci, která je oddělená od kódu, který vytváří sestavení.

Poznámky pro volající

Sestavení, které obsahuje zkompilované regulární výrazy v systému, který má nainstalované rozhraní .NET Framework 4 místo novějších verzí.
Místo volání CompileToAssembly(RegexCompilationInfo[], AssemblyName) a načtení kompilovaného regulárního výrazu ze sestavení použijte statické metody nebo metody Regex instance s možností Compiled při vytvoření instance objektu Regex nebo volání metody porovnávání vzorů regulárních výrazů.

Viz také

kompilace a opakované použití

Platí pro

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

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Upozornění

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

Zkompiluje jeden nebo více zadaných Regex objektů do pojmenovaného sestavení se zadanými atributy.

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

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

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

Parametry

regexinfos: RegexCompilationInfo[]

Pole, které popisuje regulární výrazy ke kompilaci.

assemblyname: AssemblyName

Název souboru sestavení.

attributes: CustomAttributeBuilder[]

Pole, které definuje atributy, které se mají použít na sestavení.

Atributy: ObsoleteAttribute

Výjimky

ArgumentException

Hodnota vlastnosti assemblyname parametru Name je prázdný řetězec nebo řetězec null.

-nebo-

Vzor regulárního výrazu jednoho nebo více objektů v regexinfos obsahuje neplatnou syntaxi.

ArgumentNullException

assemblyname nebo regexinfos je null.

PlatformNotSupportedException

Pouze .NET Core a .NET 5+: Vytvoření sestavení zkompilovaných regulárních výrazů není podporováno.

Příklady

Následující příklad vytvoří sestavení s názvem RegexLib.dll a použije na něj atribut AssemblyTitleAttribute. Sestavení obsahuje dva kompilované regulární výrazy. První Utilities.RegularExpressions.DuplicatedStringodpovídá dvěma stejným souvislým slovům. Druhý Utilities.RegularExpressions.EmailAddresszkontroluje, jestli má řetězec správný formát, který má e-mailovou adresu.

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

Můžete ověřit, že AssemblyTitleAttribute atribut byl použit na sestavení prozkoumáním jeho manifestu pomocí nástroje reflexe, jako je ILDasm.

Regulární výraz, který kontroluje řetězec duplicitních slov, se vytvoří instance a použije ho v následujícím příkladu.

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

Úspěšná kompilace tohoto druhého příkladu vyžaduje, aby byl do projektu přidán odkaz na RegexLib.dll (sestavení vytvořeného prvním příkladem).

Poznámky

Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) generuje sestavení rozhraní .NET Framework, ve kterém je každý regulární výraz definovaný v poli regexinfos reprezentován třídou. Metoda CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]) je obvykle volána z samostatné aplikace, která generuje sestavení kompilovaných regulárních výrazů. Každý regulární výraz zahrnutý v sestavení má následující vlastnosti:

Je odvozena z třídy Regex.
Je přiřazen plně kvalifikovaný název definovaný fullnamespace a name parametry odpovídajícího objektu RegexCompilationInfo.
Má výchozí konstruktor (nebo bez parametrů).

Obvykle se kód, který vytvoří instanci a používá zkompilovaný regulární výraz, nachází v sestavení nebo aplikaci, která je oddělená od kódu, který vytváří sestavení.

Vytvořte pole Type objektů představujících typy parametrů konstruktoru atributů, který chcete volat.
Načtení objektu Type představující třídu atributu, kterou chcete použít pro nové sestavení.
Volání GetConstructor metody atributu Type objekt načtení ConstructorInfo objekt představující konstruktor atributu, který chcete volat. Předejte GetConstructor metodu pole Type objektů, které představují typy parametrů konstruktoru.
Vytvořte Object pole, které definuje parametry, které se mají předat konstruktoru atributu.
Vytvoření instance objektu CustomAttributeBuilder předáním jeho konstruktoru objektu ConstructorInfo načteného v kroku 3 a pole Object vytvořené v kroku 4.

Pole těchto objektů CustomAttributeBuilder pak můžete předat namísto parametru attributes metodě Regex.CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[]).

Poznámky pro volající

Sestavení, které obsahuje zkompilované regulární výrazy v systému, který má nainstalované rozhraní .NET Framework 4 místo novějších verzí.
Místo volání CompileToAssembly(RegexCompilationInfo[], AssemblyName) a načtení kompilovaného regulárního výrazu ze sestavení použijte statické metody nebo metody Regex instance s možností Compiled při vytvoření instance objektu Regex nebo volání metody porovnávání vzorů regulárních výrazů.

Viz také

kompilace a opakované použití

Platí pro

Sdílet prostřednictvím

Regex.CompileToAssembly Metoda

Definice

Přetížení

Poznámky

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

Parametry

Výjimky

Poznámky

Poznámky pro volající

Viz také

Platí pro

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

Parametry

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

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

Parametry

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Váš názor

Další materiály