Regex.Replace Metod

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används ett reguljärt uttryck för att extrahera enskilda ord från en sträng och använder sedan ett MatchEvaluator ombud för att anropa en metod med namnet WordScramble som förvränger de enskilda bokstäverna i ordet. För att göra detta WordScramble skapar metoden en matris som innehåller tecknen i matchningen. Den skapar också en parallell matris som fylls i med slumpmässiga flyttalsnummer. Matriserna sorteras genom att anropa Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metoden och den sorterade matrisen tillhandahålls som ett argument till en String klasskonstruktor. Den här nyskapade strängen WordScramble returneras sedan av metoden . Det reguljära uttrycksmönstret \w+ matchar ett eller flera ordtecken. Motorn för reguljära uttryck fortsätter att lägga till tecken i matchningen tills det stöter på ett icke-ordtecken, till exempel ett blankstegstecken. Anropet Replace(String, String, MatchEvaluator, RegexOptions) till metoden innehåller RegexOptions.IgnorePatternWhitespace alternativet så att kommentaren i reguljärt uttrycksmönster \w+ # Matches all the characters in a word. ignoreras av motorn för reguljära uttryck.

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

Kommentarer

Metoden Regex.Replace(String, String, MatchEvaluator, RegexOptions) är användbar för att ersätta en reguljär uttrycksmatchning om något av följande villkor är sant:

• Om ersättningssträngen inte enkelt kan anges med ett mönster för ersättning av reguljära uttryck.

• Om ersättningssträngen är resultatet av viss bearbetning som utförs på den matchade strängen.

• Om ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String, String, RegexOptions) metoden och skicka varje Match objekt i den returnerade MatchCollection samlingen till ombudet evaluator .

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Om du anger RightToLeft parametern options börjar sökningen efter matchningar i slutet av indatasträngen och flyttas åt vänster. Annars börjar sökningen i början av indatasträngen och flyttas åt höger.

Parametern matchTimeout anger hur länge en mönstermatchningsmetod ska försöka hitta en matchning innan tidsgränsen uppnås. Om du anger ett tidsgränsintervall förhindras reguljära uttryck som förlitar sig på överdriven bakåtspårning från att visas som "sluta svara när de bearbetar indata som innehåller nära matchningar. Mer information finns i Metodtips för reguljära uttryck och bakåtspårning. Om ingen matchning hittas i det tidsintervallet utlöser metoden ett RegexMatchTimeoutException undantag. matchTimeout åsidosätter alla standardvärden för timeout som definierats för programdomänen där metoden körs.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Anteckningar till anropare

Vi rekommenderar att du anger parametern matchTimeout till ett lämpligt värde, till exempel två sekunder. Om du inaktiverar tidsgränser genom att ange ger motorn för reguljära InfiniteMatchTimeoututtryck något bättre prestanda. Du bör dock inaktivera tidsgränser endast under följande villkor:

• När indata som bearbetas av ett reguljärt uttryck härleds från en känd och betrodd källa eller består av statisk text. Detta exkluderar text som har matats in dynamiskt av användare.

• När mönstret för reguljära uttryck har testats noggrant för att säkerställa att det effektivt hanterar matchningar, icke-matchningar och nära matchningar.

• När det reguljära uttrycksmönstret inte innehåller några språkelement som är kända för att orsaka överdriven bakåtspårning vid bearbetning av en nära matchning.

Se även

• RegexOptions
• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck
• Bakåtspårning i reguljära uttryck
• Bäste metoder för reguljära uttryck i .NET

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används Replace(String, String, String, RegexOptions, TimeSpan) metoden för att ersätta den lokala datorn och enhetsnamnen i en UNC-sökväg med en lokal filsökväg. Det reguljära uttrycket använder Environment.MachineName egenskapen för att inkludera namnet på den lokala datorn och Environment.GetLogicalDrives metoden för att inkludera namnen på de logiska enheterna. Alla jämförelser av reguljära uttryckssträngar är skiftlägesokänsliga och en enskild ersättningsåtgärd överskrider tidsgränsen om en matchning inte kan hittas på 0,5 sekunder. Om du vill köra exemplet bör du ersätta strängen "MyMachine" med namnet på den lokala datorn.

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

Mönstret för reguljära uttryck definieras av följande uttryck:

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

I följande tabell visas hur mönstret för reguljära uttryck tolkas.

Mönster	Description
\\\\	Matcha två på varandra följande omvänt snedstreck (\) tecken. Eftersom omvänt snedstreck tolkas som escape-tecknet måste varje omvänt snedstreck undvikas med ett annat omvänt snedstreck.
+ Environment.MachineName +	Matcha strängen som returneras av egenskapen Environment.MachineName .
(?:\.\w+)*	Matcha punkttecknet (.) följt av ett eller flera ordtecken. Den här matchning kan inträffa noll eller fler gånger. Den matchade underuttrycket registreras inte.
\\	Matcha ett omvänt snedstreck (\) tecken.
([" + driveNames + "])	Matcha teckenklassen som består av de enskilda enhetsbeteckningarna. Den här matchningen är den första insamlade subexpressionen.
\$	Matcha teckentecknet för literal dollar ($).

Ersättningsmönstret $1 ersätter hela matchningen med den första insamlade subexpressionen. Det vill: den ersätter UNC-datorn och enhetsnamnet med enhetsbeteckningen.

Kommentarer

De statiska Replace metoderna motsvarar konstruera ett Regex objekt med det angivna reguljära uttrycksmönstret och anropa instansmetoden Replace.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens. Om du anger RightToLeft parametern options börjar sökningen efter matchningar i slutet av indatasträngen och flyttas åt vänster. Annars börjar sökningen i början av indatasträngen och flyttas åt höger.

Parametern replacement anger den sträng som ska ersätta varje matchning i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Parametern matchTimeout anger hur länge en mönstermatchningsmetod ska försöka hitta en matchning innan tidsgränsen uppnås. Om du anger ett tidsgränsintervall förhindras reguljära uttryck som förlitar sig på överdriven bakåtspårning från att verka sluta svara när de bearbetar indata som innehåller nära matchningar. Mer information finns i Metodtips för reguljära uttryck och bakåtspårning. Om ingen matchning hittas i det tidsintervallet utlöser metoden ett RegexMatchTimeoutException undantag. matchTimeout åsidosätter alla standardvärden för timeout som definierats för programdomänen där metoden körs.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Anteckningar till anropare

Vi rekommenderar att du anger parametern matchTimeout till ett lämpligt värde, till exempel två sekunder. Om du inaktiverar tidsgränser genom att ange ger motorn för reguljära InfiniteMatchTimeoututtryck något bättre prestanda. Du bör dock inaktivera tidsgränser endast under följande villkor:

• När indata som bearbetas av ett reguljärt uttryck härleds från en känd och betrodd källa eller består av statisk text. Detta exkluderar text som har matats in dynamiskt av användare.

• När mönstret för reguljära uttryck har testats noggrant för att säkerställa att det effektivt hanterar matchningar, icke-matchningar och nära matchningar.

• När det reguljära uttrycksmönstret inte innehåller några språkelement som är kända för att orsaka överdriven bakåtspårning vid bearbetning av en nära matchning.

Se även

• RegexOptions
• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck
• Bakåtspårning i reguljära uttryck
• Bäste metoder för reguljära uttryck i .NET

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att en ersättningssträng ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Kommentarer

Metoden Regex.Replace(String, MatchEvaluator, Int32, Int32) är användbar för att ersätta en reguljär uttrycksmatchning om något av följande villkor är sant:

• Ersättningssträngen kan inte enkelt anges med ett ersättningsmönster för reguljära uttryck.
• Ersättningssträngen är resultatet av viss bearbetning som utförts på den matchade strängen.
• Ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String, Int32) metoden och skicka de förstaMatchcountobjekten i den returnerade MatchCollection samlingen till ombudetevaluator.

Mer information om startatfinns i avsnittet Kommentarer i Match(String, Int32).

Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• MatchEvaluator
• Ersättningar i reguljära uttryck
• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att en ersättningssträng ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används ett reguljärt uttryck för att extrahera enskilda ord från en sträng och använder sedan ett MatchEvaluator ombud för att anropa en metod med namnet WordScramble som förvränger de enskilda bokstäverna i ordet. För att göra detta WordScramble skapar metoden en matris som innehåller tecknen i matchningen. Den skapar också en parallell matris som fylls i med slumpmässiga flyttalsnummer. Matriserna sorteras genom att anropa Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metoden och den sorterade matrisen tillhandahålls som ett argument till en String klasskonstruktor. Den här nyskapade strängen WordScramble returneras sedan av metoden . Det reguljära uttrycksmönstret \w+ matchar ett eller flera ordtecken. Motorn för reguljära uttryck fortsätter att lägga till tecken i matchningen tills det stöter på ett icke-ordtecken, till exempel ett blankstegstecken. Anropet Replace(String, String, MatchEvaluator, RegexOptions) till metoden innehåller RegexOptions.IgnorePatternWhitespace alternativet så att kommentaren i reguljärt uttrycksmönster \w+ # Matches all the characters in a word. ignoreras av motorn för reguljära uttryck.

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

Kommentarer

Metoden Regex.Replace(String, String, MatchEvaluator, RegexOptions) är användbar för att ersätta en reguljär uttrycksmatchning i om något av följande villkor är sant:

• Ersättningssträngen kan inte enkelt anges med ett ersättningsmönster för reguljära uttryck.

• Ersättningssträngen är resultatet av viss bearbetning som utförts på den matchade strängen.

• Ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String, String, RegexOptions) metoden och skicka varje Match objekt i den returnerade MatchCollection samlingen till ombudet evaluator .

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Om du anger RightToLeft parametern options börjar sökningen efter matchningar i slutet av indatasträngen och flyttas åt vänster. Annars börjar sökningen i början av indatasträngen och flyttas åt höger.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• MatchEvaluator
• RegexOptions
• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel dubblas alla utom den första raden i en sträng. Den definierar ett mönster för reguljära uttryck, ^.*$, som matchar en textrad, anropar Match(String) metoden för att matcha den första raden i strängen och använder Match.Index egenskaperna och Match.Count för att fastställa startpositionen för den andra raden.

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.

Mönster för ^.*$ reguljära uttryck definieras enligt följande tabell.

Mönster	Description
^	Matcha början av en rad. (Observera att Regex objektet instansierades med hjälp RegexOptions.Multiline av alternativet. Annars skulle den här teckenklassen endast matcha början av indatasträngen.)
.*	Matcha alla tecken noll eller fler gånger.
$	Matcha slutet av en rad. (Observera att Regex objektet instansierades med hjälp RegexOptions.Multiline av alternativet. Annars skulle den här teckenklassen endast matcha början av indatasträngen.)

Ersättningssträngen (vbCrLf + "$&" i Visual Basic, "\n$&" i C#) lägger till en ny rad före den matchade strängen. Observera att \n C#-exemplet tolkas som det nya radtecknet av C#-kompilatorn. Det representerar inte ett reguljärt uttryck.

Kommentarer

Sökningen efter matchningar startar i strängen input vid den position som anges av parametern startat . Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet. Om count är negativt fortsätter ersättningarna till slutet av strängen. Om count överskrider antalet matchningar ersätts alla matchningar.

Mer information om startatfinns i avsnittet Kommentarer i Match(String, Int32).

Parametern replacement anger den sträng som ska ersätta varje matchning i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• Ersättningar i reguljära uttryck
• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används Replace(String, String, String, RegexOptions) metoden för att ersätta den lokala datorn och enhetsnamnen i en UNC-sökväg med en lokal filsökväg. Det reguljära uttrycket använder Environment.MachineName egenskapen för att inkludera namnet på den lokala datorn och Environment.GetLogicalDrives metoden för att inkludera namnen på de logiska enheterna. Alla jämförelser av reguljära uttryckssträngar är skiftlägesokänsliga. Om du vill köra exemplet bör du ersätta strängen "MyMachine" med namnet på den lokala datorn.

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

Mönstret för reguljära uttryck definieras av följande uttryck:

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

I följande tabell visas hur mönstret för reguljära uttryck tolkas.

Mönster	Description
\\\\	Matcha två på varandra följande omvänt snedstreck (\) tecken. Eftersom omvänt snedstreck tolkas som escape-tecknet måste varje omvänt snedstreck undvikas med ett annat omvänt snedstreck.
+ Environment.MachineName +	Matcha strängen som returneras av egenskapen Environment.MachineName .
(?:\.\w+)*	Matcha punkttecknet (.) följt av ett eller flera ordtecken. Den här matchning kan inträffa noll eller fler gånger. Den matchade underuttrycket registreras inte.
\\	Matcha ett omvänt snedstreck (\) tecken.
([" + driveNames + "])	Matcha teckenklassen som består av de enskilda enhetsbeteckningarna. Den här matchningen är den första insamlade subexpressionen.
\$	Matcha teckentecknet för literal dollar ($).

Ersättningsmönstret $1 ersätter hela matchningen med den första insamlade subexpressionen. Det vill: den ersätter UNC-datorn och enhetsnamnet med enhetsbeteckningen.

Kommentarer

De statiska Replace metoderna motsvarar konstruera ett Regex objekt med det angivna reguljära uttrycksmönstret och anropa instansmetoden Replace.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens. Om du anger RightToLeft parametern options börjar sökningen efter matchningar i slutet av indatasträngen och flyttas åt vänster. Annars börjar sökningen i början av indatasträngen och flyttas åt höger.

Parametern replacement anger den sträng som ska ersätta varje matchning i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Anteckningar till anropare

Den här metoden överskrider tidsgränsen efter ett intervall som är lika med standardvärdet för timeout för den programdomän där den anropas. Om ett timeout-värde inte har definierats för programdomänen används värdet InfiniteMatchTimeout, som förhindrar att metoden överskrider tidsgränsen. Den rekommenderade statiska metoden för att ersätta en mönstermatchning är Replace(String, String, String, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

• RegexOptions
• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att en ersättningssträng ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används ett reguljärt uttryck för att extrahera enskilda ord från en sträng och använder sedan ett MatchEvaluator ombud för att anropa en metod med namnet WordScramble som förvränger de enskilda bokstäverna i ordet. För att göra detta WordScramble skapar metoden en matris som innehåller tecknen i matchningen. Den skapar också en parallell matris som fylls i med slumpmässiga flyttalsnummer. Matriserna sorteras genom att anropa Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metoden och den sorterade matrisen tillhandahålls som ett argument till en String klasskonstruktor. Den här nyskapade strängen WordScramble returneras sedan av metoden . Det reguljära uttrycksmönstret \w+ matchar ett eller flera ordtecken. Motorn för reguljära uttryck fortsätter att lägga till tecken i matchningen tills det stöter på ett icke-ordtecken, till exempel ett blankstegstecken.

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

Kommentarer

Metoden Regex.Replace(String, String, MatchEvaluator) är användbar för att ersätta en reguljär uttrycksmatchning om något av följande villkor är sant:

• Ersättningssträngen kan inte enkelt anges med ett ersättningsmönster för reguljära uttryck.

• Ersättningssträngen är resultatet av viss bearbetning som utförts på den matchade strängen.

• Ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String, String) metoden och skicka varje Match objekt i den returnerade MatchCollection samlingen till ombudet evaluator .

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Anteckningar till anropare

Den här metoden överskrider tidsgränsen efter ett intervall som är lika med standardvärdet för timeout för den programdomän där den anropas. Om ett timeout-värde inte har definierats för programdomänen används värdet InfiniteMatchTimeout, som förhindrar att metoden överskrider tidsgränsen. Den rekommenderade statiska metoden för att utvärdera och ersätta en mönstermatchning är Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

• MatchEvaluator
• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om pattern inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel definieras ett reguljärt uttryck, \s+, som matchar ett eller flera blankstegstecken. Ersättningssträngen , " ", ersätter dem med ett enda blankstegstecken.

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.

I följande exempel används Replace(String, String, String) metoden för att ersätta den lokala datorn och enhetsnamnen i en UNC-sökväg med en lokal filsökväg. Det reguljära uttrycket använder Environment.MachineName egenskapen för att inkludera namnet på den lokala datorn och Environment.GetLogicalDrives metoden för att inkludera namnen på de logiska enheterna. Om du vill köra exemplet bör du ersätta strängen "MyMachine" med namnet på den lokala datorn.

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

Mönstret för reguljära uttryck definieras av följande uttryck:

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

I följande tabell visas hur mönstret för reguljära uttryck tolkas.

Mönster	Description
\\\\	Matcha två på varandra följande omvänt snedstreck (\) tecken. Eftersom omvänt snedstreck tolkas som escape-tecknet måste varje omvänt snedstreck undvikas med ett annat omvänt snedstreck.
(?i:" + Environment.MachineName + ")	Utför en skiftlägeskänslig matchning av strängen som returneras av Environment.MachineName egenskapen.
(?:\.\w+)*	Matcha punkttecknet (.) följt av ett eller flera ordtecken. Den här matchning kan inträffa noll eller fler gånger. Den matchade underuttrycket registreras inte.
\\	Matcha ett omvänt snedstreck (\) tecken.
((?i:[" + driveNames + "]))	Utför en skiftlägeskänslig matchning av teckenklassen som består av de enskilda enhetsbeteckningarna. Den här matchningen är den första insamlade subexpressionen.
\$	Matcha teckentecknet för literal dollar ($).

Ersättningsmönstret $1 ersätter hela matchningen med den första insamlade subexpressionen. Det vill: den ersätter UNC-datorn och enhetsnamnet med enhetsbeteckningen.

Kommentarer

De statiska Replace metoderna motsvarar konstruera ett Regex objekt med det angivna reguljära uttrycksmönstret och anropa instansmetoden Replace.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i .NET reguljära uttryck och Regular Expression Language – Snabbreferens. Sökningen efter matchningar börjar i början av strängen input .

Parametern replacement anger den sträng som ska ersätta varje matchning i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som angetts för programdomänen där metoden anropas. Om ingen tidsgräns har definierats i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag.

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Anteckningar till anropare

Den här metoden överskrider tidsgränsen efter ett intervall som är lika med standardvärdet för timeout för den programdomän där den anropas. Om ett timeout-värde inte har definierats för programdomänen används värdet InfiniteMatchTimeout, som förhindrar att metoden överskrider tidsgränsen. Den rekommenderade statiska metoden för att ersätta en mönstermatchning är Replace(String, String, String, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

• Ersättningar i reguljära uttryck
• Språkelement för reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel ersätts de första fem förekomsterna av duplicerade tecken med ett enda tecken. Mönster för (\w)\1 reguljära uttryck matchar efterföljande förekomster av ett enskilt tecken och tilldelar den första förekomsten till den första insamlingsgruppen. Ersättningsmönstret $1 ersätter hela matchningen med den första insamlade gruppen.

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'

Kommentarer

Sökningen efter matchningar börjar i början av strängen input . Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet. Om count är negativt fortsätter ersättningarna till slutet av strängen. Om count överskrider antalet matchningar ersätts alla matchningar.

Parametern replacement anger den sträng som ska ersätta de första count matchningarna i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• Språk för reguljärt uttryck – snabbreferens
• Ersättningar i reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att en ersättningssträng ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande kodexempel visas en originalsträng, matchar varje ord i den ursprungliga strängen, konverterar det första tecknet för varje matchning till versaler och visar sedan den konverterade strängen.

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]

Kommentarer

Metoden Regex.Replace(String, MatchEvaluator) är användbar för att ersätta en reguljär uttrycksmatchning om något av följande villkor är sant:

• Ersättningssträngen kan inte enkelt anges med ett ersättningsmönster för reguljära uttryck.

• Ersättningssträngen är resultatet av viss bearbetning som utförts på den matchade strängen.

• Ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String) metoden och skicka varje Match objekt i den returnerade MatchCollection samlingen till ombudet evaluator .

Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• MatchEvaluator
• Ersättningar i reguljära uttryck
• Språk för reguljärt uttryck – snabbreferens

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att ersättningssträngen ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel definieras ett reguljärt uttryck, \s+, som matchar ett eller flera blankstegstecken. Ersättningssträngen , " ", ersätter dem med ett enda blankstegstecken.

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.

I följande exempel definieras ett reguljärt uttryck, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, och ett ersättningsmönster, $2, som tar bort antingen en inledande eller en avslutande valutasymbol från ett numeriskt värde.

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'

Det reguljära uttrycket tolkas som det visas i följande tabell.

Mönster	Description
\p{Sc}	Matcha en valutasymbol. {Sc} anger alla tecken som är medlemmar i kategorin Unicode-symbol, valuta.
\s?	Matcha noll eller ett vitt tecken.
(\p{Sc}\s?)?	Matcha noll eller en förekomst av kombinationen av en valutasymbol följt av noll eller ett blankstegstecken. Det här är den första fångstgruppen.
\d+	Matcha en eller flera decimaler.
\.?	Matcha noll eller en förekomst av en period (används som decimaltecken).
((?<=\.)\d+)?	Om en punkt är det föregående tecknet matchar du en eller flera decimalsiffror. Det här mönstret kan matchas antingen noll eller en gång.
(\d+\.?((?<=\.)\d+)?)	Matcha mönstret för en eller flera decimaler följt av en valfri period och ytterligare decimalsiffror. Det här är den andra fångstgruppen. Anropet Replace(String, String) till metoden ersätter hela matchningen med värdet för den här insamlade gruppen.
(?(1)|\s?\p{Sc})?	Om den första insamlade gruppen finns matchar du en tom sträng. Annars matchar du noll eller ett blankstegstecken följt av en valutasymbol.

Kommentarer

Sökningen efter matchningar börjar i början av strängen input . Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet.

Parametern replacement anger den sträng som ska ersätta varje matchning i input. replacement kan bestå av valfri kombination av literaltext och ersättningar. Ersättningsmönstret a*${test}b infogar till exempel strängen "a*" följt av den delsträng som matchas av den test eventuella insamlingsgruppen följt av strängen "b". *-tecknet identifieras inte som ett metakarakter i ett ersättningsmönster.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• Språk för reguljärt uttryck – snabbreferens
• Ersättningar i reguljära uttryck

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

Parametrar

Returer

En ny sträng som är identisk med indatasträngen, förutom att en ersättningssträng ersätter varje matchad sträng. Om mönstret för reguljära uttryck inte matchas i den aktuella instansen returnerar metoden den aktuella instansen oförändrad.

Undantag

Exempel

I följande exempel används ett reguljärt uttryck för att avsiktligt felstava hälften av orden i en lista. Det använder det reguljära uttrycket \w*(ie|ei)\w* för att matcha ord som innehåller tecknen "ie" eller "ei". Den skickar den första halvan av matchande ord till ReverseLetter metoden, som i sin tur använder Replace(String, String, String, RegexOptions) metoden för att vända "i" och "e" i den matchade strängen. De återstående orden förblir oförändrade.

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

Det reguljära uttrycket \w*(ie|ei)\w* definieras enligt följande tabell.

Mönster	Description
\w*	Matcha noll eller fler ordtecken.
(ie|ei)	Matcha antingen "ie" eller "ei".
\w*	Matcha noll eller fler ordtecken.

Mönstret ([ie])([ie]) för reguljära uttryck i ReverseLetter metoden matchar det första "i" eller "e" i diftongen "ie" eller "ei" och tilldelar bokstaven till den första insamlingsgruppen. Den matchar det andra "i" eller "e" och tilldelar bokstaven till den andra insamlingsgruppen. De två tecknen återställs sedan genom att metoden anropas Replace(String, String, String) med ersättningsmönstret $2$1.

Kommentarer

Metoden Regex.Replace(String, MatchEvaluator, Int32) är användbar för att ersätta en reguljär uttrycksmatchning om något av följande villkor är sant:

• Ersättningssträngen kan inte enkelt anges med ett ersättningsmönster för reguljära uttryck.

• Ersättningssträngen är resultatet av viss bearbetning som utförts på den matchade strängen.

• Ersättningssträngen är resultatet av villkorsstyrd bearbetning.

Metoden motsvarar att anropa Regex.Matches(String) metoden och skicka de förstaMatchcountobjekten i den returnerade MatchCollection samlingen till ombudetevaluator.

Det reguljära uttrycket är det mönster som definieras av konstruktorn för det aktuella Regex objektet.

Parametern evaluator är ombudet för en anpassad metod som du definierar och som undersöker varje matchning. Den anpassade metoden måste ha följande signatur för att matcha ombudet MatchEvaluator .

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Din anpassade metod returnerar en sträng som ersätter de matchade indata.

Undantaget RegexMatchTimeoutException utlöses om körningstiden för ersättningsåtgärden överskrider det tidsgränsintervall som anges av Regex.Regex(String, RegexOptions, TimeSpan) konstruktorn. Om du inte anger ett tidsgränsintervall när du anropar konstruktorn utlöses undantaget om åtgärden överskrider ett timeout-värde som har upprättats för programdomänen Regex där objektet skapas. Om ingen tidsgräns har definierats i konstruktoranropet Regex eller i programdomänens egenskaper, eller om tidsgränsvärdet är Regex.InfiniteMatchTimeout, genereras inget undantag

Eftersom metoden returnerar input oförändrad om det inte finns någon matchning kan du använda Object.ReferenceEquals metoden för att avgöra om metoden har gjort några ersättningar till indatasträngen.

Se även

• MatchEvaluator
• Ersättningar i reguljära uttryck
• Språk för reguljärt uttryck – snabbreferens