Regex Konstruktory
Definice
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 Regex třídy pomocí serializovaných dat. |
Regex(String, RegexOptions) |
Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které mění 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, než vyprší její časový limit. |
Regex()
Regex(String)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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
Došlo k chybě parsování regulárního výrazu.
pattern
je null
.
Příklady
Následující příklad ukazuje, jak použít tento konstruktor k vytvoření instance regulárního výrazu, který odpovídá libovolnému 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 při porovnávání se ve výchozím nastavení rozlišují velká a malá písmena. Příklad porovnání bez rozlišování velkých a malých písmen najdete v konstruktoru Regex(String, RegexOptions) .
Poznámky
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í výrazy .NET a Jazyk regulárních výrazů – rychlé referenční informace.
Volání konstruktoru Regex(String) je ekvivalentní volání konstruktoru Regex(String, RegexOptions) s hodnotou None argumentu 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 kolikrát, aniž by se znovu zkompiloval.
Tento konstruktor vytvoří instanci objektu regulárního výrazu, který se pokusí rozlišovat velká a malá písmena všech abecedních znaků definovaných v pattern
nástroji . Pokud chcete rozlišovat malá a velká písmena, použijte Regex.Regex(String, RegexOptions) konstruktor.
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řen. Pokud pro doménu aplikace nebyla definována hodnota časového limitu Regex , použije objekt hodnotu InfiniteMatchTimeout, která 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 interval časového limitu.
Viz také
Platí pro
Regex(SerializationInfo, StreamingContext)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Upozornění
This API supports obsolete formatter-based serialization. It should not be called or extended by application code.
Inicializuje novou instanci Regex třídy 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ílové umístění serializace. (Tento parametr se nepoužívá; zadejte null
.)
- Atributy
Výjimky
Došlo k chybě parsování regulárního výrazu.
Vzor, který info
obsahuje, je null
.
info
obsahuje neplatný RegexOptions příznak.
Platí pro
Regex(String, RegexOptions)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Inicializuje novou instanci Regex třídy pro zadaný regulární výraz s možnostmi, které mění 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
Došlo k chybě parsování regulárního výrazu.
pattern
je null
.
options
obsahuje neplatný příznak.
Příklady
Následující příklad ukazuje, jak použít tento konstruktor k vytvoření instance regulárního výrazu, který odpovídá libovolnému 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 options
parametr má definovaná porovnání nerozlišující malá a velká písmena.
Poznámky
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í výrazy .NET a Jazyk regulárních výrazů – rychlé referenční informace.
Objekt Regex je neměnný, což znamená, že ho lze použít pouze pro parametry shody, které definujete při jeho vytváření. Dá se ale použít kolikrát, aniž by se znovu zkompiloval.
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řen. Pokud pro doménu aplikace nebyla definována hodnota časového limitu Regex , použije objekt hodnotu InfiniteMatchTimeout, která 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 interval časového limitu.
Viz také
Platí pro
Regex(String, RegexOptions, TimeSpan)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- 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, než vyprší její časový limit.
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
Interval časového limitu nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.
Výjimky
Došlo k chybě parsování regulárního výrazu.
pattern
je null
.
options
není platná RegexOptions hodnota.
-nebo-
matchTimeout
je záporná, nulová nebo větší než přibližně 24 dnů.
Příklady
Následující příklad volá Regex(String, RegexOptions, TimeSpan) konstruktor pro vytvoření instance objektu Regex s hodnotou časového limitu jedné sekundy. Vzor (a+)+$
regulárního výrazu , který odpovídá jedné nebo více sekvencí jednoho nebo více znaků "a" na konci řádku, podléhá nadměrnému navracení. RegexMatchTimeoutException Pokud je vyvolán, v příkladu se zvýší hodnota časového limitu až na maximální hodnotu 3 sekund. V opačném případě se pokus o shodu se vzorem vzdá.
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
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í výrazy .NET a Jazyk regulárních výrazů – rychlé referenční informace.
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 kolikrát, aniž by se znovu zkompiloval.
Parametr matchTimeout
určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit najít shodu, než vyprší časový limit. Pokud se v daném časovém intervalu nenajde žádná shoda, metoda porovnávání vzorů RegexMatchTimeoutException vyvolá výjimku. matchTimeout
přepíše všechny výchozí hodnoty časového limitu definované pro doménu aplikace, ve které Regex je objekt vytvořen. Mezi metody porovnávání vzorů instancí, které sledují matchTimeout
interval časového limitu, patří následující:
Nastavení intervalu časového limitu zabrání tomu, aby regulární výrazy, které jsou závislé na nadměrném navracení, přestaly reagovat, když zpracovávají vstup, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a backtracking. Pokud chcete nastavit přiměřený interval časového limitu, 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šší výrazy.
Očekávané zatížení počítače. Zpracování trvá déle v systémech s vysokým využitím procesoru a paměti.
Poznámky pro volající
Doporučujeme nastavit matchTimeout
parametr na odpovídající hodnotu, například dvě sekundy. Pokud zakážete vypršení časových limitů zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Vypršení časových limitů byste ale měli zakázat pouze za následujících podmínek:
Když 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é zadává dynamicky.
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.
Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro