Regex.Match Regex.Match Regex.Match Regex.Match Method

Definition

Durchsucht eine Eingabezeichenfolge nach einer Teilzeichenfolge, die mit einem Muster eines regulären Ausdrucks übereinstimmt, und gibt das erste Vorkommen als einzelnes Match-Objekt zurück. Searches an input string for a substring that matches a regular expression pattern and returns the first occurrence as a single Match object.

Overloads

Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan)

Durchsucht die Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32)

Sucht beginnend an der angegebenen Anfangsposition in der Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks und sucht nur nach der angegebenen Anzahl von Zeichen. Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, Int32) Match(String, Int32) Match(String, Int32) Match(String, Int32)

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge. Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String) Match(String) Match(String) Match(String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks. Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, String) Match(String, String) Match(String, String) Match(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan)

Durchsucht die Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen. The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben. A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte. A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten. A regular expression parsing error occurred.

input oder pattern ist null. input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten. options is not a valid bitwise combination of RegexOptions values. - oder - -or- matchTimeout ist negativ, null oder größer als ca. 24 Tage. matchTimeout is negative, zero, or greater than approximately 24 days.

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Remarks

Die Match(String, String, RegexOptions, TimeSpan) Methode gibt die erste Teilzeichenfolge zurück, die Muster eines regulären Ausdrucks in einer Eingabezeichenfolge entspricht.The Match(String, String, RegexOptions, TimeSpan) method returns the first substring that matches a regular expression pattern in an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Die statische Match(String, String, RegexOptions, TimeSpan) Methode entspricht dem Erstellen einer Regex Objekt mit der Regex(String, RegexOptions, TimeSpan) Konstruktor und dem Aufrufen der Match(String) Methode.The static Match(String, String, RegexOptions, TimeSpan) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions, TimeSpan) constructor and calling the instance Match(String) method.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Diese Methode gibt die erste Teilzeichenfolge in gefunden input , die Muster des regulären Ausdrucks übereinstimmt.This method returns the first substring found in input that matches the regular expression pattern. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, durch den Aufruf der Regex.Matches(String, String, RegexOptions) Methode.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

Die matchTimeout Parameter gibt an, wie lange ein Musterabgleich Methode sollten versuchen, eine Übereinstimmung gefunden wird, bevor ein Timeout eintritt. Ein Timeoutintervall festlegen wird verhindert, dass reguläre Ausdrücke, die übermäßige rückverfolgung angezeigt werden, nicht mehr reagiert, wenn diese Eingaben verarbeiten, die in der Nähe von Übereinstimmungen enthält.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke und Backtracking.For more information, see Best Practices for Regular Expressions and Backtracking. Wenn Sie in dieses Zeitintervalls keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout überschreibt alle Standard-Timeoutwert, der definiert, die für die Anwendungsdomäne, in der die Methode ausgeführt wird.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notes to Callers

Es wird empfohlen, Sie legen die matchTimeout Parameter auf einen geeigneten Wert, z. B. zwei Sekunden. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts werden, indem deaktiviert InfiniteMatchTimeout, die Engine für reguläre Ausdrücke bietet eine etwas bessere Leistung. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Allerdings sollten Sie Timeouts nur unter folgenden Bedingungen deaktivieren: However, you should disable time-outs only under the following conditions: – Wenn die Eingabe verarbeitet, die von einem regulären Ausdruck aus einer bekannten und vertrauenswürdigen Quelle stammt oder besteht aus statischen Text. - When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text, der vom Benutzer eingegebene dynamisch wurde. This excludes text that has been dynamically input by users. – Wenn Sie Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass er effizient verarbeitet übereinstimmt, nicht-Übereinstimmungen und Naher entspricht. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. – Wenn Muster für reguläre Ausdrücke keine Language-Elemente enthält, die bekannt sind, um eine übermäßige rückverfolgung bei der Verarbeitung einer Nahen Übereinstimmung zu verursachen. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

See Also

Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32)

Sucht beginnend an der angegebenen Anfangsposition in der Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks und sucht nur nach der angegebenen Anzahl von Zeichen. Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);
public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);
member this.Match : string * int * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

beginning
Int32 Int32 Int32 Int32

Die nullbasierte Zeichenposition in der Eingabezeichenfolge, die die am weitesten links stehende Position definiert, die gesucht werden soll. The zero-based character position in the input string that defines the leftmost position to be searched.

length
Int32 Int32 Int32 Int32

Die Anzahl der Zeichen der Teilzeichenfolge, die in die Suche einbezogen werden soll. The number of characters in the substring to include in the search.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

beginning ist kleiner als 0 (null) oder größer als die Länge von input. beginning is less than zero or greater than the length of input. - oder - -or- length ist kleiner als 0 (null) oder größer als die Länge von input. length is less than zero or greater than the length of input. - oder - -or- beginning + length –1 gibt eine Position außerhalb des Bereichs von input an. beginning + length –1 identifies a position that is outside the range of input.

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Remarks

Die Match(String, Int32, Int32) Methode gibt die erste Teilzeichenfolge, die Muster eines regulären Ausdrucks in einem Teil einer Eingabezeichenfolge entspricht.The Match(String, Int32, Int32) method returns the first substring that matches a regular expression pattern in a portion of an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Muster für reguläre Ausdrücke für die die Match(String, Int32, Int32) Methode durchsucht wird durch den Aufruf eines definiert die Regex Klassenkonstruktoren.The regular expression pattern for which the Match(String, Int32, Int32) method searches is defined by the call to one of the Regex class constructors. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Die Match(String, Int32, Int32) Methode durchsucht, die Teil des input von definiert die beginning und length Parameter für das Muster für reguläre Ausdrücke.The Match(String, Int32, Int32) method searches the portion of input defined by the beginning and length parameters for the regular expression pattern. beginning immer definiert den Index des ersten Zeichens in die Suche eingeschlossen und length definiert die maximale Anzahl der zu suchenden Zeichen.beginning always defines the index of the leftmost character to include in the search, and length defines the maximum number of characters to search. Zusammen definieren sie den Bereich der Suche.Together, they define the range of the search. Wenn die Suche von links nach rechts (Standard) fortgesetzt wird, sucht die Engine für reguläre Ausdrücke aus dem Zeichen am Index beginning auf das Zeichen am Index beginning + length – 1.If the search proceeds from left to right (the default), the regular expression engine searches from the character at index beginning to the character at index beginning + length – 1. Wenn die Engine für reguläre Ausdrücke, mithilfe instanziiert wurde der RegexOptions.RightToLeft auswählen, sodass die Suche von rechts nach wird fortgesetzt, links, die reguläre Ausdrücke-Engine sucht mit dem Zeichen am Index beginning + length – 1, die Zeichen am Index beginning.If the regular expression engine was instantiated by using the RegexOptions.RightToLeft option so that the search proceeds from right to left, the regular expression engine searches from the character at index beginning + length – 1 to the character at index beginning. Diese Methode gibt die erste Übereinstimmung, die in diesen Bereich gefunden.This method returns the first match that it finds within this range. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts Match.NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Die RegexMatchTimeoutException Ausnahme ausgelöst, wenn die Ausführungszeit von den entsprechenden Vorgang das Timeoutintervall gemäß überschreitet die Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie einen Timeoutwert nicht festlegen, wenn Sie den Konstruktor aufrufen, wird die Ausnahme ausgelöst, wenn der Vorgang alle für die Anwendungsdomäne festgelegt wird, in dem Timeoutwert überschreitet die Regex Objekt erstellt wird.If you do not set a time-out value when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout, in definiert ist der Regex Konstruktoraufruf oder in Eigenschaften der Anwendungsdomäne, oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

See Also

Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen. The regular expression pattern to match.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben. A bitwise combination of the enumeration values that provide options for matching.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten. A regular expression parsing error occurred.

input oder pattern ist null. input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten. options is not a valid bitwise combination of RegexOptions values.

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Examples

Das folgende Beispiel definiert einen regulären Ausdruck, der entspricht Wörtern beginnend mit dem Buchstaben "a".The following example defines a regular expression that matches words beginning with the letter "a". Er verwendet den RegexOptions.IgnoreCase Option aus, um sicherzustellen, dass der reguläre Ausdruck Wörter mit einem Großbuchstaben "a" und ein kleines sucht "a".It uses the RegexOptions.IgnoreCase option to ensure that the regular expression locates words beginning with both an uppercase "a" and a lowercase "a".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\ba\w*\b";
      string input = "An extraordinary day dawns with each new day.";
      Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
      if (m.Success)
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
   }
}
// The example displays the following output:
//        Found 'An' at position 0.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Das Muster für reguläre Ausdrücke \ba\w*\b wird entsprechend der folgenden Tabelle interpretiert:The regular expression pattern \ba\w*\b is interpreted as shown in the following table.

MusterPattern Beschreibung Description
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
a Übereinstimmung mit dem Zeichen "a".Match the character "a".
\w* Entspricht 0 (null), 1 oder mehr Wortzeichen.Match zero, one, or more word characters.
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Remarks

Die Match(String, String, RegexOptions) Methode gibt die erste Teilzeichenfolge zurück, die Muster eines regulären Ausdrucks in einer Eingabezeichenfolge entspricht.The Match(String, String, RegexOptions) method returns the first substring that matches a regular expression pattern in an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Die statische Match(String, String, RegexOptions) Methode entspricht dem Erstellen einer Regex Objekt mit der Regex(String, RegexOptions) Konstruktor und dem Aufrufen der Match(String) Methode.The static Match(String, String, RegexOptions) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions) constructor and calling the instance Match(String) method.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Diese Methode gibt die erste Teilzeichenfolge in gefunden input , die Muster des regulären Ausdrucks übereinstimmt.This method returns the first substring found in input that matches the regular expression pattern. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, durch den Aufruf der Regex.Matches(String, String, RegexOptions) Methode.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

Die RegexMatchTimeoutException Ausnahme ausgelöst, wenn die Ausführungszeit von den entsprechenden Vorgang überschreitet das Timeoutintervall angegeben, für die Anwendungsdomäne, in dem die Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in der Anwendungsdomäne definiert ist, oder der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes to Callers

Diese-Methode ein Timeout, nach einem bestimmten Zeitintervall, das gleich der Standardwert für das Timeout der Anwendungsdomäne, in dem sie aufgerufen wird. This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn Sie ein Timeoutwert für die Anwendungsdomäne, der Wert nicht definiert wurde InfiniteMatchTimeout, das Timeout, die Methode verhindert werden. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Ist die empfohlene statische Methode zum Abrufen von eine Musterübereinstimmung Match(String, String), mit dem Sie das Timeoutintervall festlegen. The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

See Also

Match(String, Int32) Match(String, Int32) Match(String, Int32) Match(String, Int32)

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge. Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);
public System.Text.RegularExpressions.Match Match (string input, int startat);
member this.Match : string * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, startat As Integer) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

startat
Int32 Int32 Int32 Int32

Die nullbasierte Zeichenposition, an der mit der Suche begonnen werden soll. The zero-based character position at which to start the search.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

startat ist kleiner als 0 (null) oder größer als die Länge von input. startat is less than zero or greater than the length of input.

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Remarks

Die Match(String, Int32) Methode gibt die erste Teilzeichenfolge, die ein Muster für reguläre Ausdrücke ab, um oder nach entspricht der startat Position in einer Eingabezeichenfolge Zeichen.The Match(String, Int32) method returns the first substring that matches a regular expression pattern, starting at or after the startat character position, in an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Muster für reguläre Ausdrücke für die die Match(String, Int32) Methode durchsucht wird durch den Aufruf eines definiert die Regex Klassenkonstruktoren.The regular expression pattern for which the Match(String, Int32) method searches is defined by the call to one of the Regex class constructors. Weitere Informationen zu den Elementen, die ein Muster für reguläre Ausdrücke bilden können, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Sie können optional die Position des ersten in der Zeichenfolge angeben, mit der startat Parameter.You can optionally specify a starting position in the string by using the startat parameter. Wenn die Engine für reguläre Ausdrücke von links nach rechts (Standard) analysiert wird, die übereinstimmen und die Überprüfung verschieben rightward, beginnend ab der Zeichen im angegebenen startat.When the regular expression engine parses from left to right (the default), the match and the scan move rightward, starting at the character specified in startat. Wenn analysiert die Engine für reguläre Ausdrücke von rechts nach links (wenn Muster für reguläre Ausdrücke erstellt wird, mit der RegexOptions.RightToLeft Option), der Übereinstimmung und die Überprüfung in die entgegengesetzte Richtung zu verschieben, und beginnen mit dem Zeichen am startat -1.When the regular expression engine parses from right to left (when the regular expression pattern is constructed with the RegexOptions.RightToLeft option), the match and scan move in the opposite direction and begin with the character at startat -1. Wenn Sie keine Position des ersten angeben, wird die Suche beginnt, den Standardwert startat Position.If you do not specify a starting position, the search begins at the default startat position. Wenn der reguläre Ausdruck von links nach rechts und von der Standardeinstellung sucht startat Position befindet sich am linken Ende input; wenn er sucht, von rechts nach links ist, wird der Standardwert startat Position befindet sich am rechten Ende input.If the regular expression searches from left to right, the default startat position is at the left end of input; if it searches from right to left, the default startat position is at the right end of input.

Wenn eine Übereinstimmung zu beschränken, damit sie an einer bestimmten Zeichenposition in der Zeichenfolge beginnt und die Engine für reguläre Ausdrücke der Rest der Zeichenfolge nach einer Übereinstimmung nicht überprüft werden sollen, Verankern des regulären Ausdrucks mit einem \G (auf einem von links nach rechts nach links Muster oder rechts für rechts-nach-links-Muster).If you want to restrict a match so that it begins at a particular character position in the string and the regular expression engine does not scan the remainder of the string for a match, anchor the regular expression with a \G (at the left for a left-to-right pattern, or at the right for a right-to-left pattern). Dadurch wird die Übereinstimmung, sodass sie genau bei beginnen muss startat.This restricts the match so it must start exactly at startat.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Diese Methode gibt die erste Teilzeichenfolge gefunden wird, um oder nach der startat Zeichenposition in input , die Muster des regulären Ausdrucks übereinstimmt.This method returns the first substring found at or after the startat character position in input that matches the regular expression pattern. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts Match.NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, durch den Aufruf der Regex.Matches(String, Int32) Methode.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, Int32) method.

Die RegexMatchTimeoutException Ausnahme ausgelöst, wenn die Ausführungszeit von den entsprechenden Vorgang das Timeoutintervall gemäß überschreitet die Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie ein Timeoutintervall nicht festlegen, wenn Sie den Konstruktor aufrufen, wird die Ausnahme ausgelöst, wenn der Vorgang überschreitet die maximal alle Timeoutwert für die Anwendungsdomäne, in dem hergestellt. die Regex Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exeeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout, in definiert ist der Regex Konstruktoraufruf oder in Eigenschaften der Anwendungsdomäne, oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

See Also

Match(String) Match(String) Match(String) Match(String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks. Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);
public System.Text.RegularExpressions.Match Match (string input);
member this.Match : string -> System.Text.RegularExpressions.Match
Public Function Match (input As String) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Examples

Das folgende Beispiel findet Muster für reguläre Ausdrücke in einer Zeichenfolge entspricht und anschließend eine Liste der übereinstimmenden Gruppen, erfasst und Capture-Positionen.The following example finds regular expression pattern matches in a string, then lists the matched groups, captures, and capture positions.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
using System;
using System.Text.RegularExpressions;

class Example 
{
   static void Main() 
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);
      
      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success) 
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++) 
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++) 
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
      	      Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Muster für reguläre Ausdrücke (\w+)\s+(car) Vorkommen des Worts "Car" mit dem Wort, das ihm vorausgeht.The regular expression pattern (\w+)\s+(car) matches occurrences of the word "car" along with the word that precedes it. Es wird entsprechend in der folgenden Tabelle interpretiert.It is interpreted as shown in the following table.

MusterPattern Beschreibung Description
(\w+) Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\s+ Übereinstimmung mit ein oder mehrere Leerzeichen Zeichen.Match one or more white-space characters.
(PKW)(car) Mit die literale Zeichenfolge "Car" übereinstimmen.Match the literal string "car". Dies ist die zweite Erfassungsgruppe.This is the second capturing group.

Remarks

Die Match(String) Methode gibt die erste Teilzeichenfolge zurück, die Muster eines regulären Ausdrucks in einer Eingabezeichenfolge entspricht.The Match(String) method returns the first substring that matches a regular expression pattern in an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Diese Methode gibt die erste Teilzeichenfolge in input , die Muster des regulären Ausdrucks übereinstimmt.This method returns the first substring in input that matches the regular expression pattern. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts Match.NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, durch den Aufruf der Regex.Matches(String) Methode.You can also retrieve all matches in a single method call by calling the Regex.Matches(String) method.

Die RegexMatchTimeoutException Ausnahme ausgelöst, wenn die Ausführungszeit von den entsprechenden Vorgang das Timeoutintervall gemäß überschreitet die Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie ein Timeoutintervall nicht festlegen, wenn Sie den Konstruktor aufrufen, wird die Ausnahme ausgelöst, wenn der Vorgang alle für die Anwendungsdomäne festgelegt wird, in dem Timeoutwert überschreitet die Regex Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout, in definiert ist der Regex Konstruktoraufruf oder in Eigenschaften der Anwendungsdomäne, oder wenn der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

See Also

Match(String, String) Match(String, String) Match(String, String) Match(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks. Searches the specified input string for the first occurrence of the specified regular expression.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.Match Match (string input, string pattern);
static member Match : string * string -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String) As Match

Parameter

input
String String String String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge. The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen. The regular expression pattern to match.

Returns

Ein Objekt, das Informationen zur Übereinstimmung enthält. An object that contains information about the match.

Exceptions

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten. A regular expression parsing error occurred.

input oder pattern ist null. input or pattern is null.

Es ist ein Timeout aufgetreten. A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“. For more information about time-outs, see the Remarks section.

Examples

Im folgenden Beispiel wird die Match(String, String) Methode, um das erste Wort zu suchen, die mindestens eins enthält z Zeichen, und ruft dann die Match.NextMatch Methode, um zusätzlichen Übereinstimmungen gefunden.The following example calls the Match(String, String) method to find the first word that contains at least one z character, and then calls the Match.NextMatch method to find any additional matches.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "ablaze beagle choral dozen elementary fanatic " +
                     "glaze hunger inept jazz kitchen lemon minus " +
                     "night optical pizza quiz restoration stamina " +
                     "train unrest vertical whiz xray yellow zealous";
      string pattern = @"\b\w*z+\w*\b";
      Match m = Regex.Match(input, pattern);
      while (m.Success) {
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
         m = m.NextMatch();
      }   
   }
}
// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

Das Muster für reguläre Ausdrücke \b\w*z+\w*\b wird entsprechend der folgenden Tabelle interpretiert:The regular expression pattern \b\w*z+\w*\b is interpreted as shown in the following table.

MusterPattern Beschreibung Description
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w* Entspricht 0 (null), 1 oder mehr Wortzeichen.Match zero, one, or more word characters.
z+ Übereinstimmung mit mindestens der z Zeichen.Match one or more occurrences of the z character.
\w* Entspricht 0 (null), 1 oder mehr Wortzeichen.Match zero, one, or more word characters.
\b Der Vergleich endet an einer Wortgrenze.End the match at a word boundary.

Remarks

Die Match(String, String) Methode gibt die erste Teilzeichenfolge zurück, die Muster eines regulären Ausdrucks in einer Eingabezeichenfolge entspricht.The Match(String, String) method returns the first substring that matches a regular expression pattern in an input string. Informationen, die Sprachelemente, die zum Erstellen des Muster eines regulären Ausdrucks verwendet wird, finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Die statische Match(String, String) Methode entspricht dem Erstellen einer Regex Objekt mit dem angegebenen regulären Ausdrucksmuster und dem Aufrufen der Match(String) Methode.The static Match(String, String) method is equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance Match(String) method. In diesem Fall wird die Engine für reguläre Ausdrücke das Muster für reguläre Ausdrücke zwischengespeichert.In this case, the regular expression engine caches the regular expression pattern.

Die pattern -Parameter besteht aus Sprachelemente regulärer Ausdrücke, die zu vergleichende Zeichenfolge symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter reguläre Ausdrücke von .NET Framework und Sprachelemente für reguläre Ausdrücke – Kurzübersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Sie können bestimmen, ob das Muster für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurde, indem der Wert des zurückgegebenen überprüft Match des Objekts Success Eigenschaft.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Wenn eine Übereinstimmung gefunden wird, die zurückgegebene Match des Objekts Value Eigenschaft enthält die Teilzeichenfolge aus input , die Muster des regulären Ausdrucks übereinstimmt.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Wenn keine Übereinstimmung gefunden wird, wird der Wert ist String.Empty.If no match is found, its value is String.Empty.

Diese Methode gibt die erste Teilzeichenfolge in input , die Muster des regulären Ausdrucks übereinstimmt.This method returns the first substring in input that matches the regular expression pattern. Sie können die nachfolgende Übereinstimmungen abrufen, indem Sie durch wiederholtes Aufrufen das zurückgegebene Match des Objekts Match.NextMatch Methode.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Sie können auch alle Übereinstimmungen in einem einzelnen Methodenaufruf abrufen, durch den Aufruf der Regex.Matches(String, String) Methode.You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String) method.

Die RegexMatchTimeoutException Ausnahme ausgelöst, wenn die Ausführungszeit von den entsprechenden Vorgang überschreitet das Timeoutintervall angegeben, für die Anwendungsdomäne, in dem die Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in der Anwendungsdomäne definiert ist, oder der Timeoutwert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes to Callers

Diese-Methode ein Timeout, nach einem bestimmten Zeitintervall, das gleich der Standardwert für das Timeout der Anwendungsdomäne, in dem sie aufgerufen wird. This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn Sie ein Timeoutwert für die Anwendungsdomäne, der Wert nicht definiert wurde InfiniteMatchTimeout, das Timeout, die Methode verhindert werden. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Ist die empfohlene statische Methode zum Abrufen von eine Musterübereinstimmung Match(String, String), mit dem Sie das Timeoutintervall festlegen. The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

See Also

Applies to