Normal ifade seçenekleri
Varsayılan olarak, giriş dizesinin normal ifade desenindeki değişmez karakterlerle karşılaştırılması büyük/küçük harfe duyarlıdır, normal ifade desenindeki boşluk değişmez boşluk karakterleri olarak yorumlanır ve normal ifadedeki grupları yakalama işlemi örtük olarak ve açıkça adlandırılır. Normal ifade seçeneklerini belirterek bunları ve varsayılan normal ifade davranışının diğer çeşitli yönlerini değiştirebilirsiniz. Aşağıdaki tabloda listelenen bu seçeneklerden bazıları normal ifade deseninin bir parçası olarak satır içi olarak eklenebilir veya bir sınıf oluşturucusunda veya sabit listesi değeri olarak System.Text.RegularExpressions.RegexOptions statik desen eşleştirme yöntemine System.Text.RegularExpressions.Regex sağlanabilir.
RegexOptions üye |
Satır içi karakter | Etki | Daha Fazla Bilgi |
|---|---|---|---|
| None | Kullanılamaz | Varsayılan davranışı kullanın. | Varsayılan seçenekler |
| IgnoreCase | i |
Büyük küçük harf duyarlı eşleme kullanın. | Büyük/küçük harfe duyarlı olmayan eşleştirme |
| Multiline | m |
Her satırın başlangıcını ve $ sonunu (giriş dizesinin başlangıcı ve sonu yerine) gösterdiği ^ ve gösterdiği çok satırlı modu kullanın. |
Çok satırlı mod |
| Singleline | s |
Noktanın (.) her karakterle (hariç \nher karakter yerine) eşleştiği tek satırlı modu kullanın. |
Tek satırlı mod |
| ExplicitCapture | n |
Adsız grupları yakalamayın. Yalnızca geçerli yakalamalar, form (?<adı> alt ifadesinin açıkça adlandırılmış veya numaralandırılmış gruplarıdır.) |
Yalnızca açık yakalamalar |
| Compiled | Kullanılamaz | Normal ifadeyi bir derlemeye derleyin. | Derlenmiş normal ifadeler |
| IgnorePatternWhitespace | x |
Düzen dışı boşlukları desenden dışlayın ve sayı işaretinden (# sonra) açıklamaları etkinleştirin. |
Boşluğu yoksay |
| RightToLeft | Kullanılamaz | Arama yönünü değiştirin. Arama, soldan sağa değil, sağdan sola taşınır. | Sağdan sola modu |
| ECMAScript | Kullanılamaz | İfade için ECMAScript uyumlu davranışı etkinleştirin. | ECMAScript eşleştirme davranışı |
| CultureInvariant | Kullanılamaz | Dildeki kültürel farklılıkları yoksayın. | Sabit kültürü kullanarak karşılaştırma |
| NonBacktracking | Kullanılamaz | Geri izlemeyi önleyen ve girişin uzunluğunda doğrusal zaman işlemeyi garanti eden bir yaklaşım kullanarak eşleştirin. (.NET 7 ve sonraki sürümlerde kullanılabilir.) | Geri izleme modu |
Seçenekleri belirtme
Normal ifadeler için seçenekleri üç yoldan biriyle belirtebilirsiniz:
optionsVeya gibi Regex(String, RegexOptions) Regex.Match(String, String, RegexOptions)bir System.Text.RegularExpressions.Regex sınıf oluşturucusunun veya statik (SharedVisual Basic'te) desen eşleştirme yönteminin parametresinde.optionsparametresi, numaralandırılmış değerlerin System.Text.RegularExpressions.RegexOptions bit düzeyinde VEYA birleşimidir.Bir sınıf oluşturucusunun
optionsparametresi kullanılarak bir Regex örneğe seçenekler sağlandığında, seçenekler özelliğine System.Text.RegularExpressions.RegexOptions atanır. Ancak, System.Text.RegularExpressions.RegexOptions özelliği normal ifade desenindeki satır içi seçenekleri yansıtmaz.Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için yönteminin parametresini Regex.Match(String, String, RegexOptions) kullanır
options.string pattern = @"d \w+ \s"; string input = "Dogs are decidedly good pets."; RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace; foreach (Match match in Regex.Matches(input, pattern, options)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "d \w+ \s" Dim input As String = "Dogs are decidedly good pets." Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace For Each match As Match In Regex.Matches(input, pattern, options) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.Söz dizimi
(?imnsx-imnsx)ile normal ifade deseninde satır içi seçenekleri uygulayarak. seçenek, seçeneğin tanımlandığı noktadan desenin sonuna veya seçeneğin başka bir satır içi seçenek tarafından tanımlanmadığı noktaya kadar desene uygulanır. Örneğin Regex özelliğinin System.Text.RegularExpressions.RegexOptions bu satır içi seçenekleri yansıtmadığını unutmayın. Daha fazla bilgi için Çeşitli Yapılar konusuna bakın.Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için satır içi seçenekleri kullanır.
string pattern = @"(?ix) d \w+ \s"; string input = "Dogs are decidedly good pets."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "\b(?ix) d \w+ \s" Dim input As String = "Dogs are decidedly good pets." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.Belirli bir gruplandırma yapısında satır içi seçenekleri, söz dizimi
(?imnsx-imnsx:alt)ifadesiyle normal bir ifade düzeninde uygulayarak. Bir dizi seçenek, kümeyi açmadan önce hiçbir işaret yoktur; bir dizi seçenek ayarı kapatmadan önce eksi işareti. (?dil yapısının söz diziminin, seçeneklerin etkin veya devre dışı olması fark etmeksizin gerekli olan sabit bir parçasıdır.) bu seçenek yalnızca bu grup için geçerlidir. Daha fazla bilgi için bkz . Gruplandırma Yapıları.Aşağıdaki örnek, bir gösterim sağlar. Büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan sözcükleri tanımlarken desen boşluklarını yoksaymak için bir gruplandırma yapısındaki satır içi seçenekleri kullanır.
string pattern = @"\b(?ix: d \w+)\s"; string input = "Dogs are decidedly good pets."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "\b(?ix: d \w+)\s" Dim input As String = "Dogs are decidedly good pets." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.
Seçenekler satır içinde belirtilirse, bir seçenek veya seçenek kümesinden önce bir eksi işareti (-) bu seçenekleri kapatır. Örneğin, satır içi yapısı (?ix-ms) ve seçeneklerini açar RegexOptions.IgnoreCase ve ve RegexOptions.Singleline seçeneklerini kapatır RegexOptions.Multiline RegexOptions.IgnorePatternWhitespace. Tüm normal ifade seçenekleri varsayılan olarak kapalıdır.
Not
Bir oluşturucunun veya yöntem çağrısının options parametresinde belirtilen normal ifade seçenekleri, normal ifade deseninde satır içinde belirtilen seçeneklerle çakışıyorsa, satır içi seçenekler kullanılır.
Aşağıdaki beş normal ifade seçeneği hem options parametresi hem de satır içi ile ayarlanabilir:
Aşağıdaki beş normal ifade seçeneği parametresi kullanılarak options ayarlanabilir ancak satır içinde ayarlanamaz:
Seçenekleri belirleme
Salt okunur Regex.Options özelliğin değerini alarak bir Regex nesnenin örneği oluşturulduğunda hangi seçeneklerin sağlandığını belirleyebilirsiniz.
dışında RegexOptions.Noneherhangi bir seçeneğin varlığını test etmek için, özelliğin Regex.Options değeri ve RegexOptions ilgilendiğiniz değerle bir AND işlemi gerçekleştirin. Ardından sonucun bu RegexOptions değere eşit olup olmadığını test edin. Aşağıdaki örnek, seçeneğin ayarlanıp ayarlanmadığını RegexOptions.IgnoreCase sınar.
if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
Console.WriteLine("Case-insensitive pattern comparison.");
else
Console.WriteLine("Case-sensitive pattern comparison.");
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
Console.WriteLine("Case-insensitive pattern comparison.")
Else
Console.WriteLine("Case-sensitive pattern comparison.")
End If
için test etmek için RegexOptions.None, aşağıdaki örnekte gösterildiği gibi özelliğinin değerinin Regex.Options değerine eşit RegexOptions.Noneolup olmadığını belirleyin.
if (rgx.Options == RegexOptions.None)
Console.WriteLine("No options have been set.");
If rgx.Options = RegexOptions.None Then
Console.WriteLine("No options have been set.")
End If
Aşağıdaki bölümlerde.NET'te normal ifade tarafından desteklenen seçenekler listelenmiştir.
Varsayılan seçenekler
RegexOptions.None seçeneği, hiçbir seçeneğin belirtilmediğinden ve normal ifade altyapısının varsayılan davranışını kullandığını gösterir. Bunlar arasında aşağıdakiler yer alır:
Desen, ECMAScript normal ifadesi yerine kurallı olarak yorumlanır.
Normal ifade deseni, giriş dizesinde soldan sağa eşleştirilir.
Karşılaştırmalar büyük/küçük harfe duyarlıdır.
^ve$dil öğeleri giriş dizesinin başlangıcını ve sonunu gösterir. Giriş dizesinin sonu, sondaki yeni satır\nkarakteri olabilir..Dil öğesi dışındaki\nher karakterle eşleşir.Normal ifade desenindeki boşluklar değişmez boşluk karakteri olarak yorumlanır.
Geçerli kültürün kuralları, desen giriş dizesiyle karşılaştırılırken kullanılır.
Normal ifade desenindeki grupları yakalama örtük ve açıktır.
Not
Seçeneğinin RegexOptions.None satır içi eşdeğeri yoktur. Normal ifade seçenekleri satır içinde uygulandığında, varsayılan davranış belirli bir seçenek kapatılarak seçenek bazında geri yüklenir. Örneğin, (?i) büyük/küçük harfe duyarlı olmayan karşılaştırmayı açar ve (?-i) varsayılan büyük/küçük harfe duyarlı karşılaştırmayı geri yükler.
RegexOptions.None seçeneği normal ifade altyapısının varsayılan davranışını temsil ettiğinden, yöntem çağrısında nadiren belirtilir. Bunun yerine parametresi olmayan bir options oluşturucu veya statik desen eşleştirme yöntemi çağrılır.
Büyük/küçük harfe duyarlı olmayan eşleştirme
seçeneği IgnoreCase veya i satır içi seçeneği büyük/küçük harfe duyarsız eşleştirme sağlar. Varsayılan olarak, geçerli kültürün büyük/küçük harf kuralları kullanılır.
Aşağıdaki örnek, \bthe\w*\b"the" ile başlayan tüm sözcüklerle eşleşen bir normal ifade deseni tanımlar. yöntemine Match yapılan ilk çağrı varsayılan büyük/küçük harfe duyarlı karşılaştırmayı kullandığından çıkış, cümleyi başlayan "The" dizesinin eşleşmediğini gösterir. yöntemi olarak ayarlanmış IgnoreCaseseçeneklerle çağrıldığında Match eşleştirilir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bthe\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bthe\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, _
RegexOptions.IgnoreCase)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
Aşağıdaki örnek, büyük/küçük harfe duyarsız karşılaştırma sağlamak için parametresi yerine satır içi seçenekleri kullanmak üzere önceki örnekteki options normal ifade desenini değiştirir. İlk desen, yalnızca "the" dizesindeki "t" harfine uygulanan bir gruplandırma yapısında büyük/küçük harfe duyarsız seçeneğini tanımlar. Seçenek yapısı desenin başında gerçekleştiğinden, ikinci desen büyük/küçük harfe duyarsız seçeneğini normal ifadenin tamamına uygular.
using System;
using System.Text.RegularExpressions;
public class CaseExample
{
public static void Main()
{
string pattern = @"\b(?i:t)he\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
pattern = @"(?i)\bthe\w*\b";
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
Imports System.Text.RegularExpressions
Module CaseExample
Public Sub Main()
Dim pattern As String = "\b(?i:t)he\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
pattern = "(?i)\bthe\w*\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
Çok satırlı mod
RegexOptions.Multiline seçeneği veya m satır içi seçeneği, normal ifade altyapısının birden çok satırdan oluşan bir giriş dizesini işlemesini sağlar. ve $ dil öğelerinin yorumunu^, giriş dizesinin başlangıcı ve sonu yerine bir satırın başlangıcını ve sonunu gösterecek şekilde değiştirir.
Varsayılan olarak, $ yalnızca giriş dizesinin sonundan memnun kalır. Seçeneğini belirtirseniz RegexOptions.Multiline , yeni satır karakteri (\n) veya giriş dizesinin sonu tarafından karşılanır.
Her iki durumda da satır başı/satır besleme karakter bileşimini (\r\n ) tanımaz$. $ her zaman herhangi bir satır başı (\r) yoksayar. Eşleşmenizi veya \r\n \nile sonlandırmak için yalnızca $yerine alt ifadeyi \r?$ kullanın. Bunun, eşleşmenin \r bir kısmını oluşturacağını unutmayın.
Aşağıdaki örnek, kasecilerin adlarını ve puanlarını ayıklar ve bunları azalan düzende sıralayan bir SortedList<TKey,TValue> koleksiyona ekler. Matches yöntemi iki kez çağrılır. İlk yöntem çağrısında normal ifadedir ^(\w+)\s(\d+)$ ve hiçbir seçenek ayarlanmadı. Çıktıda gösterildiği gibi, normal ifade altyapısı giriş dizesinin başlangıcı ve sonuyla birlikte giriş deseniyle eşleşemediğinden eşleşme bulunmaz. İkinci yöntem çağrısında normal ifade olarak ^(\w+)\s(\d+)\r?$ değiştirilir ve seçenekler olarak RegexOptions.Multilineayarlanır. Çıktıda gösterildiği gibi, adlar ve puanlar başarıyla eşleştirilir ve puanlar azalan sırada görüntülenir.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Multiline1Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer1<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"^(\w+)\s(\d+)$";
bool matched = false;
Console.WriteLine("Without Multiline option:");
foreach (Match match in Regex.Matches(input, pattern))
{
scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
matched = true;
}
if (!matched)
Console.WriteLine(" No matches.");
Console.WriteLine();
// Redefine pattern to handle multiple lines.
pattern = @"^(\w+)\s(\d+)\r*$";
Console.WriteLine("With multiline option:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer1<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Without Multiline option:
// No matches.
//
// With multiline option:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Multiline1Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer1(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf +
"Sam 208" + vbCrLf +
"Allison 211" + vbCrLf +
"Gwen 171" + vbCrLf
Dim pattern As String = "^(\w+)\s(\d+)$"
Dim matched As Boolean = False
Console.WriteLine("Without Multiline option:")
For Each match As Match In Regex.Matches(input, pattern)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
matched = True
Next
If Not matched Then Console.WriteLine(" No matches.")
Console.WriteLine()
' Redefine pattern to handle multiple lines.
pattern = "^(\w+)\s(\d+)\r*$"
Console.WriteLine("With multiline option:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer1(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Without Multiline option:
' No matches.
'
' With multiline option:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
Normal ifade deseni ^(\w+)\s(\d+)\r*$ aşağıdaki tabloda gösterildiği gibi tanımlanır.
| Desen | Açıklama |
|---|---|
^ |
Satırın başlangıcından başlayın. |
(\w+) |
Bir veya daha fazla sözcük karakteri eşleştir. Bu ilk yakalama grubudur. |
\s |
Bir boşluk karakteri ile eşleştirin. |
(\d+) |
Bir veya daha fazla ondalık basamağı eşleştirin. Bu ikinci yakalama grubudur. |
\r? |
Sıfır veya bir satır başı karakterini eşleştirin. |
$ |
Satırın sonunda sona erer. |
Aşağıdaki örnek, çok satırlı seçeneği ayarlamak için satır içi seçeneğini (?m) kullanması dışında öncekine eşdeğerdir.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Multiline2Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"(?m)^(\w+)\s(\d+)\r*$";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Multiline2Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf +
"Sam 208" + vbCrLf +
"Allison 211" + vbCrLf +
"Gwen 171" + vbCrLf
Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
Tek satırlı mod
RegexOptions.Singleline seçeneği veya s satır içi seçeneği, normal ifade altyapısının giriş dizesini tek bir satırdan oluşuyor gibi ele almasına neden olur. Bunu, nokta (.) dil öğesinin davranışını değiştirerek, yeni satır karakteri dışındaki her karakterle eşleştirmek yerine her karakterle \neşleşmesini sağlar.
Aşağıdaki örnekte, seçeneğini kullandığınızda dil öğesinin davranışının . nasıl değiştiği gösterilmektedir RegexOptions.Singleline . Normal ifade ^.+ dizenin başında başlar ve her karakterle eşleşir. Varsayılan olarak, eşleşme ilk satırın sonunda biter; normal ifade deseni satır başı karakteriyle \reşleşir, ancak ile eşleşmiyor \n. RegexOptions.Singleline seçeneği giriş dizesinin tamamını tek bir satır olarak yorumladığı için, dahil olmak üzere \ngiriş dizesindeki her karakterle eşleşir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r
//
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r
'
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Aşağıdaki örnek, tek satır modunu etkinleştirmek için satır içi seçeneğini (?s) kullanması dışında öncekine eşdeğerdir.
using System;
using System.Text.RegularExpressions;
public class SingleLineExample
{
public static void Main()
{
string pattern = "(?s)^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions
Module SingleLineExample
Public Sub Main()
Dim pattern As String = "(?s)^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Yalnızca açık yakalamalar
Varsayılan olarak, yakalama grupları normal ifade deseninde parantezlerin kullanılmasıyla tanımlanır. Adlandırılmış gruplara ad alt ifade) dili seçeneği tarafından(?< bir ad>veya sayı atanırken, adsız gruplara dizin tarafından erişilebilir. nesnesinde GroupCollection , adlandırılmamış gruplar adlandırılmış grupların önünde yer alır.
Gruplandırma yapıları genellikle yalnızca birden çok dil öğesine niceleyici uygulamak için kullanılır ve yakalanan alt dizeler ilgi çekici değildir. Örneğin, aşağıdaki normal ifade:
\b\(?((\w+),?\s?)+[\.!?]\)?
yalnızca bir belgeden nokta, ünlem işareti veya soru işaretiyle biten tümceleri ayıklamak için tasarlanmıştır; yalnızca sonuçta elde edilen tümce (nesne tarafından Match temsil edilir) ilgi çekicidir. Koleksiyondaki tek tek sözcükler değildir.
Normal ifade altyapısının hem hem CaptureCollection de GroupCollection koleksiyon nesnelerini doldurması gerektiğinden, daha sonra kullanılmayan grupları yakalamak pahalı olabilir. Alternatif olarak, yalnızca geçerli yakalamaların ad alt ifade) yapısı tarafından (?<>belirlenen açıkça adlandırılmış veya numaralandırılmış gruplar olduğunu belirtmek için seçeneğini veya n satır içi seçeneğini kullanabilirsinizRegexOptions.ExplicitCapture.
Aşağıdaki örnek, yöntem ile ve seçeneği olmadan RegexOptions.ExplicitCapture çağrıldığında normal ifade deseni Match tarafından \b\(?((\w+),?\s?)+[\.!?]\)? döndürülen eşleşmeler hakkında bilgi görüntüler. İlk yöntem çağrısının çıkışında gösterildiği gibi, normal ifade altyapısı ve CaptureCollection koleksiyon nesnelerini yakalanan alt dizeler hakkındaki bilgilerle tamamen doldururGroupCollection. İkinci yöntem olarak ayarlanmış RegexOptions.ExplicitCaptureolarak çağrıldığındanoptions, gruplarla ilgili bilgileri yakalamaz.
using System;
using System.Text.RegularExpressions;
public class Explicit1Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
Console.WriteLine("With implicit captures:");
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
Console.WriteLine();
Console.WriteLine("With explicit captures only:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// With implicit captures:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// Group 1: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// Group 2: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// Group 1: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// Group 2: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// Group 1: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// Group 2: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
// Group 1: paragraph
// Capture 0: Instead,
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
// Group 2: paragraph
// Capture 0: Instead
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
//
// With explicit captures only:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit1Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
Console.WriteLine("With implicit captures:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
Console.WriteLine()
Console.WriteLine("With explicit captures only:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' With implicit captures:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' Group 1: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' Group 2: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' Group 1: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' Group 2: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' Group 1: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' Group 2: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
' Group 1: paragraph
' Capture 0: Instead,
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
' Group 2: paragraph
' Capture 0: Instead
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
'
' With explicit captures only:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
Normal ifade deseni\b\(?((?>\w+),?\s?)+[\.!?]\)? aşağıdaki tabloda gösterildiği gibi tanımlanır.
| Desen | Açıklama |
|---|---|
\b |
Sözcük sınırında başlayın. |
\(? |
Açma parantezinin ("(") sıfır veya bir tekrarını eşleştirin. |
(?>\w+),? |
Bir veya daha fazla sözcük karakterini, ardından sıfır veya bir virgülle eşleştirin. Sözcük karakterleri eşleştirirken geri dönmeyin. |
\s? |
Sıfır veya bir beyaz boşluk karakterini eşleştirin. |
((\w+),?\s?)+ |
Bir veya daha fazla sözcük karakteri, sıfır veya bir virgül ve sıfır veya bir boşluk karakterinin birleşimini bir veya daha fazla kez eşleştirin. |
[\.!?]\)? |
Üç noktalama simgesinden herhangi birini eşleştirin ve ardından sıfır veya bir kapanış parantezi ("). |
Otomatik yakalamaları (?n) engellemek için satır içi öğesini de kullanabilirsiniz. Aşağıdaki örnek, önceki normal ifade desenini (?n) seçeneği yerine satır içi öğesini kullanacak şekilde RegexOptions.ExplicitCapture değiştirir.
using System;
using System.Text.RegularExpressions;
public class Explicit2Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit2Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
Son olarak, grup halinde otomatik yakalamaları engellemek için satır içi grup öğesini (?n:) kullanabilirsiniz. Aşağıdaki örnek, dış gruptaki ((?>\w+),?\s?)adsız yakalamaları engellemek için önceki deseni değiştirir. Bunun, iç gruptaki adsız yakalamaları da gizlediğini unutmayın.
using System;
using System.Text.RegularExpressions;
public class Explicit3Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit3Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
Derlenmiş normal ifadeler
Not
Mümkün olduğunda, seçeneğini kullanarak RegexOptions.Compiled normal ifadeleri derlemek yerine kaynak tarafından oluşturulan normal ifadeleri kullanın. Kaynak oluşturma, uygulamanızın daha hızlı başlatılmasına, daha hızlı çalışmasına ve kırpılabilir hale getirmenize yardımcı olabilir. Kaynak oluşturmanın ne zaman mümkün olduğunu öğrenmek için bkz . Ne zaman kullanılır?
Varsayılan olarak, .NET'teki normal ifadeler yorumlanır. Bir Regex nesne örneği başlatıldığında veya statik Regex bir yöntem çağrıldığında, normal ifade deseni bir özel işlem kodları kümesine ayrıştırılır ve yorumlayıcı bu işlem kodlarını kullanarak normal ifadeyi çalıştırır. Bu bir dengeyi içerir: normal ifade altyapısını başlatma maliyeti, çalışma zamanı performansı pahasına en aza indirilir.
seçeneğini kullanarak, yorumlanmış normal ifadeler yerine derlenmiş kullanabilirsiniz RegexOptions.Compiled . Bu durumda, bir desen normal ifade altyapısına geçirildiğinde, bir dizi işlem koduna ayrıştırılır ve ardından doğrudan ortak dil çalışma zamanına geçirilebilen ortak ara dile (CIL) dönüştürülür. Derlenmiş normal ifadeler, başlatma süresi pahasına çalışma zamanı performansını en üst düzeye çıkarır.
Not
Normal ifade yalnızca bir sınıf oluşturucusunun RegexOptions.Compiled Regex parametresine veya statik desen eşleştirme yöntemine options değer sağlanarak derlenebilir. Satır içi seçenek olarak kullanılamaz.
Hem statik hem de örnek normal ifadelerine yönelik çağrılarda derlenmiş normal ifadeleri kullanabilirsiniz. Statik normal ifadelerde, RegexOptions.Compiled seçeneği normal ifade desen eşleştirme yönteminin parametresine options geçirilir. Örneğin normal ifadeler, sınıf oluşturucusunun options parametresine Regex geçirilir. Her iki durumda da performansın artırılmasına neden olur.
Ancak, performanstaki bu iyileştirme yalnızca aşağıdaki koşullar altında gerçekleşir:
Regex Belirli bir normal ifadeyi temsil eden bir nesne, normal ifade desen eşleştirme yöntemlerine yapılan birden çok çağrıda kullanılır.
Nesnenin Regex kapsam dışına çıkmalarına izin verilmiyor, bu nedenle yeniden kullanılabilir.
Statik normal ifade, normal ifade desen eşleştirme yöntemlerine yapılan birden çok çağrıda kullanılır. (Statik yöntem çağrılarında kullanılan normal ifadeler normal ifade altyapısı tarafından önbelleğe alındığından performans iyileştirmesi mümkündür.)
Not
seçeneği RegexOptions.Compiled , önceden tanımlanmış, derlenmiş normal ifadeler içeren özel amaçlı bir derleme oluşturan eski Regex.CompileToAssembly yöntemle ilgisizdir.
Boşluğu yoksay
Varsayılan olarak, normal ifade desenindeki boşluk önemlidir; normal ifade altyapısını giriş dizesindeki bir boşluk karakteriyle eşleşmeye zorlar. Bu nedenle, "\b\w+\s" ve " " "\b\w+ normal ifadeleri kabaca eşdeğer normal ifadelerdir. Buna ek olarak, normal ifade deseninde sayı işareti (#) ile karşılaşıldığında, eşleştirilecek değişmez karakter olarak yorumlanır.
seçeneği RegexOptions.IgnorePatternWhitespace veya x satır içi seçeneği, bu varsayılan davranışı aşağıdaki gibi değiştirir:
Normal ifade desenindeki boşaltılmamış boşluk yoksayılır. Normal ifade deseninin bir parçası olmak için boşluk karakterlerinin kaçış karakteri (örneğin, " veya
\s"\") olması gerekir.Sayı işareti (#), değişmez karakter yerine açıklamanın başlangıcı olarak yorumlanır. Normal ifade desenindeki karakterden
#sonraki\nkaraktere veya dizenin sonuna kadar olan tüm metinler açıklama olarak yorumlanır.
Ancak, aşağıdaki durumlarda, seçeneğini kullansanız RegexOptions.IgnorePatternWhitespace bile normal ifadedeki boşluk karakterleri yoksayılamaz:
Karakter sınıfı içindeki boşluklar her zaman tam anlamıyla yorumlanır. Örneğin, normal ifade deseni
[ .,;:]herhangi bir tek boşluk karakteri, nokta, virgül, noktalı virgül veya iki nokta üst üste ile eşleşir.Köşeli ayraçlı niceleyici içinde n,
{n},}ve{n,m}gibi{boşluklara izin verilmez. Örneğin, normal ifade deseni\d{1, 3}boşluk karakteri içerdiğinden bir ile üç basamak arasındaki basamak dizileriyle eşleşemez.Dil öğesini tanıtırken karakter dizisinde boşluk olmasına izin verilmez. Örneğin:
Dil öğesi
(?:alt ifadesi), kapsüllenmeyen bir grubu temsil eder ve(?:öğenin bölümünde eklenmiş boşluk olamaz. Normal ifade altyapısı deseni ayrıştıramadığından ve desen(? :alt)ifadesi alt ifadeyle eşleşmediğinden, desen( ?:alt)ifadesi çalışma zamanında bir ArgumentException oluşturur.Unicode kategorisini veya adlandırılmış bloğu temsil eden dil öğesi
\p{adı}, öğenin bölümüne eklenmiş boşluklar\p{içeremez. Boşluk eklerseniz, öğesi çalışma zamanında bir ArgumentException oluşturur.
Bu seçeneğin etkinleştirilmesi, genellikle ayrıştırılması ve anlaşılması zor olan normal ifadeleri basitleştirmeye yardımcı olur. Okunabilirliği artırır ve normal ifadeyi belgelemesini mümkün kılar.
Aşağıdaki örnek aşağıdaki normal ifade desenini tanımlar:
\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.
Bu desen, yalnızca Açık Yakalamalar bölümünde tanımlanan desene benzer, ancak desen boşluklarını RegexOptions.IgnorePatternWhitespace yoksayma seçeneğini kullanır.
using System;
using System.Text.RegularExpressions;
public class Whitespace1Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Whitespace1Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
Aşağıdaki örnek, desen boşluklarını yoksaymak için satır içi seçeneğini (?x) kullanır.
using System;
using System.Text.RegularExpressions;
public class Whitespace2Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Whitespace2Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
Sağdan sola modu
Varsayılan olarak, normal ifade altyapısı soldan sağa arar. seçeneğini kullanarak RegexOptions.RightToLeft arama yönünü tersine çevirebilirsiniz. Sağdan sola arama otomatik olarak dizenin son karakter konumunda başlar. gibi Regex.Match(String, Int32)bir başlangıç konumu parametresi içeren desen eşleştirme yöntemleri için, belirtilen başlangıç konumu, aramanın başlayacağı en sağdaki karakter konumunun dizinidir.
Not
Sağdan sola desen modu yalnızca bir Regex sınıf oluşturucusunun RegexOptions.RightToLeft parametresine veya statik desen eşleştirme yöntemine options değer sağlanarak kullanılabilir. Satır içi seçenek olarak kullanılamaz.
Örnek
Normal ifade \bb\w+\s , "b" harfiyle başlayan ve ardından boşluk karakteri gelen iki veya daha fazla karakter içeren sözcüklerle eşleşir. Aşağıdaki örnekte, giriş dizesi bir veya daha fazla "b" karakteri içeren üç sözcük içerir. birinci ve ikinci sözcükler "b" ile başlar ve üçüncü sözcük "b" ile biter. Sağdan sola arama örneğinden elde edilen çıktıda gösterildiği gibi, normal ifade deseniyle yalnızca birinci ve ikinci sözcükler eşleşir ve ikinci sözcük önce eşleştirilir.
using System;
using System.Text.RegularExpressions;
public class RTL1Example
{
public static void Main()
{
string pattern = @"\bb\w+\s";
string input = "build band tab";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// 'band ' found at position 6.
// 'build ' found at position 0.
Imports System.Text.RegularExpressions
Module RTL1Example
Public Sub Main()
Dim pattern As String = "\bb\w+\s"
Dim input As String = "build band tab"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'band ' found at position 6.
' 'build ' found at position 0.
Değerlendirme sırası
seçeneği RegexOptions.RightToLeft arama yönünü değiştirir ve ayrıca normal ifade deseninin değerlendirilme sırasını tersine çevirir. Sağdan sola aramada arama düzeni sağdan sola okunur. Yakalama grupları ve geri başvurular gibi öğeleri etkileyebildiği için bu ayrım önemlidir. Örneğin, ifade Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) bir eşleşme abcabcbulur, ancak soldan sağa aramada ()Regex.Match("abcabc", @"\1(abc)", RegexOptions.None) eşleşme bulunmaz. Bunun nedeni, bir eşleşmenin (abc) bulunması için numaralandırılmış yakalama grubu öğesinden (\1) önce öğesinin değerlendirilmesi gerekir.
Lookahead ve lookbehind onayları
Bir lookahead () veya lookbehind ((?=subexpression)(?<=subexpression)) onayı için eşleşmenin konumu sağdan sola aramada değişmez. Lookahead onayları geçerli eşleşme konumunun sağındakine bakar; lookbehind onayları geçerli eşleşme konumunun soluna bakar.
İpucu
Aramanın sağdan sola veya değil olmasına bakılmaksızın, lookbehind'ler geçerli eşleşme konumundan başlayarak sağdan sola arama kullanılarak uygulanır.
Örneğin, normal ifade (?<=\d{1,2}\s)\w+,\s\d{4} bir ay adından önceki bir tarihi test etmek için lookbehind onayını kullanır. Ardından normal ifade ay ve yıl ile eşleşir. Lookahead ve lookbehind onayları hakkında bilgi için bkz . Yapıları Gruplandırma.
using System;
using System.Text.RegularExpressions;
public class RTL2Example
{
public static void Main()
{
string[] inputs = { "1 May, 1917", "June 16, 2003" };
string pattern = @"(?<=\d{1,2}\s)\w+,\s\d{4}";
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
if (match.Success)
Console.WriteLine("The date occurs in {0}.", match.Value);
else
Console.WriteLine("{0} does not match.", input);
}
}
}
// The example displays the following output:
// The date occurs in May, 1917.
// June 16, 2003 does not match.
Imports System.Text.RegularExpressions
Module RTL2Example
Public Sub Main()
Dim inputs() As String = {"1 May, 1917", "June 16, 2003"}
Dim pattern As String = "(?<=\d{1,2}\s)\w+,\s\d{4}"
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
If match.Success Then
Console.WriteLine("The date occurs in {0}.", match.Value)
Else
Console.WriteLine("{0} does not match.", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' The date occurs in May, 1917.
' June 16, 2003 does not match.
Normal ifade deseni aşağıdaki tabloda gösterildiği gibi tanımlanır.
| Desen | Açıklama |
|---|---|
(?<=\d{1,2}\s) |
Eşleşmenin başında bir veya iki ondalık basamak ve ardından boşluk olmalıdır. |
\w+ |
Bir veya daha fazla sözcük karakteri eşleştir. |
, |
Bir virgül karakteri eşleştirin. |
\s |
Bir boşluk karakteri ile eşleştirin. |
\d{4} |
Dört ondalık basamağı eşleştirin. |
ECMAScript eşleştirme davranışı
Varsayılan olarak, normal ifade altyapısı normal ifade desenini metin girişiyle eşleştirirken kurallı davranış kullanır. Ancak, seçeneği belirterek RegexOptions.ECMAScript normal ifade altyapısına ECMAScript eşleştirme davranışını kullanmasını belirtebilirsiniz.
Not
ECMAScript uyumlu davranış, yalnızca değeri bir Regex sınıf oluşturucusunun parametresine veya statik desen eşleştirme yöntemine options sağlayarak RegexOptions.ECMAScript kullanılabilir. Satır içi seçenek olarak kullanılamaz.
Bu RegexOptions.ECMAScript seçenek yalnızca ve RegexOptions.Multiline seçenekleriyle RegexOptions.IgnoreCase birleştirilebilir. Normal ifadede başka bir seçeneğin kullanılması sonucunda bir ArgumentOutOfRangeExceptionolur.
ECMAScript ve kurallı normal ifadelerin davranışı üç alanda farklılık gösterir: karakter sınıfı söz dizimi, kendi kendine başvuran yakalama grupları ve sekizli ve geri başvuru yorumu.
Karakter sınıfı söz dizimi. Kurallı normal ifadeler Unicode'u desteklediği halde ECMAScript desteklemediğinden, ECMAScript'teki karakter sınıflarının söz dizimi daha sınırlıdır ve bazı karakter sınıfı dil öğeleri farklı anlamlara sahiptir. Örneğin, ECMAScript Unicode kategorisi veya blok öğeleri ve
\Pgibi dil öğelerini\pdesteklemez. Benzer şekilde, bir sözcük karakteriyle\weşleşen öğesi, ECMAScript kullanılırken ve[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]kurallı davranış kullanılırken karakter sınıfıyla eşdeğerdir[a-zA-Z_0-9]. Daha fazla bilgi için bkz . Karakter Sınıfları.Aşağıdaki örnekte kurallı ve ECMAScript desen eşleştirme arasındaki fark gösterilmektedir. Ardından boşluk karakterleri gelen sözcüklerle eşleşen bir normal ifade
\b(\w+\s*)+tanımlar. Giriş, biri Latin karakter kümesini, diğeri kiril karakter kümesini kullanan iki dizeden oluşur. Çıktıda gösterildiği gibi ECMAScript eşleştirmesi Regex.IsMatch(String, String, RegexOptions) kullanan yöntemine yapılan çağrı Kiril sözcüklerle eşleşemezken kurallı eşleştirme kullanan yöntem çağrısı bu sözcüklerle eşleşir.using System; using System.Text.RegularExpressions; public class EcmaScriptExample { public static void Main() { string[] values = { "целый мир", "the whole world" }; string pattern = @"\b(\w+\s*)+"; foreach (var value in values) { Console.Write("Canonical matching: "); if (Regex.IsMatch(value, pattern)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.Write("ECMAScript matching: "); if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.WriteLine(); } } } // The example displays the following output: // Canonical matching: 'целый мир' matches the pattern. // ECMAScript matching: целый мир does not match the pattern. // // Canonical matching: 'the whole world' matches the pattern. // ECMAScript matching: 'the whole world' matches the pattern.Imports System.Text.RegularExpressions Module Ecma1Example Public Sub Main() Dim values() As String = {"целый мир", "the whole world"} Dim pattern As String = "\b(\w+\s*)+" For Each value In values Console.Write("Canonical matching: ") If Regex.IsMatch(value, pattern) Then Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.Write("ECMAScript matching: ") If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript) Then Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.WriteLine() Next End Sub End Module ' The example displays the following output: ' Canonical matching: 'целый мир' matches the pattern. ' ECMAScript matching: целый мир does not match the pattern. ' ' Canonical matching: 'the whole world' matches the pattern. ' ECMAScript matching: 'the whole world' matches the pattern.Kendi kendine başvuran yakalama grupları. Kendisine bir geri başvuru içeren normal ifade yakalama sınıfı, her yakalama yinelemesiyle güncelleştirilmelidir. Aşağıdaki örnekte gösterildiği gibi bu özellik, normal ifadenin
((a+)(\1) ?)+ECMAScript kullanırken " aa aa aaaaaa " giriş dizesiyle eşleşmesini sağlar, ancak kurallı eşleştirme kullanılırken eşleşmez.using System; using System.Text.RegularExpressions; public class EcmaScript2Example { static string pattern; public static void Main() { string input = "aa aaaa aaaaaa "; pattern = @"((a+)(\1) ?)+"; // Match input using canonical matching. AnalyzeMatch(Regex.Match(input, pattern)); // Match input using ECMAScript. AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript)); } private static void AnalyzeMatch(Match m) { if (m.Success) { Console.WriteLine("'{0}' matches {1} at position {2}.", pattern, m.Value, m.Index); int grpCtr = 0; foreach (Group grp in m.Groups) { Console.WriteLine(" {0}: '{1}'", grpCtr, grp.Value); grpCtr++; int capCtr = 0; foreach (Capture cap in grp.Captures) { Console.WriteLine(" {0}: '{1}'", capCtr, cap.Value); capCtr++; } } } else { Console.WriteLine("No match found."); } Console.WriteLine(); } } // The example displays the following output: // No match found. // // '((a+)(\1) ?)+' matches aa aaaa aaaaaa at position 0. // 0: 'aa aaaa aaaaaa ' // 0: 'aa aaaa aaaaaa ' // 1: 'aaaaaa ' // 0: 'aa ' // 1: 'aaaa ' // 2: 'aaaaaa ' // 2: 'aa' // 0: 'aa' // 1: 'aa' // 2: 'aa' // 3: 'aaaa ' // 0: '' // 1: 'aa ' // 2: 'aaaa 'Imports System.Text.RegularExpressions Module Ecma2Example Dim pattern As String Public Sub Main() Dim input As String = "aa aaaa aaaaaa " pattern = "((a+)(\1) ?)+" ' Match input using canonical matching. AnalyzeMatch(Regex.Match(input, pattern)) ' Match input using ECMAScript. AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript)) End Sub Private Sub AnalyzeMatch(m As Match) If m.Success Then Console.WriteLine("'{0}' matches {1} at position {2}.", pattern, m.Value, m.Index) Dim grpCtr As Integer = 0 For Each grp As Group In m.Groups Console.WriteLine(" {0}: '{1}'", grpCtr, grp.Value) grpCtr += 1 Dim capCtr As Integer = 0 For Each cap As Capture In grp.Captures Console.WriteLine(" {0}: '{1}'", capCtr, cap.Value) capCtr += 1 Next Next Else Console.WriteLine("No match found.") End If Console.WriteLine() End Sub End Module ' The example displays the following output: ' No match found. ' ' '((a+)(\1) ?)+' matches aa aaaa aaaaaa at position 0. ' 0: 'aa aaaa aaaaaa ' ' 0: 'aa aaaa aaaaaa ' ' 1: 'aaaaaa ' ' 0: 'aa ' ' 1: 'aaaa ' ' 2: 'aaaaaa ' ' 2: 'aa' ' 0: 'aa' ' 1: 'aa' ' 2: 'aa' ' 3: 'aaaa ' ' 0: '' ' 1: 'aa ' ' 2: 'aaaa 'Normal ifade aşağıdaki tabloda gösterildiği gibi tanımlanır.
Desen Açıklama (a+) "a" harfini bir veya daha fazla kez eşleştirin. Bu ikinci yakalama grubudur. (\1) İlk yakalama grubu tarafından yakalanan alt dizeyi eşleştirin. Bu, üçüncü yakalama grubudur. ? Sıfır veya bir boşluk karakteri eşleştirin. ((a+)(\1) ?) + Bir veya daha fazla "a" karakterinin desenini ve ardından ilk yakalama grubuyla eşleşen bir dizeyi ve ardından sıfır veya bir boşluk karakterini bir veya daha fazla kez eşleştirin. Bu ilk yakalama grubudur. Sekizli kaçışlar ile geri başvurular arasındaki belirsizliklerin çözümü. Aşağıdaki tabloda kurallı ve ECMAScript normal ifadelerine göre sekizlik ve geri başvuru yorumlama arasındaki farklar özetlenir.
Regular expression Kurallı davranış ECMAScript davranışı \0ardından 0 ile 2 sekizli basamakSekizli olarak yorumla. Örneğin, \044her zaman sekizlik değer olarak yorumlanır ve "$" anlamına gelir.Aynı davranış. \ve ardından 1 ile 9 arasından bir basamak ve ardından ek ondalık basamak yok,Geri başvuru olarak yorumla. Örneğin, \9dokuzuncu bir yakalama grubu olmasa bile her zaman geri başvuru 9 anlamına gelir. Yakalama grubu yoksa, normal ifade ayrıştırıcısı bir ArgumentExceptionoluşturur.Tek bir ondalık basamak yakalama grubu varsa, bu rakama geri başvuru yapın. Aksi takdirde, değeri değişmez değer olarak yorumlar. \ardından 1 ile 9 arasından bir basamak ve ardından ek ondalık basamaklarBasamakları ondalık değer olarak yorumlama. Bu yakalama grubu varsa, ifadeyi geri başvuru olarak yorumla.
Aksi takdirde, sekizli basamakları sekizlik 377'ye kadar yorumla; başka bir ifadeyle, değerin yalnızca düşük 8 bitini göz önünde bulundurun. Kalan basamakları değişmez değer olarak yorumla. Örneğin, ifadesinde\3000, 300 grubu yakalanıyorsa geri başvuru 300 olarak yorumla; 300 grubunu yakalama yoksa, sekizli 300 ve ardından 0 olarak yorumla.Mümkün olduğunca çok basamağı yakalamaya başvurabilen ondalık bir değere dönüştürerek geri başvuru olarak yorumlayabilirsiniz. Hiçbir basamak dönüştürülemiyorsa, sekizlik 377'ye kadar olan baştaki sekizlik basamakları kullanarak sekizli olarak yorumlayabilirsiniz; kalan basamakları değişmez değer olarak yorumlar.
Sabit kültürü kullanarak karşılaştırma
Varsayılan olarak, normal ifade altyapısı büyük/küçük harfe duyarsız karşılaştırmalar gerçekleştirdiğinde, eşdeğer büyük ve küçük harf karakterlerini belirlemek için geçerli kültürün büyük/küçük harf kurallarını kullanır.
Ancak bu davranış, özellikle kullanıcı girişini parolalar, dosyalar veya URL'ler gibi sistem kaynaklarının adlarıyla karşılaştırırken bazı karşılaştırma türleri için istenmeyen bir davranıştır. Aşağıdaki örnekte bu tür bir senaryo gösterilmektedir. Kod, URL'si FILE:// ile önceden oluşturulmuş herhangi bir kaynağa erişimi engellemeye yöneliktir. Normal ifade, normal ifadesini $FILE://kullanarak dizeyle büyük/küçük harfe duyarlı olmayan bir eşleşme dener. Ancak mevcut sistem kültürü tr-TR (Türk-Türkiye) olduğunda "i" büyük harfle eşdeğer değildir. Sonuç olarak, yöntemine Regex.IsMatch yapılan çağrı döndürür falseve dosyaya erişime izin verilir.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-sensitive matching ({0} culture)...",
Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-sensitive matching (tr-TR culture)...
// Access to file://c:/Documents.MyReport.doc is allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-sensitive matching ({0} culture)...",
Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-sensitive matching (tr-TR culture)...
' Access to file://c:/Documents.MyReport.doc is allowed.
Not
Büyük/küçük harfe duyarlı olan ve sabit kültürü kullanan dize karşılaştırmaları hakkında daha fazla bilgi için bkz . Dizeleri Kullanmak için En İyi Yöntemler.
Geçerli kültürün büyük/küçük harfe duyarsız karşılaştırmalarını kullanmak yerine, dildeki kültürel farklılıkları yoksayma ve sabit kültürün kurallarını kullanma seçeneğini belirtebilirsiniz RegexOptions.CultureInvariant .
Not
Sabit kültürü kullanarak karşılaştırma yalnızca değeri sınıf Regex oluşturucusunun veya statik desen eşleştirme yönteminin parametresine options sağlanarak RegexOptions.CultureInvariant kullanılabilir. Satır içi seçenek olarak kullanılamaz.
Aşağıdaki örnek, statik Regex.IsMatch(String, String, RegexOptions) yöntemi içeren seçeneklerle RegexOptions.CultureInvariantçağrılmaları dışında önceki örnekle aynıdır. Geçerli kültür Türkçe (Türkiye) olarak ayarlandığında bile normal ifade altyapısı "DOSYA" ve "dosya" ile başarıyla eşleşip dosya kaynağına erişimi engelleyebilir.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern,
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-insensitive matching...
// URLs that access files are not allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern,
RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-insensitive matching...
' URLs that access files are not allowed.
Geri izleme modu
Varsayılan olarak, . NET'in regex altyapısı, desen eşleşmelerini bulmaya çalışmak için geri izlemeyi kullanır. Geri izleme altyapısı, tek bir desenle eşleşmeye çalışan altyapıdır ve bu başarısız olursa geri gider ve alternatif bir desenle eşleştirmeye çalışır, vb. Geri izleme altyapısı tipik durumlar için çok hızlıdır, ancak desen değişimlerinin sayısı arttıkça yavaşlar ve bu da yıkıcı geri dönüşlere yol açabilir. RegexOptions.NonBacktracking.NET 7'de sunulan seçenek geri izleme kullanmaz ve en kötü senaryoyu önler. Amacı, aranan girişe bakılmaksızın tutarlı bir şekilde iyi davranış sağlamaktır.
Bu RegexOptions.NonBacktracking seçenek, diğer yerleşik altyapıların desteklediği her şeyi desteklemez. Özellikle, seçeneği veya RegexOptions.ECMAScriptile RegexOptions.RightToLeft birlikte kullanılamaz. Ayrıca, desende aşağıdaki yapılara izin vermez:
- Atomik gruplar
- Geri Başvurular
- Dengeleme grupları
- Koşullar
- Aramalar
- Başlangıç tutturucuları (
\G)
RegexOptions.NonBacktracking ayrıca yürütmeyle ilgili olarak küçük bir fark vardır. Yakalama grubu bir döngüdeyse, çoğu (non-.NET) regex altyapısı yalnızca bu yakalama için son eşleşen değeri sağlar. Fakat. NET'in regex altyapısı bir döngü içinde yakalanan tüm değerleri izler ve bunlara erişim sağlar. Seçeneği RegexOptions.NonBacktracking diğer çoğu regex uygulamasına benzer ve yalnızca son yakalamayı sağlamayı destekler.
Geri izleme hakkında daha fazla bilgi için bkz . Normal ifadelerde geri izleme.
Ayrıca bkz.
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin