Regex.Match Método

Definición

Espacio de nombres:

System.Text.RegularExpressions

Ensamblado:

System.Text.RegularExpressions.dll

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

Sobrecargas

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 por la posición inicial especificada en la cadena.
Match(String, String)	Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada.
Match(String, Int32, Int32)	Busca en la cadena de entrada la primera aparición de una expresión regular, comenzando en la posición inicial especificada y buscando solo el número especificado de caracteres.
Match(String, String, RegexOptions)	Busca en la cadena de entrada la primera aparición de la expresión regular especificada mediante las opciones de coincidencia especificadas.
Match(String, String, RegexOptions, TimeSpan)	Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando las opciones de coincidencia y el intervalo de tiempo de espera especificados.

Match(String)

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 que se va a buscar una coincidencia.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentNullException

input es null.

RegexMatchTimeoutException

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

Ejemplos

En el ejemplo siguiente se buscan coincidencias de patrón 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 de expresión regular (\w+)\s+(car) 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+)	Coincide con uno o varios caracteres de palabra. 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 método Match(String) 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 que se usan para crear un patrón de expresión regular, vea 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 Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta 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 de input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método Match.NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String).

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex 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

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Match(String, Int32)

Source:

Regex.Match.cs

Busca en la cadena de entrada la primera aparición de una expresión regular, empezando por la posición inicial especificada en 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 que se va a buscar una coincidencia.

startat

Int32

Posición de carácter de base 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 agota el tiempo de espera. Para obtener 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 de API complementarias para Regex.Match.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Match(String, String)

Source:

Regex.Match.cs

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

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 que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

RegexMatchTimeoutException

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

Ejemplos

En el ejemplo siguiente se llama al método Match(String, String) para buscar la primera palabra que contiene al menos un carácter z y, a continuación, llama al método Match.NextMatch 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 expresión regular \b\w*z+\w*\b se interpreta como se muestra en la tabla siguiente.

Patrón	Descripción
\b	Comience la coincidencia 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 carácter z.
\w*	Coincide con cero, uno o más caracteres de palabra.
\b	Finalice la coincidencia en un límite de palabras.

Comentarios

El método Match(String, String) 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 que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

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

El parámetro pattern 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 Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta 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 de input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método Match.NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String).

La excepción RegexMatchTimeoutException 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

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Match(String, Int32, Int32)

Source:

Regex.Match.cs

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

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 que se va a buscar una coincidencia.

beginning

Int32

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

length

Int32

Número de caracteres de la subcadena que se va 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-

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

-o-

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

RegexMatchTimeoutException

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

Comentarios

El método Match(String, Int32, Int32) 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 de 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 método Match(String, Int32, Int32) se define mediante la llamada a uno de los constructores de clase Regex. 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 método Match(String, Int32, Int32) busca en la parte de input definida por los parámetros beginning y length para el patrón de expresión regular. beginning define siempre el índice del carácter 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 el input se input.Substring(beginning, length)de forma eficaz, excepto que el índice de cualquier coincidencia se cuenta con respecto al inicio de input. Esto significa que los delimitadores o aserciones de ancho cero al principio o al final del patrón se comportan como si no hubiera ningún input fuera de este intervalo. Por ejemplo, los delimitadores ^, \Gy \A se cumplirán en beginning y $ y \z se cumplirán en beginning + length - 1.

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 al carácter en el índice beginning + length - 1. Si se creó una instancia del motor de expresiones regulares mediante la opción RegexOptions.RightToLeft 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 al carácter en el índice beginning.

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

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta 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.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex 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

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Match(String, String, RegexOptions)

Source:

Regex.Match.cs

Busca en la cadena de entrada la primera aparición de la expresión regular especificada mediante las opciones de coincidencia especificadas.

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 que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

options

RegexOptions

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

Devoluciones

Match

Objeto que contiene información sobre la coincidencia.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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 con la letra "a". Usa la opción RegexOptions.IgnoreCase 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 expresión regular \ba\w*\b se interpreta como se muestra en la tabla siguiente.

Patrón	Descripción
\b	Comience la coincidencia 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	Finalice la coincidencia en un límite de palabras.

Comentarios

El método Match(String, String, RegexOptions) 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 que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

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

El parámetro pattern 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 Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta 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 que se encuentra en input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String, RegexOptions).

La excepción RegexMatchTimeoutException 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

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Match(String, String, RegexOptions, TimeSpan)

Source:

Regex.Match.cs

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

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 que se va a buscar una coincidencia.

pattern

String

Patrón de expresión regular que se va a coincidir.

options

RegexOptions

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

matchTimeout

TimeSpan

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

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

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

-o-

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

RegexMatchTimeoutException

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

Comentarios

El método Match(String, String, RegexOptions, TimeSpan) 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 que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

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

El parámetro pattern 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 Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta 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 que se encuentra en input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String, RegexOptions).

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. 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 parámetro matchTimeout 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 eficazmente 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: de referencia rápida