Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

CaptureCollection (Clase)

Representa el conjunto de capturas realizado por un único grupo de capturas.

System.Object
  System.Text.RegularExpressions.CaptureCollection

Espacio de nombres:  System.Text.RegularExpressions
Ensamblado:  System (en System.dll)

[SerializableAttribute]
public class CaptureCollection : ICollection, 
	IEnumerable

El tipo CaptureCollection expone los siguientes miembros.

  NombreDescripción
Propiedad públicaCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifCountObtiene el número de subcadenas capturadas por el grupo.
Propiedad públicaCompatible con XNA FrameworkIsReadOnlyObtiene un valor que indica si la colección es de sólo lectura.
Propiedad públicaCompatible con XNA FrameworkIsSynchronizedObtiene un valor que indica si el acceso a la colección está sincronizado (es seguro para la ejecución de subprocesos).
Propiedad públicaCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifItemObtiene un miembro individual de la colección.
Propiedad públicaCompatible con XNA FrameworkSyncRootObtiene un objeto que se puede utilizar para sincronizar el acceso a la colección.
Arriba

  NombreDescripción
Método públicoCompatible con XNA FrameworkCopyToCopia todos los elementos de la colección en la matriz indicada a partir del índice especificado.
Método públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifEquals(Object)Determina si el objeto Object especificado es igual al objeto Object actual. (Se hereda de Object).
Método protegidoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifGetEnumeratorProporciona un enumerador que recorre en iteración la colección.
Método públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifGetHashCodeActúa como función hash para un tipo concreto. (Se hereda de Object).
Método públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método protegidoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

  NombreDescripción
Método de extensión públicoAsParallelHabilita la paralelización de una consulta. (Definido por ParallelEnumerable).
Método de extensión público1463y6st.PortableClassLibrary(es-es,VS.100).gifAsQueryableConvierte una interfaz IEnumerable en IQueryable. (Definido por Queryable).
Método de extensión públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifCast<TResult>Convierte los elementos de IEnumerable en el tipo especificado. (Definido por Enumerable).
Método de extensión públicoCompatible con XNA Framework1463y6st.PortableClassLibrary(es-es,VS.100).gifOfType<TResult>Filtra los elementos de IEnumerable en función de un tipo especificado. (Definido por Enumerable).
Arriba

La colección es inmutable (de sólo lectura) y no tiene constructor público. El objeto CaptureCollection contiene uno o más objetos Capture.

Las siguientes propiedades devuelven instancias de la clase CaptureCollection:

  • Propiedad Group.Captures Cada miembro de la colección representa una subcadena capturada por un grupo de capturas. Si un cuantificador no se aplica a un grupo de captura, CaptureCollection incluye un único objeto Capture que representa la misma subcadena capturada como el objeto Group. Si un cuantificador se aplica a un grupo de captura, CaptureCollection incluye un objeto Capture para cada subcadena capturada y el objeto Group sólo proporciona información sobre la última subcadena capturada.

  • Propiedad Match.Captures En este caso, la colección está compuesta por un objeto Capture único que proporciona información sobre la coincidencia en conjunto. Es decir el objeto CaptureCollection proporciona la misma información que el objeto Match.

Para recorrer en iteración los miembros de una colección, debería utiliza la construcción de la iteración de colección que proporciona el lenguaje de programación (como foreach en C# y For EachNext en Visual Basic) en vez de recuperar el enumerador que devuelve el método GetEnumerator.

En el siguiente ejemplo se comparan los objetos Capture en el objeto CaptureCollection devuelto mediante las propiedades Group.Captures y Match.Captures. También compara objetos Group con objetos Capture en CaptureCollection devueltos por la propiedad Group.Captures. En el ejemplo se usan las siguientes dos expresiones regulares para encontrar las coincidencias en una cadena de entrada única:

  • \b\w+\W{1,2}

    Este modelo de expresión regular que identifica una palabra compuesta de uno o más caracteres de palabra, seguido de uno o dos caracteres que no pertenezcan a una palabra, como el espacio en blanco o la puntuación. La expresión regular no incluye ningún grupo de capturas. El resultado del ejemplo muestra que el objeto Match, así como los objetos CaptureCollection devueltos por las propiedades Match.Captures y Group.Captures contienen información sobre la misma coincidencia.

  • (\b\w+\W{1,2})+

    Este modelo de expresión regular identifica las palabras de una frase. El modelo define un solo grupo de captura que está compuesto de uno o más caracteres de palabra, seguido por uno o dos caracteres que no pertenezcan a una palabra. El modelo de expresión regular usa el cuantificador + para que coincida con una o más apariciones de este grupo. El resultado de este ejemplo muestra que el objeto Match y el objeto CaptureCollection devuelto por la propiedad Match.Captures contienen información sobre la misma coincidencia. El segundo objeto Group, que se corresponde con el único grupo de captura en la expresión regular, identifica sólo la última cadena capturada, mientras que el objeto CaptureCollection devuelto por el primer grupo de captura de la propiedad Group.Captures, incluye todas las subcadenas capturadas.


using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern;  
      string input = "The young, hairy, and tall dog slowly walked across the yard.";
      Match match;

      // Match a word with a pattern that has no capturing groups.
      pattern = @"\b\w+\W{1,2}";
      match = Regex.Match(input, pattern);
      Console.WriteLine("Pattern: " + pattern);
      Console.WriteLine("Match: " + match.Value);
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count);
      for (int ctr = 0; ctr < match.Captures.Count; ctr++)
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures[ctr].Value);
      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count);
      for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
      {
         Console.WriteLine("    Group {0}: '{1}'", 
                           groupCtr, match.Groups[groupCtr].Value);
         Console.WriteLine("    Group({0}).Captures: {1}", 
                           groupCtr, match.Groups[groupCtr].Captures.Count);
         for (int captureCtr = 0; captureCtr < match.Groups[groupCtr].Captures.Count; captureCtr++)
            Console.WriteLine("      Capture {0}: '{1}'", 
                              captureCtr, 
                              match.Groups[groupCtr].Captures[captureCtr].Value);
      }
      Console.WriteLine("-----\n");

      // Match a sentence with a pattern that has a quantifier that 
      // applies to the entire group.
      pattern = @"(\b\w+\W{1,2})+";
      match = Regex.Match(input, pattern);
      Console.WriteLine("Pattern: " + pattern);
      Console.WriteLine("Match: " + match.Value);
      Console.WriteLine("  Match.Captures: {0}", match.Captures.Count);
      for (int ctr = 0; ctr < match.Captures.Count; ctr++)
         Console.WriteLine("    {0}: '{1}'", ctr, match.Captures[ctr].Value);

      Console.WriteLine("  Match.Groups: {0}", match.Groups.Count);
      for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
      {
         Console.WriteLine("    Group {0}: '{1}'", groupCtr, match.Groups[groupCtr].Value);
         Console.WriteLine("    Group({0}).Captures: {1}", 
                           groupCtr, match.Groups[groupCtr].Captures.Count);
         for (int captureCtr = 0; captureCtr < match.Groups[groupCtr].Captures.Count; captureCtr++)
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, match.Groups[groupCtr].Captures[captureCtr].Value);
      }
   }
}
// The example displays the following output:
//    Pattern: \b\w+\W{1,2}
//    Match: The
//      Match.Captures: 1
//        0: 'The '
//      Match.Groups: 1
//        Group 0: 'The '
//        Group(0).Captures: 1
//          Capture 0: 'The '
//    -----
//    
//    Pattern: (\b\w+\W{1,2})+
//    Match: The young, hairy, and tall dog slowly walked across the yard.
//      Match.Captures: 1
//        0: 'The young, hairy, and tall dog slowly walked across the yard.'
//      Match.Groups: 2
//        Group 0: 'The young, hairy, and tall dog slowly walked across the yard.'
//        Group(0).Captures: 1
//          Capture 0: 'The young, hairy, and tall dog slowly walked across the yard.'
//        Group 1: 'yard.'
//        Group(1).Captures: 11
//          Capture 0: 'The '
//          Capture 1: 'young, '
//          Capture 2: 'hairy, '
//          Capture 3: 'and '
//          Capture 4: 'tall '
//          Capture 5: 'dog '
//          Capture 6: 'slowly '
//          Capture 7: 'walked '
//          Capture 8: 'across '
//          Capture 9: 'the '
//          Capture 10: 'yard.'


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft