Regex Konstruktory

Reference

Definice

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

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.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í.

Inicializuje novou instanci Regex třídy.

Přetížení

Regex()	Inicializuje novou instanci Regex třídy.
Regex(String)	Inicializuje novou instanci Regex třídy pro zadaný regulární výraz.
Regex(SerializationInfo, StreamingContext)	Zastaralé. Inicializuje novou instanci třídy Regex pomocí serializovaných dat.
Regex(String, RegexOptions)	Inicializuje novou instanci třídy Regex pro zadaný regulární výraz s možnostmi, které upravují vzor.
Regex(String, RegexOptions, TimeSpan)	Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které upravují vzor a hodnotu, která určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit o shodu před časovým limitem.

Regex()

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Inicializuje novou instanci Regex třídy.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Poznámky

Všimněte si, že tento konstruktor je chráněn; lze volat pouze třídami odvozenými z Regex třídy.

Platí pro

Regex(String)

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Inicializuje novou instanci Regex třídy pro zadaný regulární výraz.

public:
 Regex(System::String ^ pattern);

public Regex (string pattern);

new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String)

Parametry

pattern: String

Vzor regulárního výrazu, který se má shodovat.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

pattern je null.

Příklady

Následující příklad ukazuje, jak pomocí tohoto konstruktoru vytvořit instanci regulárního výrazu, který odpovídá jakémukoli slovu, které začíná písmeny "a" nebo "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Všimněte si, že vzor regulárního výrazu nemůže odpovídat slovu "The" na začátku textu, protože porovnání ve výchozím nastavení rozlišují malá a velká písmena. Příklad porovnání nerozlišující malá a velká písmena najdete v Regex(String, RegexOptions) konstruktoru.

Poznámky

Varování

Při použití System.Text.RegularExpressions ke zpracování nedůvěryhodného vstupu předejte hodnotu časového limitu, abyste zabránili škodlivým uživatelům v tom, aby útok na dostupnost služby. Hodnota časového limitu určuje, jak dlouho se má metoda porovnávání vzorů pokusit najít shodu před vypršením časového limitu.

Parametr pattern se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématech regulárních výrazů .NET a jazyk regulárních výrazů – rychlá referenční témata.

Volání konstruktoru Regex(String) je ekvivalentní volání konstruktoru Regex(String, RegexOptions) s hodnotou None pro argument options.

Objekt Regex je neměnný, což znamená, že ho lze použít pouze pro vzor shody, který definujete při jeho vytváření. Dá se ale použít libovolný počet opakování, aniž by se znovu kompiloval.

Tento konstruktor vytvoří instanci objektu regulárního výrazu, který se pokusí rozlišovat malá a velká písmena všech abecedních znaků definovaných v pattern. Pro shodu nerozlišující malá a velká písmena použijte konstruktor Regex.Regex(String, RegexOptions).

Poznámky pro volající

Tento konstruktor vytvoří Regex objekt, který používá výchozí hodnotu časového limitu domény aplikace, ve které je vytvořena. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije objekt Regex hodnotu InfiniteMatchTimeout, což brání vypršení časového limitu operace. Doporučený konstruktor pro vytvoření objektu Regex je Regex(String, RegexOptions, TimeSpan), který umožňuje nastavit časový limit.

Viz také

elementy jazyka regulárních výrazů

Platí pro

Regex(SerializationInfo, StreamingContext)

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Upozornění

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Inicializuje novou instanci třídy Regex pomocí serializovaných dat.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametry

info: SerializationInfo

Objekt, který obsahuje serializovaný vzor a RegexOptions informace.

context: StreamingContext

Cíl pro tuto serializaci. (Tento parametr se nepoužívá; zadejte null.)

Atributy: ObsoleteAttribute

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

Vzor, který info obsahuje, je null.

ArgumentOutOfRangeException

info obsahuje neplatný příznak RegexOptions.

Platí pro

Regex(String, RegexOptions)

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Inicializuje novou instanci třídy Regex pro zadaný regulární výraz s možnostmi, které upravují vzor.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions)

Parametry

pattern: String

Vzor regulárního výrazu, který se má shodovat.

options: RegexOptions

Bitové kombinace hodnot výčtu, které upravují regulární výraz.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

pattern je null.

ArgumentOutOfRangeException

options obsahuje neplatný příznak.

Příklady

Následující příklad ukazuje, jak pomocí tohoto konstruktoru vytvořit instanci regulárního výrazu, který odpovídá jakémukoli slovu, které začíná písmeny "a" nebo "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Všimněte si, že kolekce shody obsahuje slovo "The", které začíná text, protože parametr options definoval porovnání nerozlišující malá a velká písmena.

Poznámky

Varování

Objekt Regex je neměnný, což znamená, že jej lze použít pouze pro parametry shody, které definujete při jeho vytvoření. Dá se ale použít libovolný počet opakování, aniž by se znovu kompiloval.

Poznámky pro volající

Viz také

elementy jazyka regulárních výrazů

Platí pro

Regex(String, RegexOptions, TimeSpan)

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Zdroj:: Regex.cs

Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které upravují vzor a hodnotu, která určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit o shodu před časovým limitem.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Parametry

pattern: String

Vzor regulárního výrazu, který se má shodovat.

options: RegexOptions

Bitové kombinace hodnot výčtu, které upravují regulární výraz.

matchTimeout: TimeSpan

Časový limit nebo InfiniteMatchTimeout označující, že metoda by neměla časového limitu časového limitu.

Výjimky

ArgumentException

Došlo k chybě analýzy regulárních výrazů.

ArgumentNullException

pattern je null.

ArgumentOutOfRangeException

options není platná hodnota RegexOptions.

-nebo-

matchTimeout je záporná, nula nebo větší než přibližně 24 dní.

Příklady

Následující příklad volá Regex(String, RegexOptions, TimeSpan) konstruktor vytvořit instanci Regex objektu s hodnotou časového limitu jedné sekundy. Vzor regulárního výrazu (a+)+$, který odpovídá jedné nebo více sekvencí jednoho nebo více znaků "a" na konci řádku, podléhá nadměrnému navracení. Pokud je vyvolán RegexMatchTimeoutException, příklad zvýší hodnotu časového limitu až na maximální hodnotu tří sekund. V opačném případě opustí pokus o shodu se vzorem.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Poznámky

Objekt Regex je neměnný, což znamená, že ho lze použít pouze pro vzor shody, který definujete při jeho vytvoření. Dá se ale použít libovolný počet opakování, aniž by se znovu kompiloval.

Parametr matchTimeout určuje, jak dlouho se má metoda porovnávání vzorů pokusit najít shodu, než vyprší časový limit. Pokud se v daném časovém intervalu nenajde žádná shoda, vyvolá metoda porovnávání vzorů výjimku RegexMatchTimeoutException. matchTimeout přepíše výchozí hodnotu časového limitu definovanou pro doménu aplikace, ve které je vytvořen objekt Regex. Metody porovnávání vzorů instancí, které sledují interval časového limitu matchTimeout, zahrnují následující:

Nastavení intervalu časového limitu brání regulárním výrazům, které spoléhají na nadměrné navracení, aby přestaly reagovat při zpracování vstupu, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a zpětného navracení . Pokud chcete nastavit přiměřený časový limit, zvažte následující faktory:

Délka a složitost vzoru regulárního výrazu. Delší a složitější regulární výrazy vyžadují více času než kratší a jednodušší.
Očekávané zatížení počítače. Zpracování zabere více času v systémech s vysokým využitím procesoru a paměti.

Poznámky pro volající

Doporučujeme nastavit parametr matchTimeout na odpovídající hodnotu, například dvě sekundy. Pokud zakážete vypršení časového limitu zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí mírně lepší výkon. Časové limity byste ale měli zakázat pouze za následujících podmínek:

Pokud je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé dynamicky zadali.
Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.
Pokud vzor regulárního výrazu neobsahuje žádné prvky jazyka, o kterých je známo, že při zpracování blízké shody způsobují nadměrné navracení.

Viz také

Platí pro

Sdílet prostřednictvím

Regex Konstruktory

Definice

Přetížení

Regex()

Poznámky

Platí pro

Regex(String)

Parametry

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Regex(SerializationInfo, StreamingContext)

Parametry

Výjimky

Platí pro

Regex(String, RegexOptions)

Parametry

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Regex(String, RegexOptions, TimeSpan)

Parametry

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Další materiály