Regex.Replace Yöntem

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, yerel makineyi ve UNC yolundaki sürücü adlarını yerel dosya yolu ile değiştirmek için Replace(String, String, String, RegexOptions) yöntemini kullanır. Normal ifade, yerel bilgisayarın adını eklemek için Environment.MachineName özelliğini ve mantıksal sürücülerin adlarını eklemek için Environment.GetLogicalDrives yöntemini kullanır. Tüm normal ifade dizesi karşılaştırmaları büyük/küçük harfe duyarlı değildir. Örneği başarıyla çalıştırmak için "MyMachine" değişmez dizesini yerel makine adınızla değiştirmeniz gerekir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Normal ifade deseni aşağıdaki ifadeyle tanımlanır:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Aşağıdaki tabloda normal ifade deseninin nasıl yorumlandığı gösterilmektedir.

Değiştirme düzeni $1 tüm eşleşmeyi yakalanan ilk alt ifadeyle değiştirir. Yani, UNC makinesini ve sürücü adını sürücü harfiyle değiştirir.

Açıklamalar

Statik Replace yöntemleri, belirtilen normal ifade desenine sahip bir Regex nesnesi oluşturmak ve Replaceörnek yöntemini çağırmakla eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru. options parametresi için RightToLeft belirtirseniz, eşleşme araması giriş dizesinin sonunda başlar ve sola taşınır; aksi takdirde, arama giriş dizesinin başlangıcında başlar ve sağa taşınır.

replacement parametresi, inputiçindeki her eşleşmenin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

Değiştirme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Arayanlara Notlar

Bu yöntem, çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına girmesini engelleyen InfiniteMatchTimeoutdeğeri kullanılır. Desen eşleşmesini değiştirmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan Replace(String, String, String, RegexOptions, TimeSpan)yöntemidir.

Ayrıca bkz.

• RegexOptions
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, yerel makineyi ve UNC yolundaki sürücü adlarını yerel dosya yolu ile değiştirmek için Replace(String, String, String, RegexOptions, TimeSpan) yöntemini kullanır. Normal ifade, yerel bilgisayarın adını eklemek için Environment.MachineName özelliğini ve mantıksal sürücülerin adlarını eklemek için Environment.GetLogicalDrives yöntemini kullanır. Tüm normal ifade dizesi karşılaştırmaları büyük/küçük harfe duyarlı değildir ve eşleşme 0,5 saniye içinde bulunamazsa tek değiştirme işlemleri zaman aşımına ular. Örneği başarıyla çalıştırmak için "MyMachine" değişmez dizesini yerel makine adınızla değiştirmeniz gerekir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Normal ifade deseni aşağıdaki ifadeyle tanımlanır:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Aşağıdaki tabloda normal ifade deseninin nasıl yorumlandığı gösterilmektedir.

Değiştirme düzeni $1 tüm eşleşmeyi yakalanan ilk alt ifadeyle değiştirir. Yani, UNC makinesini ve sürücü adını sürücü harfiyle değiştirir.

Açıklamalar

Statik Replace yöntemleri, belirtilen normal ifade desenine sahip bir Regex nesnesi oluşturmak ve Replaceörnek yöntemini çağırmakla eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru. options parametresi için RightToLeft belirtirseniz, eşleşme araması giriş dizesinin sonunda başlar ve sola taşınır; aksi takdirde, arama giriş dizesinin başlangıcında başlar ve sağa taşınır.

replacement parametresi, inputiçindeki her eşleşmenin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

matchTimeout parametresi, bir desen eşleştirme yönteminin zaman aşımına uğramadan önce eşleşmeyi ne kadar süreyle bulmaya çalışması gerektiğini belirtir. Zaman aşımı aralığı ayarlamak, aşırı geri izleme kullanan normal ifadelerin, yakın eşleşmeler içeren girişleri işlerken yanıt vermeyi durdurmak için görünmesini engeller. Daha fazla bilgi için bkz. Normal İfadeler ve Geri İzlemeiçin En İyi Yöntemler. Bu zaman aralığında eşleşme bulunmazsa, yöntem bir RegexMatchTimeoutException özel durumu oluşturur. matchTimeout, yöntemin yürütüldiği uygulama etki alanı için tanımlanan varsayılan zaman aşımı değerlerini geçersiz kılar.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Arayanlara Notlar

matchTimeout parametresini iki saniye gibi uygun bir değere ayarlamanızı öneririz. InfiniteMatchTimeoutbelirterek zaman aşımlarını devre dışı bırakırsanız, normal ifade altyapısı biraz daha iyi performans sunar. Ancak, zaman aşımlarını yalnızca aşağıdaki koşullar altında devre dışı bırakmalısınız:

• Normal bir ifade tarafından işlenen giriş bilinen ve güvenilen bir kaynaktan türetildiğinde veya statik metinden oluştuğunda. Bu, kullanıcılar tarafından dinamik olarak giriş yapılan metinleri dışlar.

• Normal ifade deseni, eşleşmeleri, eşleşme olmayanları ve yakın eşleşmeleri verimli bir şekilde işlediğinden emin olmak için kapsamlı bir şekilde test edildiğinde.

• Normal ifade deseni, yakın bir eşleşmeyi işlerken aşırı geri dönüşe neden olduğu bilinen bir dil öğesi içermediğinde.

Ayrıca bkz.

• RegexOptions
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri
• Normal İfadelerde Geri İzlemeyi
• .NET normal ifadeler için en iyi yöntemler

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parametreler

Döndürülenler

Eşleşen her dizenin yerini bir değiştirme dizesinin alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Açıklamalar

Regex.Replace(String, MatchEvaluator, Int32, Int32) yöntemi, aşağıdaki koşullardan biri doğruysa normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi, normal ifade değiştirme deseni tarafından hazır olarak belirtilemez.
• Değiştirme dizesi, eşleşen dizede yapılan bazı işlemlerden kaynaklanır.
• Değiştirme dizesi koşullu işleme sonucu verir.

yöntemi, Regex.Matches(String, Int32) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki ilk countMatch nesnelerini evaluator temsilciye geçirmekle eşdeğerdir.

startathakkında daha fazla ayrıntı için Match(String, Int32)'nin Açıklamalar bölümüne bakın.

Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• MatchEvaluator
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dilini - Hızlı Başvuru

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String

Parametreler

Döndürülenler

Eşleşen her dizenin yerini bir değiştirme dizesinin alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir dizedeki tek tek sözcükleri ayıklamak için normal bir ifade kullanır ve ardından MatchEvaluator temsilcisini kullanarak WordScramble adlı ve sözcükteki tek tek harfleri karıştıran bir yöntem çağırır. Bunu yapmak için WordScramble yöntemi, eşleşmedeki karakterleri içeren bir dizi oluşturur. Ayrıca rastgele kayan nokta sayılarıyla dolduran paralel bir dizi oluşturur. Diziler Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) yöntemi çağrılarak sıralanır ve sıralanmış dizi, String sınıf oluşturucusunun bağımsız değişkeni olarak sağlanır. Bu yeni oluşturulan dize daha sonra WordScramble yöntemi tarafından döndürülür. Normal ifade deseni \w+ bir veya daha fazla sözcük karakteriyle eşleşir; normal ifade altyapısı, boşluk karakteri gibi sözcük olmayan bir karakterle karşılaşana kadar eşleşmeye karakter eklemeye devam eder. Replace(String, String, MatchEvaluator, RegexOptions) yöntemi çağrısı, RegexOptions.IgnorePatternWhitespace seçeneğini içerir, böylece normal ifade desenindeki \w+ # Matches all the characters in a word. açıklama normal ifade altyapısı tarafından yoksayılır.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Açıklamalar

Regex.Replace(String, String, MatchEvaluator, RegexOptions) yöntemi, aşağıdaki koşullardan biri doğruysa içindeki normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi, normal ifade değiştirme deseni tarafından hazır olarak belirtilemez.

• Değiştirme dizesi, eşleşen dizede yapılan bazı işlemlerden kaynaklanır.

• Değiştirme dizesi koşullu işleme sonucu verir.

yöntemi, Regex.Matches(String, String, RegexOptions) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki her Match nesnesini evaluator temsilcisine geçirmekle eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

options parametresi için RightToLeft belirtirseniz, eşleşme araması giriş dizesinin sonunda başlar ve sola taşınır; aksi takdirde, arama giriş dizesinin başlangıcında başlar ve sağa taşınır.

Değiştirme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• MatchEvaluator
• RegexOptions
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir dizedeki tek tek sözcükleri ayıklamak için normal bir ifade kullanır ve ardından MatchEvaluator temsilcisini kullanarak WordScramble adlı ve sözcükteki tek tek harfleri karıştıran bir yöntem çağırır. Bunu yapmak için WordScramble yöntemi, eşleşmedeki karakterleri içeren bir dizi oluşturur. Ayrıca rastgele kayan nokta sayılarıyla dolduran paralel bir dizi oluşturur. Diziler Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) yöntemi çağrılarak sıralanır ve sıralanmış dizi, String sınıf oluşturucusunun bağımsız değişkeni olarak sağlanır. Bu yeni oluşturulan dize daha sonra WordScramble yöntemi tarafından döndürülür. Normal ifade deseni \w+ bir veya daha fazla sözcük karakteriyle eşleşir; normal ifade altyapısı, boşluk karakteri gibi sözcük olmayan bir karakterle karşılaşana kadar eşleşmeye karakter eklemeye devam eder. Replace(String, String, MatchEvaluator, RegexOptions) yöntemi çağrısı, RegexOptions.IgnorePatternWhitespace seçeneğini içerir, böylece normal ifade desenindeki \w+ # Matches all the characters in a word. açıklama normal ifade altyapısı tarafından yoksayılır.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Açıklamalar

Regex.Replace(String, String, MatchEvaluator, RegexOptions) yöntemi, aşağıdaki koşullardan biri doğruysa normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi normal ifade değiştirme deseni tarafından kolayca belirtilemiyorsa.

• Değiştirilen dize, eşleşen dizede gerçekleştirilen bazı işlemlerden kaynaklanırsa.

• Değiştirme dizesi koşullu işlemeden kaynaklanırsa.

yöntemi, Regex.Matches(String, String, RegexOptions) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki her Match nesnesini evaluator temsilcisine geçirmekle eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

options parametresi için RightToLeft belirtirseniz, eşleşme araması giriş dizesinin sonunda başlar ve sola taşınır; aksi takdirde, arama giriş dizesinin başlangıcında başlar ve sağa taşınır.

matchTimeout parametresi, bir desen eşleştirme yönteminin zaman aşımına uğramadan önce eşleşmeyi ne kadar süreyle bulmaya çalışması gerektiğini belirtir. Zaman aşımı aralığının ayarlanması, aşırı geri izleme kullanan normal ifadelerin "yakın eşleşmeler içeren girişi işlerken yanıt vermeyi durdurma" olarak görünmesini önler. Daha fazla bilgi için bkz. Normal İfadeler ve Geri İzlemeiçin En İyi Yöntemler. Bu zaman aralığında eşleşme bulunmazsa, yöntem bir RegexMatchTimeoutException özel durumu oluşturur. matchTimeout, yöntemin yürütüldiği uygulama etki alanı için tanımlanan varsayılan zaman aşımı değerlerini geçersiz kılar.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Arayanlara Notlar

matchTimeout parametresini iki saniye gibi uygun bir değere ayarlamanızı öneririz. InfiniteMatchTimeoutbelirterek zaman aşımlarını devre dışı bırakırsanız, normal ifade altyapısı biraz daha iyi performans sunar. Ancak, zaman aşımlarını yalnızca aşağıdaki koşullar altında devre dışı bırakmalısınız:

• Normal bir ifade tarafından işlenen giriş bilinen ve güvenilen bir kaynaktan türetildiğinde veya statik metinden oluştuğunda. Bu, kullanıcılar tarafından dinamik olarak giriş yapılan metinleri dışlar.

• Normal ifade deseni, eşleşmeleri, eşleşme olmayanları ve yakın eşleşmeleri verimli bir şekilde işlediğinden emin olmak için kapsamlı bir şekilde test edildiğinde.

• Normal ifade deseni, yakın bir eşleşmeyi işlerken aşırı geri dönüşe neden olduğu bilinen bir dil öğesi içermediğinde.

Ayrıca bkz.

• RegexOptions
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri
• Normal İfadelerde Geri İzlemeyi
• .NET normal ifadeler için en iyi yöntemler

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);

public string Replace (string input, string replacement, int count, int startat);

member this.Replace : string * string * int * int -> string

Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir dizenin ilk satırı dışında tümünü çift boşluklar. Bir metin satırıyla eşleşen, ^.*$bir normal ifade deseni tanımlar, dizenin ilk satırıyla eşleşmesi için Match(String) yöntemini çağırır ve ikinci satırın başlangıç konumunu belirlemek için Match.Index ve Match.Count özelliklerini kullanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

Normal ifade deseni ^.*$ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Değiştirilen dize (Visual Basic'tevbCrLf + "$&", C# dilinde "\n$&") eşleşen dizeden önce yeni bir satır ekler. C# örneğindeki \n C# derleyicisi tarafından yeni satır karakteri olarak yorumlandığını unutmayın; normal ifade karakter çıkışlarını temsil etmez.

Açıklamalar

Eşleşme araması, startat parametresi tarafından belirtilen konumdaki input dizesinde başlar. Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir. count negatifse, değiştirmeler dizenin sonuna kadar devam eder. count eşleşme sayısını aşarsa, tüm eşleşmeler değiştirilir.

startathakkında daha fazla ayrıntı için Match(String, Int32)'nin Açıklamalar bölümüne bakın.

replacement parametresi, inputiçindeki her eşleşmenin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• Normal İfadelerde Değiştirmeleri
• Normal İfade Dilini - Hızlı Başvuru

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);

public static string Replace (string input, string pattern, string replacement);

static member Replace : string * string * string -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir veya daha fazla boşluk karakteriyle eşleşen \s+normal ifadeyi tanımlar. " " yerine geçen dize, bunları tek bir boşluk karakteriyle değiştirir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Aşağıdaki örnek, yerel makineyi ve UNC yolundaki sürücü adlarını yerel dosya yolu ile değiştirmek için Replace(String, String, String) yöntemini kullanır. Normal ifade, yerel bilgisayarın adını eklemek için Environment.MachineName özelliğini ve mantıksal sürücülerin adlarını eklemek için Environment.GetLogicalDrives yöntemini kullanır. Örneği başarıyla çalıştırmak için "MyMachine" değişmez dizesini yerel makine adınızla değiştirmeniz gerekir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Normal ifade deseni aşağıdaki ifadeyle tanımlanır:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

Aşağıdaki tabloda normal ifade deseninin nasıl yorumlandığı gösterilmektedir.

Değiştirme düzeni $1 tüm eşleşmeyi yakalanan ilk alt ifadeyle değiştirir. Yani, UNC makinesini ve sürücü adını sürücü harfiyle değiştirir.

Açıklamalar

Statik Replace yöntemleri, belirtilen normal ifade desenine sahip bir Regex nesnesi oluşturmak ve Replaceörnek yöntemini çağırmakla eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru. Eşleşme araması, input dizesinin başında başlar.

replacement parametresi, inputiçindeki her eşleşmenin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

Değiştirme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Arayanlara Notlar

Bu yöntem, çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına girmesini engelleyen InfiniteMatchTimeoutdeğeri kullanılır. Desen eşleşmesini değiştirmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan Replace(String, String, String, RegexOptions, TimeSpan)yöntemidir.

Ayrıca bkz.

• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parametreler

Döndürülenler

Eşleşen her dizenin yerini bir değiştirme dizesinin alması dışında giriş dizesiyle aynı olan yeni bir dize. geçerli örnekte pattern eşleşmezse, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir dizedeki tek tek sözcükleri ayıklamak için normal bir ifade kullanır ve ardından MatchEvaluator temsilcisini kullanarak WordScramble adlı ve sözcükteki tek tek harfleri karıştıran bir yöntem çağırır. Bunu yapmak için WordScramble yöntemi, eşleşmedeki karakterleri içeren bir dizi oluşturur. Ayrıca rastgele kayan nokta sayılarıyla dolduran paralel bir dizi oluşturur. Diziler Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) yöntemi çağrılarak sıralanır ve sıralanmış dizi, String sınıf oluşturucusunun bağımsız değişkeni olarak sağlanır. Bu yeni oluşturulan dize daha sonra WordScramble yöntemi tarafından döndürülür. Normal ifade deseni \w+ bir veya daha fazla sözcük karakteriyle eşleşir; normal ifade altyapısı, boşluk karakteri gibi sözcük olmayan bir karakterle karşılaşana kadar eşleşmeye karakter eklemeye devam eder.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Açıklamalar

Regex.Replace(String, String, MatchEvaluator) yöntemi, aşağıdaki koşullardan biri doğruysa normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi, normal ifade değiştirme deseni tarafından hazır olarak belirtilemez.

• Değiştirme dizesi, eşleşen dizede yapılan bazı işlemlerden kaynaklanır.

• Değiştirme dizesi koşullu işleme sonucu verir.

yöntemi, Regex.Matches(String, String) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki her Match nesnesini evaluator temsilcisine geçirmekle eşdeğerdir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

Değiştirme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Arayanlara Notlar

Bu yöntem, çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına girmesini engelleyen InfiniteMatchTimeoutdeğeri kullanılır. Desen eşleşmesini değerlendirmek ve değiştirmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)yöntemidir.

Ayrıca bkz.

• MatchEvaluator
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dili Öğeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);

public string Replace (string input, string replacement, int count);

member this.Replace : string * string * int -> string

Public Function Replace (input As String, replacement As String, count As Integer) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, yinelenen karakterlerin ilk beş oluşumunu tek bir karakterle değiştirir. Normal ifade deseni (\w)\1 tek bir karakterin ardışık oluşumlarıyla eşleşir ve ilk oluşumu ilk yakalama grubuna atar. Değiştirme düzeni $1 tüm eşleşmeyi yakalanan ilk grupla değiştirir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Açıklamalar

Eşleşme araması, input dizesinin başında başlar. Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir. count negatifse, değiştirmeler dizenin sonuna kadar devam eder. count eşleşme sayısını aşarsa, tüm eşleşmeler değiştirilir.

replacement parametresi, inputiçindeki ilk count eşleşmelerinin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• Normal İfade Dilini - Hızlı Başvuru
• Normal İfadelerde Değiştirmeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parametreler

Döndürülenler

Eşleşen her dizenin yerini bir değiştirme dizesinin alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki kod örneği özgün dizeyi görüntüler, özgün dizedeki her sözcükle eşleşir, her eşleşmenin ilk karakterini büyük harfe dönüştürür ve sonra dönüştürülen dizeyi görüntüler.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]

Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

Açıklamalar

Regex.Replace(String, MatchEvaluator) yöntemi, aşağıdaki koşullardan biri doğruysa normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi, normal ifade değiştirme deseni tarafından hazır olarak belirtilemez.

• Değiştirme dizesi, eşleşen dizede yapılan bazı işlemlerden kaynaklanır.

• Değiştirme dizesi koşullu işleme sonucu verir.

yöntemi, Regex.Matches(String) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki her Match nesnesini evaluator temsilcisine geçirmekle eşdeğerdir.

Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• MatchEvaluator
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dilini - Hızlı Başvuru

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);

public string Replace (string input, string replacement);

member this.Replace : string * string -> string

Public Function Replace (input As String, replacement As String) As String

Parametreler

Döndürülenler

Değiştirilen dizenin eşleşen her dizenin yerini alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, bir veya daha fazla boşluk karakteriyle eşleşen \s+normal ifadeyi tanımlar. " " yerine geçen dize, bunları tek bir boşluk karakteriyle değiştirir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Aşağıdaki örnek, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?normal bir ifadeyi ve sayısal değerden baştaki veya sondaki para birimi simgesini kaldıran $2değiştirme desenini tanımlar.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Normal ifade aşağıdaki tabloda gösterildiği gibi yorumlanır.

Açıklamalar

Eşleşme araması, input dizesinin başında başlar. Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir.

replacement parametresi, inputiçindeki her eşleşmenin yerini alacak dizeyi belirtir. ,değişmez metin ve değiştirmelerinin herhangi bir bileşiminden oluşabilir. Örneğin, değiştirme deseni a*${test}b "a*" dizesini ve ardından varsa test yakalama grubuyla eşleşen alt dizeyi ve ardından "b" dizesini ekler. * karakteri, değiştirme deseni içinde meta karakter olarak tanınmaz.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• Normal İfade Dilini - Hızlı Başvuru
• Normal İfadelerde Değiştirmeleri

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

Kaynak:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parametreler

Döndürülenler

Eşleşen her dizenin yerini bir değiştirme dizesinin alması dışında giriş dizesiyle aynı olan yeni bir dize. Normal ifade deseni geçerli örnekte eşleşmiyorsa, yöntemi geçerli örneği değişmeden döndürür.

Özel durumlar

Örnekler

Aşağıdaki örnek, listedeki sözcüklerin yarısını bilerek yanlış göndermek için normal bir ifade kullanır. "ie" veya "ei" karakterlerini içeren sözcükleri eşleştirmek için normal ifade \w*(ie|ei)\w* kullanır. Eşleşen sözcüklerin ilk yarısını ReverseLetter yöntemine geçirir ve bu yöntem de eşleşen dizede "i" ve "e" değerlerini ters çevirmek için Replace(String, String, String, RegexOptions) yöntemini kullanır. Kalan sözcükler değişmeden kalır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

normal ifade \w*(ie|ei)\w* aşağıdaki tabloda gösterildiği gibi tanımlanır.

ReverseLetter yönteminde ([ie])([ie]) normal ifade deseni, diphthong "ie" veya "ei" içindeki ilk "i" veya "e" ile eşleşir ve harfi ilk yakalama grubuna atar. İkinci "i" veya "e" ile eşleşir ve harfi ikinci yakalama grubuna atar. İki karakter daha sonra $2$1değiştirme deseni ile Replace(String, String, String) yöntemi çağrılarak tersine çevrilir.

Açıklamalar

Regex.Replace(String, MatchEvaluator, Int32) yöntemi, aşağıdaki koşullardan biri doğruysa normal ifade eşleşmesini değiştirmek için kullanışlıdır:

• Değiştirme dizesi, normal ifade değiştirme deseni tarafından hazır olarak belirtilemez.

• Değiştirme dizesi, eşleşen dizede yapılan bazı işlemlerden kaynaklanır.

• Değiştirme dizesi koşullu işleme sonucu verir.

yöntemi, Regex.Matches(String) yöntemini çağırmak ve döndürülen MatchCollection koleksiyonundaki ilk countMatch nesnelerini evaluator temsilciye geçirmekle eşdeğerdir.

Normal ifade, geçerli Regex nesnesi için oluşturucu tarafından tanımlanan desendir.

evaluator parametresi, tanımladığınız ve her eşleşmeyi inceleyen özel bir yöntemin temsilcisidir. Özel yöntemin MatchEvaluator temsilcisiyle eşleşmesi için aşağıdaki imzaya sahip olması gerekir.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Özel yönteminiz, eşleşen girişin yerini alan bir dize döndürür.

Değiştirme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Eşleşme yoksa yöntemi input değişmeden döndürdüğünden, yöntemin giriş dizesinde herhangi bir değişiklik yapıp yapmadığını belirlemek için Object.ReferenceEquals yöntemini kullanabilirsiniz.

Ayrıca bkz.

• MatchEvaluator
• Normal İfadelerde Değiştirmeleri
• Normal İfade Dilini - Hızlı Başvuru