MatchCollection.Count Proprietà

Definizione

Spazio dei nomi:

System.Text.RegularExpressions

Assembly:

System.Text.RegularExpressions.dll

Origine:

MatchCollection.cs

Ottiene il numero di corrispondenze.

public:
 property int Count { int get(); };

public int Count { get; }

member this.Count : int

Public ReadOnly Property Count As Integer

Valore della proprietà

Int32

Numero di corrispondenze.

Implementazioni

Count Count Count

Eccezioni

RegexMatchTimeoutException

Si è verificato un timeout.

Esempio

Nell'esempio seguente viene utilizzata la Count proprietà per determinare se la chiamata al Regex.Matches(String, String) metodo ha trovato corrispondenze. In caso contrario, indica che non sono state trovate corrispondenze. In caso contrario, enumera le corrispondenze e visualizza il relativo valore e la posizione nella stringa di input in corrispondenza della quale sono stati trovati.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string[] inputs = { "This sentence contains no numbers.",
                          "123 What do I see?",
                          "2468 369 48 5" };
      foreach (var input in inputs) {
         MatchCollection matches = Regex.Matches(input, pattern);
         Console.WriteLine("Input: {0}", input);
         if (matches.Count == 0)
            Console.WriteLine("   No matches");
         else
            foreach (Match m in matches)
               Console.WriteLine("   {0} at index {1}", m.Value, m.Index);

         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Input: This sentence contains no numbers.
//          No matches
//
//       Input: 123 What do I see?
//          123 at index 0
//
//       Input: 2468 369 48 5
//          2468 at index 0
//          369 at index 5
//          48 at index 9
//          5 at index 12

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim inputs() As String = { "This sentence contains no numbers.",
                                 "123 What do I see?",
                                 "2468 369 48 5" }
      For Each inputStr In inputs
         Dim matches As MatchCollection = Regex.Matches(inputStr, pattern)
         Console.WriteLine("Input: {0}", inputStr)
         If matches.Count = 0
            Console.WriteLine("   No matches")
         Else
            For Each m As Match In matches
               Console.WriteLine("   {0} at index {1}", m.Value, m.Index)
            Next
         End If
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Input: This sentence contains no numbers.
'       No matches
'
'       Input: 123 What do I see?
'       123 at index 0
'
'       Input: 2468 369 48 5
'       2468 at index 0
'       369 at index 5
'       48 at index 9
'       5 at index 12

Il criterio \d+ di espressione regolare corrisponde a uno o più caratteri decimali in una stringa di input.

Commenti

L'accesso ai singoli membri dell'oggetto MatchCollection recuperando il valore della proprietà dell'insieme Count fa sì che il motore delle espressioni regolari popola la raccolta usando la valutazione diretta. Il contrasto ln, la chiamata al GetEnumerator metodo (o l'uso dell'istruzione foreach in C# e l'istruzione For Each...Next in Visual Basic) fa sì che il motore delle espressioni regolari popola la raccolta in base alle esigenze usando la valutazione differita. La valutazione diretta può essere un metodo molto più costoso per la compilazione della raccolta rispetto alla valutazione differita.

Poiché l'oggetto MatchCollection viene in genere popolato usando la valutazione differita, il tentativo di determinare il numero di elementi nella raccolta prima che sia stato completamente popolato può generare un'eccezione RegexMatchTimeoutException . Questa eccezione può essere generata se è attivo un valore di timeout per le operazioni di corrispondenza e il tentativo di trovare una singola corrispondenza supera l'intervallo di timeout.