MatchCollection.Count Proprietà

Definizione

Ottiene il numero di corrispondenze.Gets the number of matches.

public:
 property int Count { int get(); };
public int Count { get; }
member this.Count : int
Public ReadOnly Property Count As Integer

Valore della proprietà

Numero di corrispondenze.The number of matches.

Implementazioni

Eccezioni

Si è verificato un timeout.A time-out occurred.

Esempi

Nell'esempio seguente viene utilizzata Count la proprietà per determinare se la chiamata Regex.Matches(String, String) al metodo ha rilevato corrispondenze.The following example uses the Count property to determine whether the call to the Regex.Matches(String, String) method found any matches. In caso contrario, indica che non sono state trovate corrispondenze.If not, it indicates that no matches were found. In caso contrario, enumera le corrispondenze e ne Visualizza il valore e la posizione nella stringa di input in corrispondenza della quale sono state trovate.Otherwise, it enumerates the matches and displays their value and the position in the input string at which they were found.

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 ricerca di espressioni regolari corrisponde a uno o più caratteri decimali in una stringa di input.The regular expression pattern \d+ matches one or more decimal characters in an input string.

Commenti

L'accesso ai singoli membri dell' MatchCollection oggetto tramite il recupero del valore della Count proprietà della raccolta determina il popolamento della raccolta da parte del motore delle espressioni regolari mediante la valutazione diretta.Accessing individual members of the MatchCollection object by retrieving the value of the collection's Count property causes the regular expression engine to populate the collection using direct evaluation. al contrario, chiamare il GetEnumerator metodo (o utilizzando l' foreach istruzione in C# e For Each... Next in Visual Basic) fa in modo che il motore delle espressioni regolari popola la raccolta in base alle esigenze usando la valutazione lazy.ln contrast, calling the GetEnumerator method (or using the foreach statement in C# and the For Each...Next statement in Visual Basic) causes the regular expression engine to populate the collection on an as needed basis using lazy evaluation. La valutazione diretta può essere un metodo molto più costoso per compilare la raccolta rispetto alla valutazione lazy.Direct evaluation can be a much more expensive method of building the collection than lazy evaluation.

Poiché l' MatchCollection oggetto viene in genere popolato utilizzando la valutazione lazy, il tentativo di determinare il numero di elementi nella raccolta prima che venga popolata completamente potrebbe RegexMatchTimeoutException generare un'eccezione.Because the MatchCollection object is generally populated by using lazy evaluation, trying to determine the number of elements in the collection before it has been fully populated may throw a RegexMatchTimeoutException exception. 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 tale intervallo di timeout.This exception can be thrown if a time-out value for matching operations is in effect, and the attempt to find a single match exceeds that time-out interval.

Si applica a