Regex.Match Método

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Busca en una cadena de entrada una subcadena que coincida con un modelo de expresión regular y devuelve la primera aparición como un único objeto Match.

Sobrecargas

Match(String, String, RegexOptions)	Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia indicadas.
Match(String)	Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada en el constructor Regex.
Match(String, Int32)	Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada de la cadena.
Match(String, String)	Busca en la cadena de entrada especificada la primera aparición de la expresión regular indicada.
Match(String, Int32, Int32)	Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada y buscando solo en el número de caracteres indicado.
Match(String, String, RegexOptions, TimeSpan)	Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se indiquen.

Match(String, String, RegexOptions)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia indicadas.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentException

Se produjo un error de análisis de expresión regular.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se define una expresión regular que coincide con las palabras que comienzan por la letra "a". Usa la RegexOptions.IgnoreCase opción para asegurarse de que la expresión regular busca palabras que comienzan con una "a" mayúscula y una "a" minúscula.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        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.

El patrón de la expresión regular \ba\w*\b se interpreta como se muestra en la tabla siguiente.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`a`	Coincide con el carácter "a".
`\w*`	Coincide con cero, uno o más caracteres de palabra.
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Match(String, String, RegexOptions) método devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje usados para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

El método estático Match(String, String, RegexOptions) es equivalente a construir un Regex objeto con el Regex(String, RegexOptions) constructor y llamar al método de instancia Match(String) .

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

Este método devuelve la primera subcadena encontrada en input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método del NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String, String, RegexOptions) método .

La RegexMatchTimeoutException excepción se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para recuperar una coincidencia de patrón es Match(String, String), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

Match(String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada en el constructor Regex.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentNullException

input es null.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se buscan coincidencias de patrones de expresión regular en una cadena y, a continuación, se enumeran los grupos coincidentes, las capturas y las posiciones de captura.

#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

El patrón (\w+)\s+(car) de expresión regular coincide con las apariciones de la palabra "car" junto con la palabra que lo precede. Se interpreta como se muestra en la tabla siguiente.

Patrón	Descripción
`(\w+)`	Buscar coincidencias con uno o más caracteres alfabéticos. Este es el primer grupo de captura.
`\s+`	Coincide con uno o varios caracteres de espacio en blanco.
(coche)	Coincide con la cadena literal "car". Este es el segundo grupo de captura.

Comentarios

El Match(String) método devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje usados para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

Este método devuelve la primera subcadena de input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método del Match.NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String) método .

La RegexMatchTimeoutException excepción se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

Se aplica a

Match(String, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada de la cadena.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

startat: Int32

Posición de carácter basada en cero en la que se va a iniciar la búsqueda.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentNullException

input es null.

ArgumentOutOfRangeException

startat es menor que cero o mayor que la longitud de input.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Para obtener más información sobre esta API, consulte Comentarios complementarios de la API para Regex.Match.

Consulte también

Se aplica a

Match(String, String)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada especificada la primera aparición de la expresión regular indicada.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentException

Se produjo un error de análisis de expresión regular.

ArgumentNullException

input o pattern es null.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se llama al Match(String, String) método para buscar la primera palabra que contiene al menos un z carácter y, a continuación, llama al Match.NextMatch método para buscar coincidencias adicionales.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    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

El patrón de la expresión regular \b\w*z+\w*\b se interpreta como se muestra en la tabla siguiente.

Modelo	Descripción
`\b`	Iniciar la búsqueda de coincidencias en un límite de palabras.
`\w*`	Coincide con cero, uno o más caracteres de palabra.
`z+`	Coincide con una o varias apariciones del `z` carácter.
`\w*`	Coincide con cero, uno o más caracteres de palabra.
`\b`	Finalizar la búsqueda de coincidencias en un límite de palabras.

Comentarios

El Match(String, String) método devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos del lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

El método estático Match(String, String) es equivalente a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método de instancia Match(String) . En este caso, el motor de expresiones regulares almacena en caché el patrón de expresión regular.

Notas a los autores de las llamadas

Consulte también

Se aplica a

Match(String, Int32, Int32)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada y buscando solo en el número de caracteres indicado.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

beginning: Int32

Posición de caracteres de base cero en la cadena de entrada que define la posición más a la izquierda en la que se buscará.

length: Int32

Número de caracteres de la subcadena que se van a incluir en la búsqueda.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentNullException

input es null.

ArgumentOutOfRangeException

beginning es menor que cero o mayor que la longitud de input.

O bien

length es menor que cero o mayor que la longitud de input.

O bien

beginning+length-1 identifica una posición que está fuera del intervalo de input.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

El Match(String, Int32, Int32) método devuelve la primera subcadena que coincide con un patrón de expresión regular en una parte de una cadena de entrada. Para obtener información sobre los elementos del lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

El patrón de expresión regular para el que busca el Match(String, Int32, Int32) método se define mediante la llamada a uno de los Regex constructores de clase. Para obtener más información sobre los elementos que pueden formar un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

El Match(String, Int32, Int32) método busca en la parte de input definida por los beginning parámetros y length para el patrón de expresión regular. beginning define siempre el índice del carácter situado más a la izquierda que se va a incluir en la búsqueda y length define el número máximo de caracteres que se van a buscar. Juntos, definen el intervalo de la búsqueda. El comportamiento es exactamente igual que si input era eficaz input.Substring(beginning, length), excepto que el índice de cualquier coincidencia se cuenta con respecto al inicio de input. Esto significa que cualquier delimitador o aserciones de ancho cero al principio o al final del patrón se comporta como si no hubiera ninguna input fuera de este intervalo. Por ejemplo, los delimitadores , y se cumplirán en beginning y $\z y se cumplirán en beginning + length - 1.\A\G^

Si la búsqueda continúa de izquierda a derecha (valor predeterminado), el motor de expresiones regulares busca desde el carácter en el índice beginning hasta el carácter en el índice beginning + length - 1. Si se creó una instancia del motor de expresiones regulares mediante la RegexOptions.RightToLeft opción para que la búsqueda continúe de derecha a izquierda, el motor de expresiones regulares busca desde el carácter en el índice beginning + length - 1 hasta el carácter del índice beginning.

Este método devuelve la primera coincidencia que encuentra dentro de este intervalo. Puede recuperar coincidencias posteriores llamando repetidamente al método del Match.NextMatch objeto devueltoMatch.

La RegexMatchTimeoutException excepción se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un valor de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la Regex llamada del constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

Se aplica a

Match(String, String, RegexOptions, TimeSpan)

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Source:: Regex.Match.cs

Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se indiquen.

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

Parámetros

input: String

Cadena en la que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular del que van a buscarse coincidencias.

options: RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.

matchTimeout: TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentException

Se produjo un error de análisis de expresión regular.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de valores RegexOptions.

O bien

matchTimeout es negativo, cero o mayor que 24 días aproximadamente.

RegexMatchTimeoutException

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

El Match(String, String, RegexOptions, TimeSpan) método devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos del lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.

El método estático Match(String, String, RegexOptions, TimeSpan) es equivalente a construir un Regex objeto con el Regex(String, RegexOptions, TimeSpan) constructor y llamar al método de instancia Match(String) .

El matchTimeout parámetro especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que agote el tiempo de espera. Establecer un intervalo de tiempo de espera impide que las expresiones regulares que dependen del retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea Procedimientos recomendados para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.
Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla de forma eficaz las coincidencias, las no coincide y las coincidencias cercanas.
Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

Lenguaje de expresiones regulares: referencia rápida

Se aplica a

Regex.Match Método

Definición

Sobrecargas

Match(String, String, RegexOptions)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Match(String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Match(String, Int32)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

Match(String, String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Match(String, Int32, Int32)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

Match(String, String, RegexOptions, TimeSpan)

Parámetros

Devoluciones

Excepciones

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Comentarios

Recursos adicionales