Match Sınıf

Tanım

Tek bir normal ifade eşleşmesinden elde edilecek sonuçları temsil eder.Represents the results from a single regular expression match.

public ref class Match : System::Text::RegularExpressions::Group
public class Match : System.Text.RegularExpressions.Group
[System.Serializable]
public class Match : System.Text.RegularExpressions.Group
type Match = class
    inherit Group
[<System.Serializable>]
type Match = class
    inherit Group
Public Class Match
Inherits Group
Devralma
Öznitelikler

Örnekler

Aşağıdaki örnekler, normal ifadeyi kullanır Console\.Write(Line)? .The following examples use the regular expression Console\.Write(Line)?. Normal ifade aşağıdaki gibi yorumlanır:The regular expression is interpreted as follows:

Konsol \ . YazarkenConsole\.Write "Console. Write" dizesiyle eşleştirin.Match the string "Console.Write". "." Karakterinin, herhangi bir karakterle eşleşen bir joker karakter yerine bir sabit değer olarak yorumlanacağı şekilde atlandığını unutmayın.Note that the "." character is escaped so that it is interpreted as a literal period rather than as a wildcard that matches any character.
(Satır)?(Line)? "Line" dizesinin sıfır veya bir oluşumunu eşleştirin.Match zero or one occurrence of the string "Line".

Örnek 1Example 1

Aşağıdaki örnek, Regex.Matches(String, String) bir giriş dizesindeki tüm kalıp eşleşmelerini almak için yöntemini çağırır.The following example calls the Regex.Matches(String, String) method to retrieve all pattern matches in an input string. Daha sonra, Match MatchCollection her eşleşme hakkındaki bilgileri göstermek için döndürülen nesnedeki nesneleri yineler.It then iterates the Match objects in the returned MatchCollection object to display information about each match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      
      string pattern = @"Console\.Write(Line)?";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)       
      Next                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Örnek 2Example 2

Aşağıdaki örnek, Match(String, String) NextMatch bir seferde bir eşleşme almak için ve yöntemlerini çağırır.The following example calls the Match(String, String) and NextMatch methods to retrieve one match at a time.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      string pattern = @"Console\.Write(Line)?";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)
         match = match.NextMatch()                  
      Loop                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Açıklamalar

MatchNesne sabittir ve genel oluşturucuya sahip değil.The Match object is immutable and has no public constructor. Sınıfının bir örneği Match , yöntemi tarafından döndürülür Regex.Match ve bir dizedeki ilk model eşleşmeyi temsil eder.An instance of the Match class is returned by the Regex.Match method and represents the first pattern match in a string. Sonraki eşleşmeler Match , yöntemi tarafından döndürülen nesneler tarafından temsil edilir Match.NextMatch .Subsequent matches are represented by Match objects returned by the Match.NextMatch method. Ayrıca, MatchCollection sıfır, bir veya daha fazla nesneden oluşan bir nesne Match , yöntemi tarafından döndürülür Regex.Matches .In addition, a MatchCollection object that consists of zero, one, or more Match objects is returned by the Regex.Matches method.

Yöntem bir Regex.Matches Giriş dizesindeki normal ifade düzeniyle eşleşmiyorsa boş bir MatchCollection nesne döndürür.If the Regex.Matches method fails to match a regular expression pattern in an input string, it returns an empty MatchCollection object. Daha sonra foreach For Each , koleksiyonu yinelemek Için, C# veya Visual Basic bir yapı içinde bir yapı kullanabilirsiniz.You can then use a foreach construct in C# or a For Each construct in Visual Basic to iterate the collection.

Regex.MatchYöntem normal ifade düzeniyle eşleşmezse, Match değerine eşit olan bir nesne döndürür Match.Empty .If the Regex.Match method fails to match the regular expression pattern, it returns a Match object that is equal to Match.Empty. SuccessÖzelliği, eşleşmenin başarılı olup olmadığını anlamak için kullanabilirsiniz.You can use the Success property to determine whether the match was successful. Aşağıdaki örnek, bir gösterim sağlar.The following example provides an illustration.

// Search for a pattern that is not found in the input string.
string pattern = "dog";
string input = "The cat saw the other cats playing in the back yard.";
Match match = Regex.Match(input, pattern);
if (match.Success )
   // Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", 
                     match.Value, match.Index + 1, input);
else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.",
                     pattern, input);
' Search for a pattern that is not found in the input string.
Dim pattern As String = "dog"
Dim input As String = "The cat saw the other cats playing in the back yard."
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
   ' Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", _ 
                     match.Value, match.Index + 1, input)
Else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.", _
                     pattern, input)
End If

Bir model eşleşmesi başarılı olursa, Value özelliği eşleşen alt dizeyi içerir, Index özelliği giriş dizesindeki eşleşen alt dizenin sıfır tabanlı başlangıç konumunu gösterir ve Length özellik giriş dizesindeki eşleşen alt dizenin uzunluğunu gösterir.If a pattern match is successful, the Value property contains the matched substring, the Index property indicates the zero-based starting position of the matched substring in the input string, and the Length property indicates the length of matched substring in the input string.

Tek bir eşleşme birden çok yakalama grubu içerebileceği için, Match döndüren bir Groups özelliğine sahiptir GroupCollection .Because a single match can involve multiple capturing groups, Match has a Groups property that returns the GroupCollection. MatchÖrneğin, Match.Groups[0] Match.Groups(0) tüm eşleşmeyi temsil eden (Visual Basic), koleksiyondaki ilk nesneye eşdeğerdir.The Match instance itself is equivalent to the first object in the collection, at Match.Groups[0] (Match.Groups(0) in Visual Basic), which represents the entire match. Yakalanan gruplara bir eşleşme ile aşağıdaki yollarla erişebilirsiniz:You can access the captured groups in a match in the following ways:

  • GroupCollectionBir foreach (C#) veya For Each (Visual Basic) yapısını kullanarak nesnesinin üyelerini yineleyebilirsiniz.You can iterate the members of the GroupCollection object by using a foreach (C#) or For Each (Visual Basic) construct.

  • Bu GroupCollection.Item[Int32] özelliği, yakalama grubu sayısına göre grupları almak için kullanabilirsiniz.You can use the GroupCollection.Item[Int32] property to retrieve groups by the number of the capturing group. Örnek yöntemini çağırarak bir normal ifadede hangi numaralanmış grupların bulunduğunu belirleyebileceğinizi unutmayın Regex.GetGroupNumbers .Note that you can determine which numbered groups are present in a regular expression by calling the instance Regex.GetGroupNumbers method.

  • Bu GroupCollection.Item[String] özelliği, yakalama grubunun adına grupları almak için kullanabilirsiniz.You can use the GroupCollection.Item[String] property to retrieve groups by the name of the capturing group. Örnek yöntemini çağırarak bir normal ifadede hangi adlandırılmış grupların bulunduğunu belirleyebileceğinizi unutmayın Regex.GetGroupNames() .Note that you can determine which named groups are present in a regular expression by calling the instance Regex.GetGroupNames() method.

Özellikler

Captures

Yakalama grubu tarafından eşleştirilen tüm yakalamalara ait, en soldaki ilk düzende (veya normal ifade seçeneğiyle değiştirilmişse en sağdaki ilk sırada) bir koleksiyon alır RightToLeft .Gets a collection of all the captures matched by the capturing group, in innermost-leftmost-first order (or innermost-rightmost-first order if the regular expression is modified with the RightToLeft option). Koleksiyonda sıfır veya daha fazla öğe olabilir.The collection may have zero or more items.

(Devralındığı yer: Group)
Empty

Boş grubu alır.Gets the empty group. Tüm başarısız eşleşmeler bu boş eşleşmeyi döndürür.All failed matches return this empty match.

Groups

Normal ifadeyle eşleşen grupların koleksiyonunu alır.Gets a collection of groups matched by the regular expression.

Index

Yakalanan alt dizenin ilk karakterinin bulunduğu özgün dizedeki konum.The position in the original string where the first character of the captured substring is found.

(Devralındığı yer: Capture)
Length

Yakalanan alt dizenin uzunluğunu alır.Gets the length of the captured substring.

(Devralındığı yer: Capture)
Name

Geçerli örnek tarafından temsil edilen yakalama grubunun adını döndürür.Returns the name of the capturing group represented by the current instance.

(Devralındığı yer: Group)
Success

Eşleşmenin başarılı olup olmadığını gösteren bir değer alır.Gets a value indicating whether the match is successful.

(Devralındığı yer: Group)
Value

Giriş dizesinden yakalanan alt dizeyi alır.Gets the captured substring from the input string.

(Devralındığı yer: Capture)

Yöntemler

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
NextMatch()

MatchSon eşleşmenin sona erdiği konumdan başlayarak (son eşleşen karakterden sonraki karakterde), sonraki eşleşme için sonuçlara sahip yeni bir nesne döndürür.Returns a new Match object with the results for the next match, starting at the position at which the last match ended (at the character after the last matched character).

Result(String)

Belirtilen değiştirme deseninin genişletmesinin döndürür.Returns the expansion of the specified replacement pattern.

Synchronized(Match)

MatchBirden çok iş parçacığı arasında paylaşmak için uygun olan bir örnek ile eşdeğer bir örnek döndürür.Returns a Match instance equivalent to the one supplied that is suitable to share between multiple threads.

ToString()

Özelliği çağırarak, giriş dizesinden yakalanan alt dizeyi alır Value .Retrieves the captured substring from the input string by calling the Value property.

(Devralındığı yer: Capture)

Şunlara uygulanır

Ayrıca bkz.